Commit | Line | Data |
---|---|---|
14727281 DH |
1 | /* NFS filesystem cache interface |
2 | * | |
3 | * Copyright (C) 2008 Red Hat, Inc. All Rights Reserved. | |
4 | * Written by David Howells (dhowells@redhat.com) | |
5 | * | |
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. | |
10 | */ | |
11 | ||
12 | #include <linux/init.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/sched.h> | |
15 | #include <linux/mm.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 | ||
21 | #include "internal.h" | |
545db45f | 22 | #include "iostat.h" |
14727281 DH |
23 | #include "fscache.h" |
24 | ||
25 | #define NFSDBG_FACILITY NFSDBG_FSCACHE | |
26 | ||
08734048 DH |
27 | static struct rb_root nfs_fscache_keys = RB_ROOT; |
28 | static DEFINE_SPINLOCK(nfs_fscache_keys_lock); | |
29 | ||
14727281 DH |
30 | /* |
31 | * Get the per-client index cookie for an NFS client if the appropriate mount | |
32 | * flag was set | |
33 | * - We always try and get an index cookie for the client, but get filehandle | |
34 | * cookies on a per-superblock basis, depending on the mount flags | |
35 | */ | |
36 | void nfs_fscache_get_client_cookie(struct nfs_client *clp) | |
37 | { | |
38 | /* create a cache index for looking up filehandles */ | |
39 | clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index, | |
40 | &nfs_fscache_server_index_def, | |
41 | clp); | |
42 | dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n", | |
43 | clp, clp->fscache); | |
44 | } | |
45 | ||
46 | /* | |
47 | * Dispose of a per-client cookie | |
48 | */ | |
49 | void nfs_fscache_release_client_cookie(struct nfs_client *clp) | |
50 | { | |
51 | dfprintk(FSCACHE, "NFS: releasing client cookie (0x%p/0x%p)\n", | |
52 | clp, clp->fscache); | |
53 | ||
54 | fscache_relinquish_cookie(clp->fscache, 0); | |
55 | clp->fscache = NULL; | |
56 | } | |
08734048 DH |
57 | |
58 | /* | |
59 | * Get the cache cookie for an NFS superblock. We have to handle | |
60 | * uniquification here because the cache doesn't do it for us. | |
2df54806 DH |
61 | * |
62 | * The default uniquifier is just an empty string, but it may be overridden | |
63 | * either by the 'fsc=xxx' option to mount, or by inheriting it from the parent | |
64 | * superblock across an automount point of some nature. | |
08734048 | 65 | */ |
2df54806 DH |
66 | void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, |
67 | struct nfs_clone_mount *mntdata) | |
08734048 DH |
68 | { |
69 | struct nfs_fscache_key *key, *xkey; | |
70 | struct nfs_server *nfss = NFS_SB(sb); | |
71 | struct rb_node **p, *parent; | |
08734048 DH |
72 | int diff, ulen; |
73 | ||
2df54806 DH |
74 | if (uniq) { |
75 | ulen = strlen(uniq); | |
76 | } else if (mntdata) { | |
77 | struct nfs_server *mnt_s = NFS_SB(mntdata->sb); | |
78 | if (mnt_s->fscache_key) { | |
79 | uniq = mnt_s->fscache_key->key.uniquifier; | |
80 | ulen = mnt_s->fscache_key->key.uniq_len; | |
81 | } | |
82 | } | |
83 | ||
84 | if (!uniq) { | |
85 | uniq = ""; | |
86 | ulen = 1; | |
87 | } | |
88 | ||
08734048 DH |
89 | key = kzalloc(sizeof(*key) + ulen, GFP_KERNEL); |
90 | if (!key) | |
91 | return; | |
92 | ||
93 | key->nfs_client = nfss->nfs_client; | |
94 | key->key.super.s_flags = sb->s_flags & NFS_MS_MASK; | |
95 | key->key.nfs_server.flags = nfss->flags; | |
96 | key->key.nfs_server.rsize = nfss->rsize; | |
97 | key->key.nfs_server.wsize = nfss->wsize; | |
98 | key->key.nfs_server.acregmin = nfss->acregmin; | |
99 | key->key.nfs_server.acregmax = nfss->acregmax; | |
100 | key->key.nfs_server.acdirmin = nfss->acdirmin; | |
101 | key->key.nfs_server.acdirmax = nfss->acdirmax; | |
102 | key->key.nfs_server.fsid = nfss->fsid; | |
103 | key->key.rpc_auth.au_flavor = nfss->client->cl_auth->au_flavor; | |
104 | ||
105 | key->key.uniq_len = ulen; | |
106 | memcpy(key->key.uniquifier, uniq, ulen); | |
107 | ||
108 | spin_lock(&nfs_fscache_keys_lock); | |
109 | p = &nfs_fscache_keys.rb_node; | |
110 | parent = NULL; | |
111 | while (*p) { | |
112 | parent = *p; | |
113 | xkey = rb_entry(parent, struct nfs_fscache_key, node); | |
114 | ||
115 | if (key->nfs_client < xkey->nfs_client) | |
116 | goto go_left; | |
117 | if (key->nfs_client > xkey->nfs_client) | |
118 | goto go_right; | |
119 | ||
120 | diff = memcmp(&key->key, &xkey->key, sizeof(key->key)); | |
121 | if (diff < 0) | |
122 | goto go_left; | |
123 | if (diff > 0) | |
124 | goto go_right; | |
125 | ||
126 | if (key->key.uniq_len == 0) | |
127 | goto non_unique; | |
128 | diff = memcmp(key->key.uniquifier, | |
129 | xkey->key.uniquifier, | |
130 | key->key.uniq_len); | |
131 | if (diff < 0) | |
132 | goto go_left; | |
133 | if (diff > 0) | |
134 | goto go_right; | |
135 | goto non_unique; | |
136 | ||
137 | go_left: | |
138 | p = &(*p)->rb_left; | |
139 | continue; | |
140 | go_right: | |
141 | p = &(*p)->rb_right; | |
142 | } | |
143 | ||
144 | rb_link_node(&key->node, parent, p); | |
145 | rb_insert_color(&key->node, &nfs_fscache_keys); | |
146 | spin_unlock(&nfs_fscache_keys_lock); | |
147 | nfss->fscache_key = key; | |
148 | ||
149 | /* create a cache index for looking up filehandles */ | |
150 | nfss->fscache = fscache_acquire_cookie(nfss->nfs_client->fscache, | |
151 | &nfs_fscache_super_index_def, | |
152 | nfss); | |
153 | dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n", | |
154 | nfss, nfss->fscache); | |
155 | return; | |
156 | ||
157 | non_unique: | |
158 | spin_unlock(&nfs_fscache_keys_lock); | |
159 | kfree(key); | |
160 | nfss->fscache_key = NULL; | |
161 | nfss->fscache = NULL; | |
162 | printk(KERN_WARNING "NFS:" | |
163 | " Cache request denied due to non-unique superblock keys\n"); | |
164 | } | |
165 | ||
166 | /* | |
167 | * release a per-superblock cookie | |
168 | */ | |
169 | void nfs_fscache_release_super_cookie(struct super_block *sb) | |
170 | { | |
171 | struct nfs_server *nfss = NFS_SB(sb); | |
172 | ||
173 | dfprintk(FSCACHE, "NFS: releasing superblock cookie (0x%p/0x%p)\n", | |
174 | nfss, nfss->fscache); | |
175 | ||
176 | fscache_relinquish_cookie(nfss->fscache, 0); | |
177 | nfss->fscache = NULL; | |
178 | ||
179 | if (nfss->fscache_key) { | |
180 | spin_lock(&nfs_fscache_keys_lock); | |
181 | rb_erase(&nfss->fscache_key->node, &nfs_fscache_keys); | |
182 | spin_unlock(&nfs_fscache_keys_lock); | |
183 | kfree(nfss->fscache_key); | |
184 | nfss->fscache_key = NULL; | |
185 | } | |
186 | } | |
ef79c097 DH |
187 | |
188 | /* | |
189 | * Initialise the per-inode cache cookie pointer for an NFS inode. | |
190 | */ | |
191 | void nfs_fscache_init_inode_cookie(struct inode *inode) | |
192 | { | |
193 | NFS_I(inode)->fscache = NULL; | |
194 | if (S_ISREG(inode->i_mode)) | |
195 | set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags); | |
196 | } | |
197 | ||
198 | /* | |
199 | * Get the per-inode cache cookie for an NFS inode. | |
200 | */ | |
201 | static void nfs_fscache_enable_inode_cookie(struct inode *inode) | |
202 | { | |
203 | struct super_block *sb = inode->i_sb; | |
204 | struct nfs_inode *nfsi = NFS_I(inode); | |
205 | ||
206 | if (nfsi->fscache || !NFS_FSCACHE(inode)) | |
207 | return; | |
208 | ||
209 | if ((NFS_SB(sb)->options & NFS_OPTION_FSCACHE)) { | |
210 | nfsi->fscache = fscache_acquire_cookie( | |
211 | NFS_SB(sb)->fscache, | |
212 | &nfs_fscache_inode_object_def, | |
213 | nfsi); | |
214 | ||
215 | dfprintk(FSCACHE, "NFS: get FH cookie (0x%p/0x%p/0x%p)\n", | |
216 | sb, nfsi, nfsi->fscache); | |
217 | } | |
218 | } | |
219 | ||
220 | /* | |
221 | * Release a per-inode cookie. | |
222 | */ | |
223 | void nfs_fscache_release_inode_cookie(struct inode *inode) | |
224 | { | |
225 | struct nfs_inode *nfsi = NFS_I(inode); | |
226 | ||
227 | dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", | |
228 | nfsi, nfsi->fscache); | |
229 | ||
230 | fscache_relinquish_cookie(nfsi->fscache, 0); | |
231 | nfsi->fscache = NULL; | |
232 | } | |
233 | ||
234 | /* | |
235 | * Retire a per-inode cookie, destroying the data attached to it. | |
236 | */ | |
237 | void nfs_fscache_zap_inode_cookie(struct inode *inode) | |
238 | { | |
239 | struct nfs_inode *nfsi = NFS_I(inode); | |
240 | ||
241 | dfprintk(FSCACHE, "NFS: zapping cookie (0x%p/0x%p)\n", | |
242 | nfsi, nfsi->fscache); | |
243 | ||
244 | fscache_relinquish_cookie(nfsi->fscache, 1); | |
245 | nfsi->fscache = NULL; | |
246 | } | |
247 | ||
248 | /* | |
249 | * Turn off the cache with regard to a per-inode cookie if opened for writing, | |
250 | * invalidating all the pages in the page cache relating to the associated | |
251 | * inode to clear the per-page caching. | |
252 | */ | |
253 | static void nfs_fscache_disable_inode_cookie(struct inode *inode) | |
254 | { | |
255 | clear_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags); | |
256 | ||
257 | if (NFS_I(inode)->fscache) { | |
258 | dfprintk(FSCACHE, | |
259 | "NFS: nfsi 0x%p turning cache off\n", NFS_I(inode)); | |
260 | ||
261 | /* Need to invalidate any mapped pages that were read in before | |
262 | * turning off the cache. | |
263 | */ | |
264 | if (inode->i_mapping && inode->i_mapping->nrpages) | |
265 | invalidate_inode_pages2(inode->i_mapping); | |
266 | ||
267 | nfs_fscache_zap_inode_cookie(inode); | |
268 | } | |
269 | } | |
270 | ||
271 | /* | |
272 | * wait_on_bit() sleep function for uninterruptible waiting | |
273 | */ | |
274 | static int nfs_fscache_wait_bit(void *flags) | |
275 | { | |
276 | schedule(); | |
277 | return 0; | |
278 | } | |
279 | ||
280 | /* | |
281 | * Lock against someone else trying to also acquire or relinquish a cookie | |
282 | */ | |
283 | static inline void nfs_fscache_inode_lock(struct inode *inode) | |
284 | { | |
285 | struct nfs_inode *nfsi = NFS_I(inode); | |
286 | ||
287 | while (test_and_set_bit(NFS_INO_FSCACHE_LOCK, &nfsi->flags)) | |
288 | wait_on_bit(&nfsi->flags, NFS_INO_FSCACHE_LOCK, | |
289 | nfs_fscache_wait_bit, TASK_UNINTERRUPTIBLE); | |
290 | } | |
291 | ||
292 | /* | |
293 | * Unlock cookie management lock | |
294 | */ | |
295 | static inline void nfs_fscache_inode_unlock(struct inode *inode) | |
296 | { | |
297 | struct nfs_inode *nfsi = NFS_I(inode); | |
298 | ||
299 | smp_mb__before_clear_bit(); | |
300 | clear_bit(NFS_INO_FSCACHE_LOCK, &nfsi->flags); | |
301 | smp_mb__after_clear_bit(); | |
302 | wake_up_bit(&nfsi->flags, NFS_INO_FSCACHE_LOCK); | |
303 | } | |
304 | ||
305 | /* | |
306 | * Decide if we should enable or disable local caching for this inode. | |
307 | * - For now, with NFS, only regular files that are open read-only will be able | |
308 | * to use the cache. | |
309 | * - May be invoked multiple times in parallel by parallel nfs_open() functions. | |
310 | */ | |
311 | void nfs_fscache_set_inode_cookie(struct inode *inode, struct file *filp) | |
312 | { | |
313 | if (NFS_FSCACHE(inode)) { | |
314 | nfs_fscache_inode_lock(inode); | |
315 | if ((filp->f_flags & O_ACCMODE) != O_RDONLY) | |
316 | nfs_fscache_disable_inode_cookie(inode); | |
317 | else | |
318 | nfs_fscache_enable_inode_cookie(inode); | |
319 | nfs_fscache_inode_unlock(inode); | |
320 | } | |
321 | } | |
322 | ||
323 | /* | |
324 | * Replace a per-inode cookie due to revalidation detecting a file having | |
325 | * changed on the server. | |
326 | */ | |
327 | void nfs_fscache_reset_inode_cookie(struct inode *inode) | |
328 | { | |
329 | struct nfs_inode *nfsi = NFS_I(inode); | |
330 | struct nfs_server *nfss = NFS_SERVER(inode); | |
331 | struct fscache_cookie *old = nfsi->fscache; | |
332 | ||
333 | nfs_fscache_inode_lock(inode); | |
334 | if (nfsi->fscache) { | |
335 | /* retire the current fscache cache and get a new one */ | |
336 | fscache_relinquish_cookie(nfsi->fscache, 1); | |
337 | ||
338 | nfsi->fscache = fscache_acquire_cookie( | |
339 | nfss->nfs_client->fscache, | |
340 | &nfs_fscache_inode_object_def, | |
341 | nfsi); | |
342 | ||
343 | dfprintk(FSCACHE, | |
344 | "NFS: revalidation new cookie (0x%p/0x%p/0x%p/0x%p)\n", | |
345 | nfss, nfsi, old, nfsi->fscache); | |
346 | } | |
347 | nfs_fscache_inode_unlock(inode); | |
348 | } | |
545db45f DH |
349 | |
350 | /* | |
351 | * Release the caching state associated with a page, if the page isn't busy | |
352 | * interacting with the cache. | |
353 | * - Returns true (can release page) or false (page busy). | |
354 | */ | |
355 | int nfs_fscache_release_page(struct page *page, gfp_t gfp) | |
356 | { | |
357 | struct nfs_inode *nfsi = NFS_I(page->mapping->host); | |
358 | struct fscache_cookie *cookie = nfsi->fscache; | |
359 | ||
360 | BUG_ON(!cookie); | |
361 | ||
362 | if (fscache_check_page_write(cookie, page)) { | |
363 | if (!(gfp & __GFP_WAIT)) | |
364 | return 0; | |
365 | fscache_wait_on_page_write(cookie, page); | |
366 | } | |
367 | ||
368 | if (PageFsCache(page)) { | |
369 | dfprintk(FSCACHE, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n", | |
370 | cookie, page, nfsi); | |
371 | ||
372 | fscache_uncache_page(cookie, page); | |
373 | nfs_add_fscache_stats(page->mapping->host, | |
374 | NFSIOS_FSCACHE_PAGES_UNCACHED, 1); | |
375 | } | |
376 | ||
377 | return 1; | |
378 | } | |
379 | ||
380 | /* | |
381 | * Release the caching state associated with a page if undergoing complete page | |
382 | * invalidation. | |
383 | */ | |
384 | void __nfs_fscache_invalidate_page(struct page *page, struct inode *inode) | |
385 | { | |
386 | struct nfs_inode *nfsi = NFS_I(inode); | |
387 | struct fscache_cookie *cookie = nfsi->fscache; | |
388 | ||
389 | BUG_ON(!cookie); | |
390 | ||
391 | dfprintk(FSCACHE, "NFS: fscache invalidatepage (0x%p/0x%p/0x%p)\n", | |
392 | cookie, page, nfsi); | |
393 | ||
394 | fscache_wait_on_page_write(cookie, page); | |
395 | ||
396 | BUG_ON(!PageLocked(page)); | |
397 | fscache_uncache_page(cookie, page); | |
398 | nfs_add_fscache_stats(page->mapping->host, | |
399 | NFSIOS_FSCACHE_PAGES_UNCACHED, 1); | |
400 | } | |
9a9fc1c0 DH |
401 | |
402 | /* | |
403 | * Handle completion of a page being read from the cache. | |
404 | * - Called in process (keventd) context. | |
405 | */ | |
406 | static void nfs_readpage_from_fscache_complete(struct page *page, | |
407 | void *context, | |
408 | int error) | |
409 | { | |
410 | dfprintk(FSCACHE, | |
411 | "NFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n", | |
412 | page, context, error); | |
413 | ||
414 | /* if the read completes with an error, we just unlock the page and let | |
415 | * the VM reissue the readpage */ | |
416 | if (!error) { | |
417 | SetPageUptodate(page); | |
418 | unlock_page(page); | |
419 | } else { | |
420 | error = nfs_readpage_async(context, page->mapping->host, page); | |
421 | if (error) | |
422 | unlock_page(page); | |
423 | } | |
424 | } | |
425 | ||
426 | /* | |
427 | * Retrieve a page from fscache | |
428 | */ | |
429 | int __nfs_readpage_from_fscache(struct nfs_open_context *ctx, | |
430 | struct inode *inode, struct page *page) | |
431 | { | |
432 | int ret; | |
433 | ||
434 | dfprintk(FSCACHE, | |
435 | "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n", | |
436 | NFS_I(inode)->fscache, page, page->index, page->flags, inode); | |
437 | ||
438 | ret = fscache_read_or_alloc_page(NFS_I(inode)->fscache, | |
439 | page, | |
440 | nfs_readpage_from_fscache_complete, | |
441 | ctx, | |
442 | GFP_KERNEL); | |
443 | ||
444 | switch (ret) { | |
445 | case 0: /* read BIO submitted (page in fscache) */ | |
446 | dfprintk(FSCACHE, | |
447 | "NFS: readpage_from_fscache: BIO submitted\n"); | |
448 | nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK, 1); | |
449 | return ret; | |
450 | ||
451 | case -ENOBUFS: /* inode not in cache */ | |
452 | case -ENODATA: /* page not in cache */ | |
453 | nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL, 1); | |
454 | dfprintk(FSCACHE, | |
455 | "NFS: readpage_from_fscache %d\n", ret); | |
456 | return 1; | |
457 | ||
458 | default: | |
459 | dfprintk(FSCACHE, "NFS: readpage_from_fscache %d\n", ret); | |
460 | nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL, 1); | |
461 | } | |
462 | return ret; | |
463 | } | |
464 | ||
465 | /* | |
466 | * Retrieve a set of pages from fscache | |
467 | */ | |
468 | int __nfs_readpages_from_fscache(struct nfs_open_context *ctx, | |
469 | struct inode *inode, | |
470 | struct address_space *mapping, | |
471 | struct list_head *pages, | |
472 | unsigned *nr_pages) | |
473 | { | |
474 | int ret, npages = *nr_pages; | |
475 | ||
476 | dfprintk(FSCACHE, "NFS: nfs_getpages_from_fscache (0x%p/%u/0x%p)\n", | |
477 | NFS_I(inode)->fscache, npages, inode); | |
478 | ||
479 | ret = fscache_read_or_alloc_pages(NFS_I(inode)->fscache, | |
480 | mapping, pages, nr_pages, | |
481 | nfs_readpage_from_fscache_complete, | |
482 | ctx, | |
483 | mapping_gfp_mask(mapping)); | |
484 | if (*nr_pages < npages) | |
485 | nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK, | |
486 | npages); | |
487 | if (*nr_pages > 0) | |
488 | nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL, | |
489 | *nr_pages); | |
490 | ||
491 | switch (ret) { | |
492 | case 0: /* read submitted to the cache for all pages */ | |
493 | BUG_ON(!list_empty(pages)); | |
494 | BUG_ON(*nr_pages != 0); | |
495 | dfprintk(FSCACHE, | |
496 | "NFS: nfs_getpages_from_fscache: submitted\n"); | |
497 | ||
498 | return ret; | |
499 | ||
500 | case -ENOBUFS: /* some pages aren't cached and can't be */ | |
501 | case -ENODATA: /* some pages aren't cached */ | |
502 | dfprintk(FSCACHE, | |
503 | "NFS: nfs_getpages_from_fscache: no page: %d\n", ret); | |
504 | return 1; | |
505 | ||
506 | default: | |
507 | dfprintk(FSCACHE, | |
508 | "NFS: nfs_getpages_from_fscache: ret %d\n", ret); | |
509 | } | |
510 | ||
511 | return ret; | |
512 | } | |
7f8e05f6 DH |
513 | |
514 | /* | |
515 | * Store a newly fetched page in fscache | |
516 | * - PG_fscache must be set on the page | |
517 | */ | |
518 | void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync) | |
519 | { | |
520 | int ret; | |
521 | ||
522 | dfprintk(FSCACHE, | |
523 | "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n", | |
524 | NFS_I(inode)->fscache, page, page->index, page->flags, sync); | |
525 | ||
526 | ret = fscache_write_page(NFS_I(inode)->fscache, page, GFP_KERNEL); | |
527 | dfprintk(FSCACHE, | |
528 | "NFS: readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n", | |
529 | page, page->index, page->flags, ret); | |
530 | ||
531 | if (ret != 0) { | |
532 | fscache_uncache_page(NFS_I(inode)->fscache, page); | |
533 | nfs_add_fscache_stats(inode, | |
534 | NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL, 1); | |
535 | nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_UNCACHED, 1); | |
536 | } else { | |
537 | nfs_add_fscache_stats(inode, | |
538 | NFSIOS_FSCACHE_PAGES_WRITTEN_OK, 1); | |
539 | } | |
540 | } |