mm/cleancache.c

   1 /*
   2  * Cleancache frontend
   3  *
   4  * This code provides the generic "frontend" layer to call a matching
   5  * "backend" driver implementation of cleancache.  See
   6  * Documentation/vm/cleancache.txt for more information.
   7  *
   8  * Copyright (C) 2009-2010 Oracle Corp. All rights reserved.
   9  * Author: Dan Magenheimer
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/fs.h>
  16 #include <linux/exportfs.h>
  17 #include <linux/mm.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/cleancache.h>
  20
  21 /*
  22  * cleancache_ops is set by cleancache_ops_register to contain the pointers
  23  * to the cleancache "backend" implementation functions.
  24  */
  25 static struct cleancache_ops *cleancache_ops __read_mostly;
  26
  27 /*
  28  * Counters available via /sys/kernel/debug/cleancache (if debugfs is
  29  * properly configured.  These are for information only so are not protected
  30  * against increment races.
  31  */
  32 static u64 cleancache_succ_gets;
  33 static u64 cleancache_failed_gets;
  34 static u64 cleancache_puts;
  35 static u64 cleancache_invalidates;
  36
  37 /*
  38  * When no backend is registered all calls to init_fs and init_shared_fs
  39  * are registered and fake poolids (FAKE_FS_POOLID_OFFSET or
  40  * FAKE_SHARED_FS_POOLID_OFFSET, plus offset in the respective array
  41  * [shared_|]fs_poolid_map) are given to the respective super block
  42  * (sb->cleancache_poolid) and no tmem_pools are created. When a backend
  43  * registers with cleancache the previous calls to init_fs and init_shared_fs
  44  * are executed to create tmem_pools and set the respective poolids. While no
  45  * backend is registered all "puts", "gets" and "flushes" are ignored or failed.
  46  */
  47 #define MAX_INITIALIZABLE_FS 32
  48 #define FAKE_FS_POOLID_OFFSET 1000
  49 #define FAKE_SHARED_FS_POOLID_OFFSET 2000
  50
  51 #define FS_NO_BACKEND (-1)
  52 #define FS_UNKNOWN (-2)
  53 static int fs_poolid_map[MAX_INITIALIZABLE_FS];
  54 static int shared_fs_poolid_map[MAX_INITIALIZABLE_FS];
  55 static char *uuids[MAX_INITIALIZABLE_FS];
  56 /*
  57  * Mutex for the [shared_|]fs_poolid_map to guard against multiple threads
  58  * invoking umount (and ending in __cleancache_invalidate_fs) and also multiple
  59  * threads calling mount (and ending up in __cleancache_init_[shared|]fs).
  60  */
  61 static DEFINE_MUTEX(poolid_mutex);
  62 /*
  63  * When set to false (default) all calls to the cleancache functions, except
  64  * the __cleancache_invalidate_fs and __cleancache_init_[shared|]fs are guarded
  65  * by the if (!cleancache_ops) return. This means multiple threads (from
  66  * different filesystems) will be checking cleancache_ops. The usage of a
  67  * bool instead of a atomic_t or a bool guarded by a spinlock is OK - we are
  68  * OK if the time between the backend's have been initialized (and
  69  * cleancache_ops has been set to not NULL) and when the filesystems start
  70  * actually calling the backends. The inverse (when unloading) is obviously
  71  * not good - but this shim does not do that (yet).
  72  */
  73
  74 /*
  75  * The backends and filesystems work all asynchronously. This is b/c the
  76  * backends can be built as modules.
  77  * The usual sequence of events is:
  78  *      a) mount /      -> __cleancache_init_fs is called. We set the
  79  *              [shared_|]fs_poolid_map and uuids for.
  80  *
  81  *      b). user does I/Os -> we call the rest of __cleancache_* functions
  82  *              which return immediately as cleancache_ops is false.
  83  *
  84  *      c). modprobe zcache -> cleancache_register_ops. We init the backend
  85  *              and set cleancache_ops to true, and for any fs_poolid_map
  86  *              (which is set by __cleancache_init_fs) we initialize the poolid.
  87  *
  88  *      d). user does I/Os -> now that cleancache_ops is true all the
  89  *              __cleancache_* functions can call the backend. They all check
  90  *              that fs_poolid_map is valid and if so invoke the backend.
  91  *
  92  *      e). umount /    -> __cleancache_invalidate_fs, the fs_poolid_map is
  93  *              reset (which is the second check in the __cleancache_* ops
  94  *              to call the backend).
  95  *
  96  * The sequence of event could also be c), followed by a), and d). and e). The
  97  * c) would not happen anymore. There is also the chance of c), and one thread
  98  * doing a) + d), and another doing e). For that case we depend on the
  99  * filesystem calling __cleancache_invalidate_fs in the proper sequence (so
 100  * that it handles all I/Os before it invalidates the fs (which is last part
 101  * of unmounting process).
 102  *
 103  * Note: The acute reader will notice that there is no "rmmod zcache" case.
 104  * This is b/c the functionality for that is not yet implemented and when
 105  * done, will require some extra locking not yet devised.
 106  */
 107
 108 /*
 109  * Register operations for cleancache. Returns 0 on success.
 110  */
 111 int cleancache_register_ops(struct cleancache_ops *ops)
 112 {
 113         int i;
 114
 115         mutex_lock(&poolid_mutex);
 116         if (cleancache_ops) {
 117                 mutex_unlock(&poolid_mutex);
 118                 return -EBUSY;
 119         }
 120         for (i = 0; i < MAX_INITIALIZABLE_FS; i++) {
 121                 if (fs_poolid_map[i] == FS_NO_BACKEND)
 122                         fs_poolid_map[i] = ops->init_fs(PAGE_SIZE);
 123                 if (shared_fs_poolid_map[i] == FS_NO_BACKEND)
 124                         shared_fs_poolid_map[i] = ops->init_shared_fs
 125                                         (uuids[i], PAGE_SIZE);
 126         }
 127         /*
 128          * We MUST set cleancache_ops _after_ we have called the backends
 129          * init_fs or init_shared_fs functions. Otherwise the compiler might
 130          * re-order where cleancache_ops is set in this function.
 131          */
 132         barrier();
 133         cleancache_ops = ops;
 134         mutex_unlock(&poolid_mutex);
 135         return 0;
 136 }
 137 EXPORT_SYMBOL(cleancache_register_ops);
 138
 139 /* Called by a cleancache-enabled filesystem at time of mount */
 140 void __cleancache_init_fs(struct super_block *sb)
 141 {
 142         int i;
 143
 144         mutex_lock(&poolid_mutex);
 145         for (i = 0; i < MAX_INITIALIZABLE_FS; i++) {
 146                 if (fs_poolid_map[i] == FS_UNKNOWN) {
 147                         sb->cleancache_poolid = i + FAKE_FS_POOLID_OFFSET;
 148                         if (cleancache_ops)
 149                                 fs_poolid_map[i] = cleancache_ops->init_fs(PAGE_SIZE);
 150                         else
 151                                 fs_poolid_map[i] = FS_NO_BACKEND;
 152                         break;
 153                 }
 154         }
 155         mutex_unlock(&poolid_mutex);
 156 }
 157 EXPORT_SYMBOL(__cleancache_init_fs);
 158
 159 /* Called by a cleancache-enabled clustered filesystem at time of mount */
 160 void __cleancache_init_shared_fs(struct super_block *sb)
 161 {
 162         int i;
 163
 164         mutex_lock(&poolid_mutex);
 165         for (i = 0; i < MAX_INITIALIZABLE_FS; i++) {
 166                 if (shared_fs_poolid_map[i] == FS_UNKNOWN) {
 167                         sb->cleancache_poolid = i + FAKE_SHARED_FS_POOLID_OFFSET;
 168                         uuids[i] = sb->s_uuid;
 169                         if (cleancache_ops)
 170                                 shared_fs_poolid_map[i] = cleancache_ops->init_shared_fs
 171                                                 (sb->s_uuid, PAGE_SIZE);
 172                         else
 173                                 shared_fs_poolid_map[i] = FS_NO_BACKEND;
 174                         break;
 175                 }
 176         }
 177         mutex_unlock(&poolid_mutex);
 178 }
 179 EXPORT_SYMBOL(__cleancache_init_shared_fs);
 180
 181 /*
 182  * If the filesystem uses exportable filehandles, use the filehandle as
 183  * the key, else use the inode number.
 184  */
 185 static int cleancache_get_key(struct inode *inode,
 186                               struct cleancache_filekey *key)
 187 {
 188         int (*fhfn)(struct inode *, __u32 *fh, int *, struct inode *);
 189         int len = 0, maxlen = CLEANCACHE_KEY_MAX;
 190         struct super_block *sb = inode->i_sb;
 191
 192         key->u.ino = inode->i_ino;
 193         if (sb->s_export_op != NULL) {
 194                 fhfn = sb->s_export_op->encode_fh;
 195                 if  (fhfn) {
 196                         len = (*fhfn)(inode, &key->u.fh[0], &maxlen, NULL);
 197                         if (len <= FILEID_ROOT || len == FILEID_INVALID)
 198                                 return -1;
 199                         if (maxlen > CLEANCACHE_KEY_MAX)
 200                                 return -1;
 201                 }
 202         }
 203         return 0;
 204 }
 205
 206 /*
 207  * Returns a pool_id that is associated with a given fake poolid.
 208  */
 209 static int get_poolid_from_fake(int fake_pool_id)
 210 {
 211         if (fake_pool_id >= FAKE_SHARED_FS_POOLID_OFFSET)
 212                 return shared_fs_poolid_map[fake_pool_id -
 213                         FAKE_SHARED_FS_POOLID_OFFSET];
 214         else if (fake_pool_id >= FAKE_FS_POOLID_OFFSET)
 215                 return fs_poolid_map[fake_pool_id - FAKE_FS_POOLID_OFFSET];
 216         return FS_NO_BACKEND;
 217 }
 218
 219 /*
 220  * "Get" data from cleancache associated with the poolid/inode/index
 221  * that were specified when the data was put to cleanache and, if
 222  * successful, use it to fill the specified page with data and return 0.
 223  * The pageframe is unchanged and returns -1 if the get fails.
 224  * Page must be locked by caller.
 225  *
 226  * The function has two checks before any action is taken - whether
 227  * a backend is registered and whether the sb->cleancache_poolid
 228  * is correct.
 229  */
 230 int __cleancache_get_page(struct page *page)
 231 {
 232         int ret = -1;
 233         int pool_id;
 234         int fake_pool_id;
 235         struct cleancache_filekey key = { .u.key = { 0 } };
 236
 237         if (!cleancache_ops) {
 238                 cleancache_failed_gets++;
 239                 goto out;
 240         }
 241
 242         VM_BUG_ON_PAGE(!PageLocked(page), page);
 243         fake_pool_id = page->mapping->host->i_sb->cleancache_poolid;
 244         if (fake_pool_id < 0)
 245                 goto out;
 246         pool_id = get_poolid_from_fake(fake_pool_id);
 247
 248         if (cleancache_get_key(page->mapping->host, &key) < 0)
 249                 goto out;
 250
 251         if (pool_id >= 0)
 252                 ret = cleancache_ops->get_page(pool_id,
 253                                 key, page->index, page);
 254         if (ret == 0)
 255                 cleancache_succ_gets++;
 256         else
 257                 cleancache_failed_gets++;
 258 out:
 259         return ret;
 260 }
 261 EXPORT_SYMBOL(__cleancache_get_page);
 262
 263 /*
 264  * "Put" data from a page to cleancache and associate it with the
 265  * (previously-obtained per-filesystem) poolid and the page's,
 266  * inode and page index.  Page must be locked.  Note that a put_page
 267  * always "succeeds", though a subsequent get_page may succeed or fail.
 268  *
 269  * The function has two checks before any action is taken - whether
 270  * a backend is registered and whether the sb->cleancache_poolid
 271  * is correct.
 272  */
 273 void __cleancache_put_page(struct page *page)
 274 {
 275         int pool_id;
 276         int fake_pool_id;
 277         struct cleancache_filekey key = { .u.key = { 0 } };
 278
 279         if (!cleancache_ops) {
 280                 cleancache_puts++;
 281                 return;
 282         }
 283
 284         VM_BUG_ON_PAGE(!PageLocked(page), page);
 285         fake_pool_id = page->mapping->host->i_sb->cleancache_poolid;
 286         if (fake_pool_id < 0)
 287                 return;
 288
 289         pool_id = get_poolid_from_fake(fake_pool_id);
 290
 291         if (pool_id >= 0 &&
 292                 cleancache_get_key(page->mapping->host, &key) >= 0) {
 293                 cleancache_ops->put_page(pool_id, key, page->index, page);
 294                 cleancache_puts++;
 295         }
 296 }
 297 EXPORT_SYMBOL(__cleancache_put_page);
 298
 299 /*
 300  * Invalidate any data from cleancache associated with the poolid and the
 301  * page's inode and page index so that a subsequent "get" will fail.
 302  *
 303  * The function has two checks before any action is taken - whether
 304  * a backend is registered and whether the sb->cleancache_poolid
 305  * is correct.
 306  */
 307 void __cleancache_invalidate_page(struct address_space *mapping,
 308                                         struct page *page)
 309 {
 310         /* careful... page->mapping is NULL sometimes when this is called */
 311         int pool_id;
 312         int fake_pool_id = mapping->host->i_sb->cleancache_poolid;
 313         struct cleancache_filekey key = { .u.key = { 0 } };
 314
 315         if (!cleancache_ops)
 316                 return;
 317
 318         if (fake_pool_id >= 0) {
 319                 pool_id = get_poolid_from_fake(fake_pool_id);
 320                 if (pool_id < 0)
 321                         return;
 322
 323                 VM_BUG_ON_PAGE(!PageLocked(page), page);
 324                 if (cleancache_get_key(mapping->host, &key) >= 0) {
 325                         cleancache_ops->invalidate_page(pool_id,
 326                                         key, page->index);
 327                         cleancache_invalidates++;
 328                 }
 329         }
 330 }
 331 EXPORT_SYMBOL(__cleancache_invalidate_page);
 332
 333 /*
 334  * Invalidate all data from cleancache associated with the poolid and the
 335  * mappings's inode so that all subsequent gets to this poolid/inode
 336  * will fail.
 337  *
 338  * The function has two checks before any action is taken - whether
 339  * a backend is registered and whether the sb->cleancache_poolid
 340  * is correct.
 341  */
 342 void __cleancache_invalidate_inode(struct address_space *mapping)
 343 {
 344         int pool_id;
 345         int fake_pool_id = mapping->host->i_sb->cleancache_poolid;
 346         struct cleancache_filekey key = { .u.key = { 0 } };
 347
 348         if (!cleancache_ops)
 349                 return;
 350
 351         if (fake_pool_id < 0)
 352                 return;
 353
 354         pool_id = get_poolid_from_fake(fake_pool_id);
 355
 356         if (pool_id >= 0 && cleancache_get_key(mapping->host, &key) >= 0)
 357                 cleancache_ops->invalidate_inode(pool_id, key);
 358 }
 359 EXPORT_SYMBOL(__cleancache_invalidate_inode);
 360
 361 /*
 362  * Called by any cleancache-enabled filesystem at time of unmount;
 363  * note that pool_id is surrendered and may be returned by a subsequent
 364  * cleancache_init_fs or cleancache_init_shared_fs.
 365  */
 366 void __cleancache_invalidate_fs(struct super_block *sb)
 367 {
 368         int index;
 369         int fake_pool_id = sb->cleancache_poolid;
 370         int old_poolid = fake_pool_id;
 371
 372         mutex_lock(&poolid_mutex);
 373         if (fake_pool_id >= FAKE_SHARED_FS_POOLID_OFFSET) {
 374                 index = fake_pool_id - FAKE_SHARED_FS_POOLID_OFFSET;
 375                 old_poolid = shared_fs_poolid_map[index];
 376                 shared_fs_poolid_map[index] = FS_UNKNOWN;
 377                 uuids[index] = NULL;
 378         } else if (fake_pool_id >= FAKE_FS_POOLID_OFFSET) {
 379                 index = fake_pool_id - FAKE_FS_POOLID_OFFSET;
 380                 old_poolid = fs_poolid_map[index];
 381                 fs_poolid_map[index] = FS_UNKNOWN;
 382         }
 383         sb->cleancache_poolid = -1;
 384         if (cleancache_ops)
 385                 cleancache_ops->invalidate_fs(old_poolid);
 386         mutex_unlock(&poolid_mutex);
 387 }
 388 EXPORT_SYMBOL(__cleancache_invalidate_fs);
 389
 390 static int __init init_cleancache(void)
 391 {
 392         int i;
 393
 394 #ifdef CONFIG_DEBUG_FS
 395         struct dentry *root = debugfs_create_dir("cleancache", NULL);
 396         if (root == NULL)
 397                 return -ENXIO;
 398         debugfs_create_u64("succ_gets", S_IRUGO, root, &cleancache_succ_gets);
 399         debugfs_create_u64("failed_gets", S_IRUGO,
 400                                 root, &cleancache_failed_gets);
 401         debugfs_create_u64("puts", S_IRUGO, root, &cleancache_puts);
 402         debugfs_create_u64("invalidates", S_IRUGO,
 403                                 root, &cleancache_invalidates);
 404 #endif
 405         for (i = 0; i < MAX_INITIALIZABLE_FS; i++) {
 406                 fs_poolid_map[i] = FS_UNKNOWN;
 407                 shared_fs_poolid_map[i] = FS_UNKNOWN;
 408         }
 409         return 0;
 410 }
 411 module_init(init_cleancache)