fs/cachefiles/cache.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Manage high-level VFS aspects of a cache.
   3  *
   4  * Copyright (C) 2007, 2021 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/slab.h>
   9 #include <linux/statfs.h>
  10 #include <linux/namei.h>
  11 #include "internal.h"
  12
  13 /*
  14  * Bring a cache online.
  15  */
  16 int cachefiles_add_cache(struct cachefiles_cache *cache)
  17 {
  18         struct fscache_cache *cache_cookie;
  19         struct path path;
  20         struct kstatfs stats;
  21         struct dentry *graveyard, *cachedir, *root;
  22         const struct cred *saved_cred;
  23         int ret;
  24
  25         _enter("");
  26
  27         cache_cookie = fscache_acquire_cache(cache->tag);
  28         if (IS_ERR(cache_cookie))
  29                 return PTR_ERR(cache_cookie);
  30
  31         /* we want to work under the module's security ID */
  32         ret = cachefiles_get_security_ID(cache);
  33         if (ret < 0)
  34                 goto error_getsec;
  35
  36         cachefiles_begin_secure(cache, &saved_cred);
  37
  38         /* look up the directory at the root of the cache */
  39         ret = kern_path(cache->rootdirname, LOOKUP_DIRECTORY, &path);
  40         if (ret < 0)
  41                 goto error_open_root;
  42
  43         cache->mnt = path.mnt;
  44         root = path.dentry;
  45
  46         ret = -EINVAL;
  47         if (is_idmapped_mnt(path.mnt)) {
  48                 pr_warn("File cache on idmapped mounts not supported");
  49                 goto error_unsupported;
  50         }
  51
  52         /* Check features of the backing filesystem:
  53          * - Directories must support looking up and directory creation
  54          * - We create tmpfiles to handle invalidation
  55          * - We use xattrs to store metadata
  56          * - We need to be able to query the amount of space available
  57          * - We want to be able to sync the filesystem when stopping the cache
  58          * - We use DIO to/from pages, so the blocksize mustn't be too big.
  59          */
  60         ret = -EOPNOTSUPP;
  61         if (d_is_negative(root) ||
  62             !d_backing_inode(root)->i_op->lookup ||
  63             !d_backing_inode(root)->i_op->mkdir ||
  64             !d_backing_inode(root)->i_op->tmpfile ||
  65             !(d_backing_inode(root)->i_opflags & IOP_XATTR) ||
  66             !root->d_sb->s_op->statfs ||
  67             !root->d_sb->s_op->sync_fs ||
  68             root->d_sb->s_blocksize > PAGE_SIZE)
  69                 goto error_unsupported;
  70
  71         ret = -EROFS;
  72         if (sb_rdonly(root->d_sb))
  73                 goto error_unsupported;
  74
  75         /* determine the security of the on-disk cache as this governs
  76          * security ID of files we create */
  77         ret = cachefiles_determine_cache_security(cache, root, &saved_cred);
  78         if (ret < 0)
  79                 goto error_unsupported;
  80
  81         /* get the cache size and blocksize */
  82         ret = vfs_statfs(&path, &stats);
  83         if (ret < 0)
  84                 goto error_unsupported;
  85
  86         ret = -ERANGE;
  87         if (stats.f_bsize <= 0)
  88                 goto error_unsupported;
  89
  90         ret = -EOPNOTSUPP;
  91         if (stats.f_bsize > PAGE_SIZE)
  92                 goto error_unsupported;
  93
  94         cache->bsize = stats.f_bsize;
  95         cache->bshift = ilog2(stats.f_bsize);
  96
  97         _debug("blksize %u (shift %u)",
  98                cache->bsize, cache->bshift);
  99
 100         _debug("size %llu, avail %llu",
 101                (unsigned long long) stats.f_blocks,
 102                (unsigned long long) stats.f_bavail);
 103
 104         /* set up caching limits */
 105         do_div(stats.f_files, 100);
 106         cache->fstop = stats.f_files * cache->fstop_percent;
 107         cache->fcull = stats.f_files * cache->fcull_percent;
 108         cache->frun  = stats.f_files * cache->frun_percent;
 109
 110         _debug("limits {%llu,%llu,%llu} files",
 111                (unsigned long long) cache->frun,
 112                (unsigned long long) cache->fcull,
 113                (unsigned long long) cache->fstop);
 114
 115         do_div(stats.f_blocks, 100);
 116         cache->bstop = stats.f_blocks * cache->bstop_percent;
 117         cache->bcull = stats.f_blocks * cache->bcull_percent;
 118         cache->brun  = stats.f_blocks * cache->brun_percent;
 119
 120         _debug("limits {%llu,%llu,%llu} blocks",
 121                (unsigned long long) cache->brun,
 122                (unsigned long long) cache->bcull,
 123                (unsigned long long) cache->bstop);
 124
 125         /* get the cache directory and check its type */
 126         cachedir = cachefiles_get_directory(cache, root, "cache", NULL);
 127         if (IS_ERR(cachedir)) {
 128                 ret = PTR_ERR(cachedir);
 129                 goto error_unsupported;
 130         }
 131
 132         cache->store = cachedir;
 133
 134         /* get the graveyard directory */
 135         graveyard = cachefiles_get_directory(cache, root, "graveyard", NULL);
 136         if (IS_ERR(graveyard)) {
 137                 ret = PTR_ERR(graveyard);
 138                 goto error_unsupported;
 139         }
 140
 141         cache->graveyard = graveyard;
 142         cache->cache = cache_cookie;
 143
 144         ret = fscache_add_cache(cache_cookie, &cachefiles_cache_ops, cache);
 145         if (ret < 0)
 146                 goto error_add_cache;
 147
 148         /* done */
 149         set_bit(CACHEFILES_READY, &cache->flags);
 150         dput(root);
 151
 152         pr_info("File cache on %s registered\n", cache_cookie->name);
 153
 154         /* check how much space the cache has */
 155         cachefiles_has_space(cache, 0, 0, cachefiles_has_space_check);
 156         cachefiles_end_secure(cache, saved_cred);
 157         _leave(" = 0 [%px]", cache->cache);
 158         return 0;
 159
 160 error_add_cache:
 161         cachefiles_put_directory(cache->graveyard);
 162         cache->graveyard = NULL;
 163 error_unsupported:
 164         cachefiles_put_directory(cache->store);
 165         cache->store = NULL;
 166         mntput(cache->mnt);
 167         cache->mnt = NULL;
 168         dput(root);
 169 error_open_root:
 170         cachefiles_end_secure(cache, saved_cred);
 171 error_getsec:
 172         fscache_relinquish_cache(cache_cookie);
 173         cache->cache = NULL;
 174         pr_err("Failed to register: %d\n", ret);
 175         return ret;
 176 }
 177
 178 /*
 179  * See if we have space for a number of pages and/or a number of files in the
 180  * cache
 181  */
 182 int cachefiles_has_space(struct cachefiles_cache *cache,
 183                          unsigned fnr, unsigned bnr,
 184                          enum cachefiles_has_space_for reason)
 185 {
 186         struct kstatfs stats;
 187         u64 b_avail, b_writing;
 188         int ret;
 189
 190         struct path path = {
 191                 .mnt    = cache->mnt,
 192                 .dentry = cache->mnt->mnt_root,
 193         };
 194
 195         //_enter("{%llu,%llu,%llu,%llu,%llu,%llu},%u,%u",
 196         //       (unsigned long long) cache->frun,
 197         //       (unsigned long long) cache->fcull,
 198         //       (unsigned long long) cache->fstop,
 199         //       (unsigned long long) cache->brun,
 200         //       (unsigned long long) cache->bcull,
 201         //       (unsigned long long) cache->bstop,
 202         //       fnr, bnr);
 203
 204         /* find out how many pages of blockdev are available */
 205         memset(&stats, 0, sizeof(stats));
 206
 207         ret = vfs_statfs(&path, &stats);
 208         if (ret < 0) {
 209                 trace_cachefiles_vfs_error(NULL, d_inode(path.dentry), ret,
 210                                            cachefiles_trace_statfs_error);
 211                 if (ret == -EIO)
 212                         cachefiles_io_error(cache, "statfs failed");
 213                 _leave(" = %d", ret);
 214                 return ret;
 215         }
 216
 217         b_avail = stats.f_bavail;
 218         b_writing = atomic_long_read(&cache->b_writing);
 219         if (b_avail > b_writing)
 220                 b_avail -= b_writing;
 221         else
 222                 b_avail = 0;
 223
 224         //_debug("avail %llu,%llu",
 225         //       (unsigned long long)stats.f_ffree,
 226         //       (unsigned long long)b_avail);
 227
 228         /* see if there is sufficient space */
 229         if (stats.f_ffree > fnr)
 230                 stats.f_ffree -= fnr;
 231         else
 232                 stats.f_ffree = 0;
 233
 234         if (b_avail > bnr)
 235                 b_avail -= bnr;
 236         else
 237                 b_avail = 0;
 238
 239         ret = -ENOBUFS;
 240         if (stats.f_ffree < cache->fstop ||
 241             b_avail < cache->bstop)
 242                 goto stop_and_begin_cull;
 243
 244         ret = 0;
 245         if (stats.f_ffree < cache->fcull ||
 246             b_avail < cache->bcull)
 247                 goto begin_cull;
 248
 249         if (test_bit(CACHEFILES_CULLING, &cache->flags) &&
 250             stats.f_ffree >= cache->frun &&
 251             b_avail >= cache->brun &&
 252             test_and_clear_bit(CACHEFILES_CULLING, &cache->flags)
 253             ) {
 254                 _debug("cease culling");
 255                 cachefiles_state_changed(cache);
 256         }
 257
 258         //_leave(" = 0");
 259         return 0;
 260
 261 stop_and_begin_cull:
 262         switch (reason) {
 263         case cachefiles_has_space_for_write:
 264                 fscache_count_no_write_space();
 265                 break;
 266         case cachefiles_has_space_for_create:
 267                 fscache_count_no_create_space();
 268                 break;
 269         default:
 270                 break;
 271         }
 272 begin_cull:
 273         if (!test_and_set_bit(CACHEFILES_CULLING, &cache->flags)) {
 274                 _debug("### CULL CACHE ###");
 275                 cachefiles_state_changed(cache);
 276         }
 277
 278         _leave(" = %d", ret);
 279         return ret;
 280 }
 281
 282 /*
 283  * Mark all the objects as being out of service and queue them all for cleanup.
 284  */
 285 static void cachefiles_withdraw_objects(struct cachefiles_cache *cache)
 286 {
 287         struct cachefiles_object *object;
 288         unsigned int count = 0;
 289
 290         _enter("");
 291
 292         spin_lock(&cache->object_list_lock);
 293
 294         while (!list_empty(&cache->object_list)) {
 295                 object = list_first_entry(&cache->object_list,
 296                                           struct cachefiles_object, cache_link);
 297                 cachefiles_see_object(object, cachefiles_obj_see_withdrawal);
 298                 list_del_init(&object->cache_link);
 299                 fscache_withdraw_cookie(object->cookie);
 300                 count++;
 301                 if ((count & 63) == 0) {
 302                         spin_unlock(&cache->object_list_lock);
 303                         cond_resched();
 304                         spin_lock(&cache->object_list_lock);
 305                 }
 306         }
 307
 308         spin_unlock(&cache->object_list_lock);
 309         _leave(" [%u objs]", count);
 310 }
 311
 312 /*
 313  * Withdraw volumes.
 314  */
 315 static void cachefiles_withdraw_volumes(struct cachefiles_cache *cache)
 316 {
 317         _enter("");
 318
 319         for (;;) {
 320                 struct cachefiles_volume *volume = NULL;
 321
 322                 spin_lock(&cache->object_list_lock);
 323                 if (!list_empty(&cache->volumes)) {
 324                         volume = list_first_entry(&cache->volumes,
 325                                                   struct cachefiles_volume, cache_link);
 326                         list_del_init(&volume->cache_link);
 327                 }
 328                 spin_unlock(&cache->object_list_lock);
 329                 if (!volume)
 330                         break;
 331
 332                 cachefiles_withdraw_volume(volume);
 333         }
 334
 335         _leave("");
 336 }
 337
 338 /*
 339  * Sync a cache to backing disk.
 340  */
 341 static void cachefiles_sync_cache(struct cachefiles_cache *cache)
 342 {
 343         const struct cred *saved_cred;
 344         int ret;
 345
 346         _enter("%s", cache->cache->name);
 347
 348         /* make sure all pages pinned by operations on behalf of the netfs are
 349          * written to disc */
 350         cachefiles_begin_secure(cache, &saved_cred);
 351         down_read(&cache->mnt->mnt_sb->s_umount);
 352         ret = sync_filesystem(cache->mnt->mnt_sb);
 353         up_read(&cache->mnt->mnt_sb->s_umount);
 354         cachefiles_end_secure(cache, saved_cred);
 355
 356         if (ret == -EIO)
 357                 cachefiles_io_error(cache,
 358                                     "Attempt to sync backing fs superblock returned error %d",
 359                                     ret);
 360 }
 361
 362 /*
 363  * Withdraw cache objects.
 364  */
 365 void cachefiles_withdraw_cache(struct cachefiles_cache *cache)
 366 {
 367         struct fscache_cache *fscache = cache->cache;
 368
 369         pr_info("File cache on %s unregistering\n", fscache->name);
 370
 371         fscache_withdraw_cache(fscache);
 372
 373         /* we now have to destroy all the active objects pertaining to this
 374          * cache - which we do by passing them off to thread pool to be
 375          * disposed of */
 376         cachefiles_withdraw_objects(cache);
 377         fscache_wait_for_objects(fscache);
 378
 379         cachefiles_withdraw_volumes(cache);
 380         cachefiles_sync_cache(cache);
 381         cache->cache = NULL;
 382         fscache_relinquish_cache(fscache);
 383 }