fs/nfs/fscache.c

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