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                 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 }