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