~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/fscache.c

Version: ~ [ linux-5.8-rc5 ] ~ [ linux-5.7.8 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.51 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.132 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.188 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.230 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.230 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/iversion.h>
 22 
 23 #include "internal.h"
 24 #include "iostat.h"
 25 #include "fscache.h"
 26 
 27 #define NFSDBG_FACILITY         NFSDBG_FSCACHE
 28 
 29 static struct rb_root nfs_fscache_keys = RB_ROOT;
 30 static DEFINE_SPINLOCK(nfs_fscache_keys_lock);
 31 
 32 /*
 33  * Layout of the key for an NFS server cache object.
 34  */
 35 struct nfs_server_key {
 36         struct {
 37                 uint16_t        nfsversion;             /* NFS protocol version */
 38                 uint16_t        family;                 /* address family */
 39                 __be16          port;                   /* IP port */
 40         } hdr;
 41         union {
 42                 struct in_addr  ipv4_addr;      /* IPv4 address */
 43                 struct in6_addr ipv6_addr;      /* IPv6 address */
 44         };
 45 } __packed;
 46 
 47 /*
 48  * Get the per-client index cookie for an NFS client if the appropriate mount
 49  * flag was set
 50  * - We always try and get an index cookie for the client, but get filehandle
 51  *   cookies on a per-superblock basis, depending on the mount flags
 52  */
 53 void nfs_fscache_get_client_cookie(struct nfs_client *clp)
 54 {
 55         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr;
 56         const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr;
 57         struct nfs_server_key key;
 58         uint16_t len = sizeof(key.hdr);
 59 
 60         memset(&key, 0, sizeof(key));
 61         key.hdr.nfsversion = clp->rpc_ops->version;
 62         key.hdr.family = clp->cl_addr.ss_family;
 63 
 64         switch (clp->cl_addr.ss_family) {
 65         case AF_INET:
 66                 key.hdr.port = sin->sin_port;
 67                 key.ipv4_addr = sin->sin_addr;
 68                 len += sizeof(key.ipv4_addr);
 69                 break;
 70 
 71         case AF_INET6:
 72                 key.hdr.port = sin6->sin6_port;
 73                 key.ipv6_addr = sin6->sin6_addr;
 74                 len += sizeof(key.ipv6_addr);
 75                 break;
 76 
 77         default:
 78                 printk(KERN_WARNING "NFS: Unknown network family '%d'\n",
 79                        clp->cl_addr.ss_family);
 80                 clp->fscache = NULL;
 81                 return;
 82         }
 83 
 84         /* create a cache index for looking up filehandles */
 85         clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index,
 86                                               &nfs_fscache_server_index_def,
 87                                               &key, len,
 88                                               NULL, 0,
 89                                               clp, 0, true);
 90         dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n",
 91                  clp, clp->fscache);
 92 }
 93 
 94 /*
 95  * Dispose of a per-client cookie
 96  */
 97 void nfs_fscache_release_client_cookie(struct nfs_client *clp)
 98 {
 99         dfprintk(FSCACHE, "NFS: releasing client cookie (0x%p/0x%p)\n",
100                  clp, clp->fscache);
101 
102         fscache_relinquish_cookie(clp->fscache, NULL, false);
103         clp->fscache = NULL;
104 }
105 
106 /*
107  * Get the cache cookie for an NFS superblock.  We have to handle
108  * uniquification here because the cache doesn't do it for us.
109  *
110  * The default uniquifier is just an empty string, but it may be overridden
111  * either by the 'fsc=xxx' option to mount, or by inheriting it from the parent
112  * superblock across an automount point of some nature.
113  */
114 void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int ulen)
115 {
116         struct nfs_fscache_key *key, *xkey;
117         struct nfs_server *nfss = NFS_SB(sb);
118         struct rb_node **p, *parent;
119         int diff;
120 
121         if (!uniq) {
122                 uniq = "";
123                 ulen = 1;
124         }
125 
126         key = kzalloc(sizeof(*key) + ulen, GFP_KERNEL);
127         if (!key)
128                 return;
129 
130         key->nfs_client = nfss->nfs_client;
131         key->key.super.s_flags = sb->s_flags & NFS_MS_MASK;
132         key->key.nfs_server.flags = nfss->flags;
133         key->key.nfs_server.rsize = nfss->rsize;
134         key->key.nfs_server.wsize = nfss->wsize;
135         key->key.nfs_server.acregmin = nfss->acregmin;
136         key->key.nfs_server.acregmax = nfss->acregmax;
137         key->key.nfs_server.acdirmin = nfss->acdirmin;
138         key->key.nfs_server.acdirmax = nfss->acdirmax;
139         key->key.nfs_server.fsid = nfss->fsid;
140         key->key.rpc_auth.au_flavor = nfss->client->cl_auth->au_flavor;
141 
142         key->key.uniq_len = ulen;
143         memcpy(key->key.uniquifier, uniq, ulen);
144 
145         spin_lock(&nfs_fscache_keys_lock);
146         p = &nfs_fscache_keys.rb_node;
147         parent = NULL;
148         while (*p) {
149                 parent = *p;
150                 xkey = rb_entry(parent, struct nfs_fscache_key, node);
151 
152                 if (key->nfs_client < xkey->nfs_client)
153                         goto go_left;
154                 if (key->nfs_client > xkey->nfs_client)
155                         goto go_right;
156 
157                 diff = memcmp(&key->key, &xkey->key, sizeof(key->key));
158                 if (diff < 0)
159                         goto go_left;
160                 if (diff > 0)
161                         goto go_right;
162 
163                 if (key->key.uniq_len == 0)
164                         goto non_unique;
165                 diff = memcmp(key->key.uniquifier,
166                               xkey->key.uniquifier,
167                               key->key.uniq_len);
168                 if (diff < 0)
169                         goto go_left;
170                 if (diff > 0)
171                         goto go_right;
172                 goto non_unique;
173 
174         go_left:
175                 p = &(*p)->rb_left;
176                 continue;
177         go_right:
178                 p = &(*p)->rb_right;
179         }
180 
181         rb_link_node(&key->node, parent, p);
182         rb_insert_color(&key->node, &nfs_fscache_keys);
183         spin_unlock(&nfs_fscache_keys_lock);
184         nfss->fscache_key = key;
185 
186         /* create a cache index for looking up filehandles */
187         nfss->fscache = fscache_acquire_cookie(nfss->nfs_client->fscache,
188                                                &nfs_fscache_super_index_def,
189                                                key, sizeof(*key) + ulen,
190                                                NULL, 0,
191                                                nfss, 0, true);
192         dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n",
193                  nfss, nfss->fscache);
194         return;
195 
196 non_unique:
197         spin_unlock(&nfs_fscache_keys_lock);
198         kfree(key);
199         nfss->fscache_key = NULL;
200         nfss->fscache = NULL;
201         printk(KERN_WARNING "NFS:"
202                " Cache request denied due to non-unique superblock keys\n");
203 }
204 
205 /*
206  * release a per-superblock cookie
207  */
208 void nfs_fscache_release_super_cookie(struct super_block *sb)
209 {
210         struct nfs_server *nfss = NFS_SB(sb);
211 
212         dfprintk(FSCACHE, "NFS: releasing superblock cookie (0x%p/0x%p)\n",
213                  nfss, nfss->fscache);
214 
215         fscache_relinquish_cookie(nfss->fscache, NULL, false);
216         nfss->fscache = NULL;
217 
218         if (nfss->fscache_key) {
219                 spin_lock(&nfs_fscache_keys_lock);
220                 rb_erase(&nfss->fscache_key->node, &nfs_fscache_keys);
221                 spin_unlock(&nfs_fscache_keys_lock);
222                 kfree(nfss->fscache_key);
223                 nfss->fscache_key = NULL;
224         }
225 }
226 
227 /*
228  * Initialise the per-inode cache cookie pointer for an NFS inode.
229  */
230 void nfs_fscache_init_inode(struct inode *inode)
231 {
232         struct nfs_fscache_inode_auxdata auxdata;
233         struct nfs_inode *nfsi = NFS_I(inode);
234 
235         nfsi->fscache = NULL;
236         if (!S_ISREG(inode->i_mode))
237                 return;
238 
239         memset(&auxdata, 0, sizeof(auxdata));
240         auxdata.mtime = timespec64_to_timespec(nfsi->vfs_inode.i_mtime);
241         auxdata.ctime = timespec64_to_timespec(nfsi->vfs_inode.i_ctime);
242 
243         if (NFS_SERVER(&nfsi->vfs_inode)->nfs_client->rpc_ops->version == 4)
244                 auxdata.change_attr = inode_peek_iversion_raw(&nfsi->vfs_inode);
245 
246         nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache,
247                                                &nfs_fscache_inode_object_def,
248                                                nfsi->fh.data, nfsi->fh.size,
249                                                &auxdata, sizeof(auxdata),
250                                                nfsi, nfsi->vfs_inode.i_size, false);
251 }
252 
253 /*
254  * Release a per-inode cookie.
255  */
256 void nfs_fscache_clear_inode(struct inode *inode)
257 {
258         struct nfs_fscache_inode_auxdata auxdata;
259         struct nfs_inode *nfsi = NFS_I(inode);
260         struct fscache_cookie *cookie = nfs_i_fscache(inode);
261 
262         dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", nfsi, cookie);
263 
264         memset(&auxdata, 0, sizeof(auxdata));
265         auxdata.mtime = timespec64_to_timespec(nfsi->vfs_inode.i_mtime);
266         auxdata.ctime = timespec64_to_timespec(nfsi->vfs_inode.i_ctime);
267         fscache_relinquish_cookie(cookie, &auxdata, false);
268         nfsi->fscache = NULL;
269 }
270 
271 static bool nfs_fscache_can_enable(void *data)
272 {
273         struct inode *inode = data;
274 
275         return !inode_is_open_for_write(inode);
276 }
277 
278 /*
279  * Enable or disable caching for a file that is being opened as appropriate.
280  * The cookie is allocated when the inode is initialised, but is not enabled at
281  * that time.  Enablement is deferred to file-open time to avoid stat() and
282  * access() thrashing the cache.
283  *
284  * For now, with NFS, only regular files that are open read-only will be able
285  * to use the cache.
286  *
287  * We enable the cache for an inode if we open it read-only and it isn't
288  * currently open for writing.  We disable the cache if the inode is open
289  * write-only.
290  *
291  * The caller uses the file struct to pin i_writecount on the inode before
292  * calling us when a file is opened for writing, so we can make use of that.
293  *
294  * Note that this may be invoked multiple times in parallel by parallel
295  * nfs_open() functions.
296  */
297 void nfs_fscache_open_file(struct inode *inode, struct file *filp)
298 {
299         struct nfs_fscache_inode_auxdata auxdata;
300         struct nfs_inode *nfsi = NFS_I(inode);
301         struct fscache_cookie *cookie = nfs_i_fscache(inode);
302 
303         if (!fscache_cookie_valid(cookie))
304                 return;
305 
306         memset(&auxdata, 0, sizeof(auxdata));
307         auxdata.mtime = timespec64_to_timespec(nfsi->vfs_inode.i_mtime);
308         auxdata.ctime = timespec64_to_timespec(nfsi->vfs_inode.i_ctime);
309 
310         if (inode_is_open_for_write(inode)) {
311                 dfprintk(FSCACHE, "NFS: nfsi 0x%p disabling cache\n", nfsi);
312                 clear_bit(NFS_INO_FSCACHE, &nfsi->flags);
313                 fscache_disable_cookie(cookie, &auxdata, true);
314                 fscache_uncache_all_inode_pages(cookie, inode);
315         } else {
316                 dfprintk(FSCACHE, "NFS: nfsi 0x%p enabling cache\n", nfsi);
317                 fscache_enable_cookie(cookie, &auxdata, nfsi->vfs_inode.i_size,
318                                       nfs_fscache_can_enable, inode);
319                 if (fscache_cookie_enabled(cookie))
320                         set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
321         }
322 }
323 EXPORT_SYMBOL_GPL(nfs_fscache_open_file);
324 
325 /*
326  * Release the caching state associated with a page, if the page isn't busy
327  * interacting with the cache.
328  * - Returns true (can release page) or false (page busy).
329  */
330 int nfs_fscache_release_page(struct page *page, gfp_t gfp)
331 {
332         if (PageFsCache(page)) {
333                 struct fscache_cookie *cookie = nfs_i_fscache(page->mapping->host);
334 
335                 BUG_ON(!cookie);
336                 dfprintk(FSCACHE, "NFS: fscache releasepage (0x%p/0x%p/0x%p)\n",
337                          cookie, page, NFS_I(page->mapping->host));
338 
339                 if (!fscache_maybe_release_page(cookie, page, gfp))
340                         return 0;
341 
342                 nfs_inc_fscache_stats(page->mapping->host,
343                                       NFSIOS_FSCACHE_PAGES_UNCACHED);
344         }
345 
346         return 1;
347 }
348 
349 /*
350  * Release the caching state associated with a page if undergoing complete page
351  * invalidation.
352  */
353 void __nfs_fscache_invalidate_page(struct page *page, struct inode *inode)
354 {
355         struct fscache_cookie *cookie = nfs_i_fscache(inode);
356 
357         BUG_ON(!cookie);
358 
359         dfprintk(FSCACHE, "NFS: fscache invalidatepage (0x%p/0x%p/0x%p)\n",
360                  cookie, page, NFS_I(inode));
361 
362         fscache_wait_on_page_write(cookie, page);
363 
364         BUG_ON(!PageLocked(page));
365         fscache_uncache_page(cookie, page);
366         nfs_inc_fscache_stats(page->mapping->host,
367                               NFSIOS_FSCACHE_PAGES_UNCACHED);
368 }
369 
370 /*
371  * Handle completion of a page being read from the cache.
372  * - Called in process (keventd) context.
373  */
374 static void nfs_readpage_from_fscache_complete(struct page *page,
375                                                void *context,
376                                                int error)
377 {
378         dfprintk(FSCACHE,
379                  "NFS: readpage_from_fscache_complete (0x%p/0x%p/%d)\n",
380                  page, context, error);
381 
382         /* if the read completes with an error, we just unlock the page and let
383          * the VM reissue the readpage */
384         if (!error) {
385                 SetPageUptodate(page);
386                 unlock_page(page);
387         } else {
388                 error = nfs_readpage_async(context, page->mapping->host, page);
389                 if (error)
390                         unlock_page(page);
391         }
392 }
393 
394 /*
395  * Retrieve a page from fscache
396  */
397 int __nfs_readpage_from_fscache(struct nfs_open_context *ctx,
398                                 struct inode *inode, struct page *page)
399 {
400         int ret;
401 
402         dfprintk(FSCACHE,
403                  "NFS: readpage_from_fscache(fsc:%p/p:%p(i:%lx f:%lx)/0x%p)\n",
404                  nfs_i_fscache(inode), page, page->index, page->flags, inode);
405 
406         ret = fscache_read_or_alloc_page(nfs_i_fscache(inode),
407                                          page,
408                                          nfs_readpage_from_fscache_complete,
409                                          ctx,
410                                          GFP_KERNEL);
411 
412         switch (ret) {
413         case 0: /* read BIO submitted (page in fscache) */
414                 dfprintk(FSCACHE,
415                          "NFS:    readpage_from_fscache: BIO submitted\n");
416                 nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK);
417                 return ret;
418 
419         case -ENOBUFS: /* inode not in cache */
420         case -ENODATA: /* page not in cache */
421                 nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL);
422                 dfprintk(FSCACHE,
423                          "NFS:    readpage_from_fscache %d\n", ret);
424                 return 1;
425 
426         default:
427                 dfprintk(FSCACHE, "NFS:    readpage_from_fscache %d\n", ret);
428                 nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL);
429         }
430         return ret;
431 }
432 
433 /*
434  * Retrieve a set of pages from fscache
435  */
436 int __nfs_readpages_from_fscache(struct nfs_open_context *ctx,
437                                  struct inode *inode,
438                                  struct address_space *mapping,
439                                  struct list_head *pages,
440                                  unsigned *nr_pages)
441 {
442         unsigned npages = *nr_pages;
443         int ret;
444 
445         dfprintk(FSCACHE, "NFS: nfs_getpages_from_fscache (0x%p/%u/0x%p)\n",
446                  nfs_i_fscache(inode), npages, inode);
447 
448         ret = fscache_read_or_alloc_pages(nfs_i_fscache(inode),
449                                           mapping, pages, nr_pages,
450                                           nfs_readpage_from_fscache_complete,
451                                           ctx,
452                                           mapping_gfp_mask(mapping));
453         if (*nr_pages < npages)
454                 nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_OK,
455                                       npages);
456         if (*nr_pages > 0)
457                 nfs_add_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_READ_FAIL,
458                                       *nr_pages);
459 
460         switch (ret) {
461         case 0: /* read submitted to the cache for all pages */
462                 BUG_ON(!list_empty(pages));
463                 BUG_ON(*nr_pages != 0);
464                 dfprintk(FSCACHE,
465                          "NFS: nfs_getpages_from_fscache: submitted\n");
466 
467                 return ret;
468 
469         case -ENOBUFS: /* some pages aren't cached and can't be */
470         case -ENODATA: /* some pages aren't cached */
471                 dfprintk(FSCACHE,
472                          "NFS: nfs_getpages_from_fscache: no page: %d\n", ret);
473                 return 1;
474 
475         default:
476                 dfprintk(FSCACHE,
477                          "NFS: nfs_getpages_from_fscache: ret  %d\n", ret);
478         }
479 
480         return ret;
481 }
482 
483 /*
484  * Store a newly fetched page in fscache
485  * - PG_fscache must be set on the page
486  */
487 void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync)
488 {
489         int ret;
490 
491         dfprintk(FSCACHE,
492                  "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n",
493                  nfs_i_fscache(inode), page, page->index, page->flags, sync);
494 
495         ret = fscache_write_page(nfs_i_fscache(inode), page,
496                                  inode->i_size, GFP_KERNEL);
497         dfprintk(FSCACHE,
498                  "NFS:     readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n",
499                  page, page->index, page->flags, ret);
500 
501         if (ret != 0) {
502                 fscache_uncache_page(nfs_i_fscache(inode), page);
503                 nfs_inc_fscache_stats(inode,
504                                       NFSIOS_FSCACHE_PAGES_WRITTEN_FAIL);
505                 nfs_inc_fscache_stats(inode, NFSIOS_FSCACHE_PAGES_UNCACHED);
506         } else {
507                 nfs_inc_fscache_stats(inode,
508                                       NFSIOS_FSCACHE_PAGES_WRITTEN_OK);
509         }
510 }
511 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp