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         put_cred(cache->cache_cred);
 172         cache->cache_cred = NULL;
 173 error_getsec:
 174         fscache_relinquish_cache(cache_cookie);
 175         cache->cache = NULL;
 176         pr_err("Failed to register: %d\n", ret);
 177         return ret;
 178 }
 179
 180 /*
 181  * See if we have space for a number of pages and/or a number of files in the
 182  * cache
 183  */
 184 int cachefiles_has_space(struct cachefiles_cache *cache,
 185                          unsigned fnr, unsigned bnr,
 186                          enum cachefiles_has_space_for reason)
 187 {
 188         struct kstatfs stats;
 189         u64 b_avail, b_writing;
 190         int ret;
 191
 192         struct path path = {
 193                 .mnt    = cache->mnt,
 194                 .dentry = cache->mnt->mnt_root,
 195         };
 196
 197         //_enter("{%llu,%llu,%llu,%llu,%llu,%llu},%u,%u",
 198         //       (unsigned long long) cache->frun,
 199         //       (unsigned long long) cache->fcull,
 200         //       (unsigned long long) cache->fstop,
 201         //       (unsigned long long) cache->brun,
 202         //       (unsigned long long) cache->bcull,
 203         //       (unsigned long long) cache->bstop,
 204         //       fnr, bnr);
 205
 206         /* find out how many pages of blockdev are available */
 207         memset(&stats, 0, sizeof(stats));
 208
 209         ret = vfs_statfs(&path, &stats);
 210         if (ret < 0) {
 211                 trace_cachefiles_vfs_error(NULL, d_inode(path.dentry), ret,
 212                                            cachefiles_trace_statfs_error);
 213                 if (ret == -EIO)
 214                         cachefiles_io_error(cache, "statfs failed");
 215                 _leave(" = %d", ret);
 216                 return ret;
 217         }
 218
 219         b_avail = stats.f_bavail;
 220         b_writing = atomic_long_read(&cache->b_writing);
 221         if (b_avail > b_writing)
 222                 b_avail -= b_writing;
 223         else
 224                 b_avail = 0;
 225
 226         //_debug("avail %llu,%llu",
 227         //       (unsigned long long)stats.f_ffree,
 228         //       (unsigned long long)b_avail);
 229
 230         /* see if there is sufficient space */
 231         if (stats.f_ffree > fnr)
 232                 stats.f_ffree -= fnr;
 233         else
 234                 stats.f_ffree = 0;
 235
 236         if (b_avail > bnr)
 237                 b_avail -= bnr;
 238         else
 239                 b_avail = 0;
 240
 241         ret = -ENOBUFS;
 242         if (stats.f_ffree < cache->fstop ||
 243             b_avail < cache->bstop)
 244                 goto stop_and_begin_cull;
 245
 246         ret = 0;
 247         if (stats.f_ffree < cache->fcull ||
 248             b_avail < cache->bcull)
 249                 goto begin_cull;
 250
 251         if (test_bit(CACHEFILES_CULLING, &cache->flags) &&
 252             stats.f_ffree >= cache->frun &&
 253             b_avail >= cache->brun &&
 254             test_and_clear_bit(CACHEFILES_CULLING, &cache->flags)
 255             ) {
 256                 _debug("cease culling");
 257                 cachefiles_state_changed(cache);
 258         }
 259
 260         //_leave(" = 0");
 261         return 0;
 262
 263 stop_and_begin_cull:
 264         switch (reason) {
 265         case cachefiles_has_space_for_write:
 266                 fscache_count_no_write_space();
 267                 break;
 268         case cachefiles_has_space_for_create:
 269                 fscache_count_no_create_space();
 270                 break;
 271         default:
 272                 break;
 273         }
 274 begin_cull:
 275         if (!test_and_set_bit(CACHEFILES_CULLING, &cache->flags)) {
 276                 _debug("### CULL CACHE ###");
 277                 cachefiles_state_changed(cache);
 278         }
 279
 280         _leave(" = %d", ret);
 281         return ret;
 282 }
 283
 284 /*
 285  * Mark all the objects as being out of service and queue them all for cleanup.
 286  */
 287 static void cachefiles_withdraw_objects(struct cachefiles_cache *cache)
 288 {
 289         struct cachefiles_object *object;
 290         unsigned int count = 0;
 291
 292         _enter("");
 293
 294         spin_lock(&cache->object_list_lock);
 295
 296         while (!list_empty(&cache->object_list)) {
 297                 object = list_first_entry(&cache->object_list,
 298                                           struct cachefiles_object, cache_link);
 299                 cachefiles_see_object(object, cachefiles_obj_see_withdrawal);
 300                 list_del_init(&object->cache_link);
 301                 fscache_withdraw_cookie(object->cookie);
 302                 count++;
 303                 if ((count & 63) == 0) {
 304                         spin_unlock(&cache->object_list_lock);
 305                         cond_resched();
 306                         spin_lock(&cache->object_list_lock);
 307                 }
 308         }
 309
 310         spin_unlock(&cache->object_list_lock);
 311         _leave(" [%u objs]", count);
 312 }
 313
 314 /*
 315  * Withdraw volumes.
 316  */
 317 static void cachefiles_withdraw_volumes(struct cachefiles_cache *cache)
 318 {
 319         _enter("");
 320
 321         for (;;) {
 322                 struct cachefiles_volume *volume = NULL;
 323
 324                 spin_lock(&cache->object_list_lock);
 325                 if (!list_empty(&cache->volumes)) {
 326                         volume = list_first_entry(&cache->volumes,
 327                                                   struct cachefiles_volume, cache_link);
 328                         list_del_init(&volume->cache_link);
 329                 }
 330                 spin_unlock(&cache->object_list_lock);
 331                 if (!volume)
 332                         break;
 333
 334                 cachefiles_withdraw_volume(volume);
 335         }
 336
 337         _leave("");
 338 }
 339
 340 /*
 341  * Sync a cache to backing disk.
 342  */
 343 static void cachefiles_sync_cache(struct cachefiles_cache *cache)
 344 {
 345         const struct cred *saved_cred;
 346         int ret;
 347
 348         _enter("%s", cache->cache->name);
 349
 350         /* make sure all pages pinned by operations on behalf of the netfs are
 351          * written to disc */
 352         cachefiles_begin_secure(cache, &saved_cred);
 353         down_read(&cache->mnt->mnt_sb->s_umount);
 354         ret = sync_filesystem(cache->mnt->mnt_sb);
 355         up_read(&cache->mnt->mnt_sb->s_umount);
 356         cachefiles_end_secure(cache, saved_cred);
 357
 358         if (ret == -EIO)
 359                 cachefiles_io_error(cache,
 360                                     "Attempt to sync backing fs superblock returned error %d",
 361                                     ret);
 362 }
 363
 364 /*
 365  * Withdraw cache objects.
 366  */
 367 void cachefiles_withdraw_cache(struct cachefiles_cache *cache)
 368 {
 369         struct fscache_cache *fscache = cache->cache;
 370
 371         pr_info("File cache on %s unregistering\n", fscache->name);
 372
 373         fscache_withdraw_cache(fscache);
 374
 375         /* we now have to destroy all the active objects pertaining to this
 376          * cache - which we do by passing them off to thread pool to be
 377          * disposed of */
 378         cachefiles_withdraw_objects(cache);
 379         fscache_wait_for_objects(fscache);
 380
 381         cachefiles_withdraw_volumes(cache);
 382         cachefiles_sync_cache(cache);
 383         cache->cache = NULL;
 384         fscache_relinquish_cache(fscache);
 385 }