1 /* NFS filesystem cache interface
3 * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/sched.h>
16 #include <linux/nfs_fs.h>
17 #include <linux/nfs_fs_sb.h>
18 #include <linux/in6.h>
19 #include <linux/seq_file.h>
20 #include <linux/slab.h>
26 #define NFSDBG_FACILITY NFSDBG_FSCACHE
28 static struct rb_root nfs_fscache_keys
= RB_ROOT
;
29 static DEFINE_SPINLOCK(nfs_fscache_keys_lock
);
32 * Get the per-client index cookie for an NFS client if the appropriate mount
34 * - We always try and get an index cookie for the client, but get filehandle
35 * cookies on a per-superblock basis, depending on the mount flags
37 void nfs_fscache_get_client_cookie(struct nfs_client
*clp
)
39 /* create a cache index for looking up filehandles */
40 clp
->fscache
= fscache_acquire_cookie(nfs_fscache_netfs
.primary_index
,
41 &nfs_fscache_server_index_def
,
43 dfprintk(FSCACHE
, "NFS: get client cookie (0x%p/0x%p)\n",
48 * Dispose of a per-client cookie
50 void nfs_fscache_release_client_cookie(struct nfs_client
*clp
)
52 dfprintk(FSCACHE
, "NFS: releasing client cookie (0x%p/0x%p)\n",
55 fscache_relinquish_cookie(clp
->fscache
, 0);
59 void nfs_fscache_get_super_cookie(struct super_block
*sb
, const char *uniq
,
60 struct nfs_clone_mount
*mntdata
)
62 struct nfs_fscache_key
*key
, *xkey
;
63 struct nfs_server
*nfss
= NFS_SB(sb
);
64 struct rb_node
**p
, *parent
;
70 struct nfs_server
*mnt_s
= NFS_SB(mntdata
->sb
);
71 if (mnt_s
->fscache_key
) {
72 uniq
= mnt_s
->fscache_key
->key
.uniquifier
;
73 ulen
= mnt_s
->fscache_key
->key
.uniq_len
;
82 key
= kzalloc(sizeof(*key
) + ulen
, GFP_KERNEL
);
86 key
->nfs_client
= nfss
->nfs_client
;
87 key
->key
.super
.s_flags
= sb
->s_flags
& NFS_MS_MASK
;
88 key
->key
.nfs_server
.flags
= nfss
->flags
;
89 key
->key
.nfs_server
.rsize
= nfss
->rsize
;
90 key
->key
.nfs_server
.wsize
= nfss
->wsize
;
91 key
->key
.nfs_server
.acregmin
= nfss
->acregmin
;
92 key
->key
.nfs_server
.acregmax
= nfss
->acregmax
;
93 key
->key
.nfs_server
.acdirmin
= nfss
->acdirmin
;
94 key
->key
.nfs_server
.acdirmax
= nfss
->acdirmax
;
95 key
->key
.nfs_server
.fsid
= nfss
->fsid
;
96 key
->key
.rpc_auth
.au_flavor
= nfss
->client
->cl_auth
->au_flavor
;
98 key
->key
.uniq_len
= ulen
;
99 memcpy(key
->key
.uniquifier
, uniq
, ulen
);
101 spin_lock(&nfs_fscache_keys_lock
);
102 p
= &nfs_fscache_keys
.rb_node
;
106 xkey
= rb_entry(parent
, struct nfs_fscache_key
, node
);
108 if (key
->nfs_client
< xkey
->nfs_client
)
110 if (key
->nfs_client
> xkey
->nfs_client
)
113 diff
= memcmp(&key
->key
, &xkey
->key
, sizeof(key
->key
));
119 if (key
->key
.uniq_len
== 0)
121 diff
= memcmp(key
->key
.uniquifier
,
122 xkey
->key
.uniquifier
,
137 rb_link_node(&key
->node
, parent
, p
);
138 rb_insert_color(&key
->node
, &nfs_fscache_keys
);
139 spin_unlock(&nfs_fscache_keys_lock
);
140 nfss
->fscache_key
= key
;
142 /* create a cache index for looking up filehandles */
143 nfss
->fscache
= fscache_acquire_cookie(nfss
->nfs_client
->fscache
,
144 &nfs_fscache_super_index_def
,
146 dfprintk(FSCACHE
, "NFS: get superblock cookie (0x%p/0x%p)\n",
147 nfss
, nfss
->fscache
);
151 spin_unlock(&nfs_fscache_keys_lock
);
153 nfss
->fscache_key
= NULL
;
154 nfss
->fscache
= NULL
;
155 printk(KERN_WARNING
"NFS:"
156 " Cache request denied due to non-unique superblock keys\n");
160 * release a per-superblock cookie
162 void nfs_fscache_release_super_cookie(struct super_block
*sb
)
164 struct nfs_server
*nfss
= NFS_SB(sb
);
166 dfprintk(FSCACHE
, "NFS: releasing superblock cookie (0x%p/0x%p)\n",
167 nfss
, nfss
->fscache
);
169 fscache_relinquish_cookie(nfss
->fscache
, 0);
170 nfss
->fscache
= NULL
;
172 if (nfss
->fscache_key
) {
173 spin_lock(&nfs_fscache_keys_lock
);
174 rb_erase(&nfss
->fscache_key
->node
, &nfs_fscache_keys
);
175 spin_unlock(&nfs_fscache_keys_lock
);
176 kfree(nfss
->fscache_key
);
177 nfss
->fscache_key
= NULL
;
182 * Initialise the per-inode cache cookie pointer for an NFS inode.
184 void nfs_fscache_init_inode_cookie(struct inode
*inode
)
186 NFS_I(inode
)->fscache
= NULL
;
187 if (S_ISREG(inode
->i_mode
))
188 set_bit(NFS_INO_FSCACHE
, &NFS_I(inode
)->flags
);
192 * Get the per-inode cache cookie for an NFS inode.
194 static void nfs_fscache_enable_inode_cookie(struct inode
*inode
)
196 struct super_block
*sb
= inode
->i_sb
;
197 struct nfs_inode
*nfsi
= NFS_I(inode
);
199 if (nfsi
->fscache
|| !NFS_FSCACHE(inode
))
202 if ((NFS_SB(sb
)->options
& NFS_OPTION_FSCACHE
)) {
203 nfsi
->fscache
= fscache_acquire_cookie(
205 &nfs_fscache_inode_object_def
,
208 dfprintk(FSCACHE
, "NFS: get FH cookie (0x%p/0x%p/0x%p)\n",
209 sb
, nfsi
, nfsi
->fscache
);
214 * Release a per-inode cookie.
216 void nfs_fscache_release_inode_cookie(struct inode
*inode
)
218 struct nfs_inode
*nfsi
= NFS_I(inode
);
220 dfprintk(FSCACHE
, "NFS: clear cookie (0x%p/0x%p)\n",
221 nfsi
, nfsi
->fscache
);
223 fscache_relinquish_cookie(nfsi
->fscache
, 0);
224 nfsi
->fscache
= NULL
;
228 * Retire a per-inode cookie, destroying the data attached to it.
230 void nfs_fscache_zap_inode_cookie(struct inode
*inode
)
232 struct nfs_inode
*nfsi
= NFS_I(inode
);
234 dfprintk(FSCACHE
, "NFS: zapping cookie (0x%p/0x%p)\n",
235 nfsi
, nfsi
->fscache
);
237 fscache_relinquish_cookie(nfsi
->fscache
, 1);
238 nfsi
->fscache
= NULL
;
242 * Turn off the cache with regard to a per-inode cookie if opened for writing,
243 * invalidating all the pages in the page cache relating to the associated
244 * inode to clear the per-page caching.
246 static void nfs_fscache_disable_inode_cookie(struct inode
*inode
)
248 clear_bit(NFS_INO_FSCACHE
, &NFS_I(inode
)->flags
);
250 if (NFS_I(inode
)->fscache
) {
252 "NFS: nfsi 0x%p turning cache off\n", NFS_I(inode
));
254 /* Need to invalidate any mapped pages that were read in before
255 * turning off the cache.
257 if (inode
->i_mapping
&& inode
->i_mapping
->nrpages
)
258 invalidate_inode_pages2(inode
->i_mapping
);
260 nfs_fscache_zap_inode_cookie(inode
);
265 * wait_on_bit() sleep function for uninterruptible waiting
267 static int nfs_fscache_wait_bit(void *flags
)
274 * Lock against someone else trying to also acquire or relinquish a cookie
276 static inline void nfs_fscache_inode_lock(struct inode
*inode
)
278 struct nfs_inode
*nfsi
= NFS_I(inode
);
280 while (test_and_set_bit(NFS_INO_FSCACHE_LOCK
, &nfsi
->flags
))
281 wait_on_bit(&nfsi
->flags
, NFS_INO_FSCACHE_LOCK
,
282 nfs_fscache_wait_bit
, TASK_UNINTERRUPTIBLE
);
286 * Unlock cookie management lock
288 static inline void nfs_fscache_inode_unlock(struct inode
*inode
)
290 struct nfs_inode
*nfsi
= NFS_I(inode
);
292 smp_mb__before_clear_bit();
293 clear_bit(NFS_INO_FSCACHE_LOCK
, &nfsi
->flags
);
294 smp_mb__after_clear_bit();
295 wake_up_bit(&nfsi
->flags
, NFS_INO_FSCACHE_LOCK
);
299 * Decide if we should enable or disable local caching for this inode.
300 * - For now, with NFS, only regular files that are open read-only will be able
302 * - May be invoked multiple times in parallel by parallel nfs_open() functions.
304 void nfs_fscache_set_inode_cookie(struct inode
*inode
, struct file
*filp
)
306 if (NFS_FSCACHE(inode
)) {
307 nfs_fscache_inode_lock(inode
);
308 if ((filp
->f_flags
& O_ACCMODE
) != O_RDONLY
)
309 nfs_fscache_disable_inode_cookie(inode
);
311 nfs_fscache_enable_inode_cookie(inode
);
312 nfs_fscache_inode_unlock(inode
);
317 * Replace a per-inode cookie due to revalidation detecting a file having
318 * changed on the server.
320 void nfs_fscache_reset_inode_cookie(struct inode
*inode
)
322 struct nfs_inode
*nfsi
= NFS_I(inode
);
323 struct nfs_server
*nfss
= NFS_SERVER(inode
);
324 struct fscache_cookie
*old
= nfsi
->fscache
;
326 nfs_fscache_inode_lock(inode
);
328 /* retire the current fscache cache and get a new one */
329 fscache_relinquish_cookie(nfsi
->fscache
, 1);
331 nfsi
->fscache
= fscache_acquire_cookie(
332 nfss
->nfs_client
->fscache
,
333 &nfs_fscache_inode_object_def
,
337 "NFS: revalidation new cookie (0x%p/0x%p/0x%p/0x%p)\n",
338 nfss
, nfsi
, old
, nfsi
->fscache
);
340 nfs_fscache_inode_unlock(inode
);
344 * Release the caching state associated with a page, if the page isn't busy
345 * interacting with the cache.
346 * - Returns true (can release page) or false (page busy).
348 int nfs_fscache_release_page(struct page
*page
, gfp_t gfp
)
350 if (PageFsCache(page
)) {
351 struct nfs_inode
*nfsi
= NFS_I(page
->mapping
->host
);
352 struct fscache_cookie
*cookie
= nfsi
->fscache
;
355 dfprintk(FSCACHE
, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n",
358 if (!fscache_maybe_release_page(cookie
, page
, gfp
))
361 nfs_add_fscache_stats(page
->mapping
->host
,
362 NFSIOS_FSCACHE_PAGES_UNCACHED
, 1);
369 * Release the caching state associated with a page if undergoing complete page
372 void __nfs_fscache_invalidate_page(struct page
*page
, struct inode
*inode
)
374 struct nfs_inode
*nfsi
= NFS_I(inode
);
375 struct fscache_cookie
*cookie
= nfsi
->fscache
;
379 dfprintk(FSCACHE
, "NFS: fscache invalidatepage (0x%p/0x%p/0x%p)\n",
382 fscache_wait_on_page_write(cookie
, page
);
384 BUG_ON(!PageLocked(page
));
385 fscache_uncache_page(cookie
, page
);
386 nfs_add_fscache_stats(page
->mapping
->host
,
387 NFSIOS_FSCACHE_PAGES_UNCACHED
, 1);
391 * Handle completion of a page being read from the cache.
392 * - Called in process (keventd) context.
394 static void nfs_readpage_from_fscache_complete(struct page
*page
,
399 "NFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n",
400 page
, context
, error
);
402 /* if the read completes with an error, we just unlock the page and let
403 * the VM reissue the readpage */
405 SetPageUptodate(page
);
408 error
= nfs_readpage_async(context
, page
->mapping
->host
, page
);
415 * Retrieve a page from fscache
417 int __nfs_readpage_from_fscache(struct nfs_open_context
*ctx
,
418 struct inode
*inode
, struct page
*page
)
423 "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n",
424 NFS_I(inode
)->fscache
, page
, page
->index
, page
->flags
, inode
);
426 ret
= fscache_read_or_alloc_page(NFS_I(inode
)->fscache
,
428 nfs_readpage_from_fscache_complete
,
433 case 0: /* read BIO submitted (page in fscache) */
435 "NFS: readpage_from_fscache: BIO submitted\n");
436 nfs_add_fscache_stats(inode
, NFSIOS_FSCACHE_PAGES_READ_OK
, 1);
439 case -ENOBUFS
: /* inode not in cache */
440 case -ENODATA
: /* page not in cache */
441 nfs_add_fscache_stats(inode
, NFSIOS_FSCACHE_PAGES_READ_FAIL
, 1);
443 "NFS: readpage_from_fscache %d\n", ret
);
447 dfprintk(FSCACHE
, "NFS: readpage_from_fscache %d\n", ret
);
448 nfs_add_fscache_stats(inode
, NFSIOS_FSCACHE_PAGES_READ_FAIL
, 1);
454 * Retrieve a set of pages from fscache
456 int __nfs_readpages_from_fscache(struct nfs_open_context
*ctx
,
458 struct address_space
*mapping
,
459 struct list_head
*pages
,
462 unsigned npages
= *nr_pages
;
465 dfprintk(FSCACHE
, "NFS: nfs_getpages_from_fscache (0x%p/%u/0x%p)\n",
466 NFS_I(inode
)->fscache
, npages
, inode
);
468 ret
= fscache_read_or_alloc_pages(NFS_I(inode
)->fscache
,
469 mapping
, pages
, nr_pages
,
470 nfs_readpage_from_fscache_complete
,
472 mapping_gfp_mask(mapping
));
473 if (*nr_pages
< npages
)
474 nfs_add_fscache_stats(inode
, NFSIOS_FSCACHE_PAGES_READ_OK
,
477 nfs_add_fscache_stats(inode
, NFSIOS_FSCACHE_PAGES_READ_FAIL
,
481 case 0: /* read submitted to the cache for all pages */
482 BUG_ON(!list_empty(pages
));
483 BUG_ON(*nr_pages
!= 0);
485 "NFS: nfs_getpages_from_fscache: submitted\n");
489 case -ENOBUFS
: /* some pages aren't cached and can't be */
490 case -ENODATA
: /* some pages aren't cached */
492 "NFS: nfs_getpages_from_fscache: no page: %d\n", ret
);
497 "NFS: nfs_getpages_from_fscache: ret %d\n", ret
);
504 * Store a newly fetched page in fscache
505 * - PG_fscache must be set on the page
507 void __nfs_readpage_to_fscache(struct inode
*inode
, struct page
*page
, int sync
)
512 "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n",
513 NFS_I(inode
)->fscache
, page
, page
->index
, page
->flags
, sync
);
515 ret
= fscache_write_page(NFS_I(inode
)->fscache
, page
, GFP_KERNEL
);
517 "NFS: readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n",
518 page
, page
->index
, page
->flags
, ret
);
521 fscache_uncache_page(NFS_I(inode
)->fscache
, page
);
522 nfs_add_fscache_stats(inode
,
523 NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL
, 1);
524 nfs_add_fscache_stats(inode
, NFSIOS_FSCACHE_PAGES_UNCACHED
, 1);
526 nfs_add_fscache_stats(inode
,
527 NFSIOS_FSCACHE_PAGES_WRITTEN_OK
, 1);