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