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