fs/nfs/fscache.c

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