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  * This global enablement flag may be read thousands of times per second
  23  * by cleancache_get/put/invalidate even on systems where cleancache_ops
  24  * is not claimed (e.g. cleancache is config'ed on but remains
  25  * disabled), so is preferred to the slower alternative: a function
  26  * call that checks a non-global.
  27  */
  28 int cleancache_enabled __read_mostly;
  29 EXPORT_SYMBOL(cleancache_enabled);
  30
  31 /*
  32  * cleancache_ops is set by cleancache_ops_register to contain the pointers
  33  * to the cleancache "backend" implementation functions.
  34  */
  35 static struct cleancache_ops cleancache_ops __read_mostly;
  36
  37 /*
  38  * Counters available via /sys/kernel/debug/frontswap (if debugfs is
  39  * properly configured.  These are for information only so are not protected
  40  * against increment races.
  41  */
  42 static u64 cleancache_succ_gets;
  43 static u64 cleancache_failed_gets;
  44 static u64 cleancache_puts;
  45 static u64 cleancache_invalidates;
  46
  47 /*
  48  * register operations for cleancache, returning previous thus allowing
  49  * detection of multiple backends and possible nesting
  50  */
  51 struct cleancache_ops cleancache_register_ops(struct cleancache_ops *ops)
  52 {
  53         struct cleancache_ops old = cleancache_ops;
  54
  55         cleancache_ops = *ops;
  56         cleancache_enabled = 1;
  57         return old;
  58 }
  59 EXPORT_SYMBOL(cleancache_register_ops);
  60
  61 /* Called by a cleancache-enabled filesystem at time of mount */
  62 void __cleancache_init_fs(struct super_block *sb)
  63 {
  64         sb->cleancache_poolid = (*cleancache_ops.init_fs)(PAGE_SIZE);
  65 }
  66 EXPORT_SYMBOL(__cleancache_init_fs);
  67
  68 /* Called by a cleancache-enabled clustered filesystem at time of mount */
  69 void __cleancache_init_shared_fs(char *uuid, struct super_block *sb)
  70 {
  71         sb->cleancache_poolid =
  72                 (*cleancache_ops.init_shared_fs)(uuid, PAGE_SIZE);
  73 }
  74 EXPORT_SYMBOL(__cleancache_init_shared_fs);
  75
  76 /*
  77  * If the filesystem uses exportable filehandles, use the filehandle as
  78  * the key, else use the inode number.
  79  */
  80 static int cleancache_get_key(struct inode *inode,
  81                               struct cleancache_filekey *key)
  82 {
  83         int (*fhfn)(struct dentry *, __u32 *fh, int *, int);
  84         int len = 0, maxlen = CLEANCACHE_KEY_MAX;
  85         struct super_block *sb = inode->i_sb;
  86
  87         key->u.ino = inode->i_ino;
  88         if (sb->s_export_op != NULL) {
  89                 fhfn = sb->s_export_op->encode_fh;
  90                 if  (fhfn) {
  91                         struct dentry d;
  92                         d.d_inode = inode;
  93                         len = (*fhfn)(&d, &key->u.fh[0], &maxlen, 0);
  94                         if (len <= 0 || len == 255)
  95                                 return -1;
  96                         if (maxlen > CLEANCACHE_KEY_MAX)
  97                                 return -1;
  98                 }
  99         }
 100         return 0;
 101 }
 102
 103 /*
 104  * "Get" data from cleancache associated with the poolid/inode/index
 105  * that were specified when the data was put to cleanache and, if
 106  * successful, use it to fill the specified page with data and return 0.
 107  * The pageframe is unchanged and returns -1 if the get fails.
 108  * Page must be locked by caller.
 109  */
 110 int __cleancache_get_page(struct page *page)
 111 {
 112         int ret = -1;
 113         int pool_id;
 114         struct cleancache_filekey key = { .u.key = { 0 } };
 115
 116         VM_BUG_ON(!PageLocked(page));
 117         pool_id = page->mapping->host->i_sb->cleancache_poolid;
 118         if (pool_id < 0)
 119                 goto out;
 120
 121         if (cleancache_get_key(page->mapping->host, &key) < 0)
 122                 goto out;
 123
 124         ret = (*cleancache_ops.get_page)(pool_id, key, page->index, page);
 125         if (ret == 0)
 126                 cleancache_succ_gets++;
 127         else
 128                 cleancache_failed_gets++;
 129 out:
 130         return ret;
 131 }
 132 EXPORT_SYMBOL(__cleancache_get_page);
 133
 134 /*
 135  * "Put" data from a page to cleancache and associate it with the
 136  * (previously-obtained per-filesystem) poolid and the page's,
 137  * inode and page index.  Page must be locked.  Note that a put_page
 138  * always "succeeds", though a subsequent get_page may succeed or fail.
 139  */
 140 void __cleancache_put_page(struct page *page)
 141 {
 142         int pool_id;
 143         struct cleancache_filekey key = { .u.key = { 0 } };
 144
 145         VM_BUG_ON(!PageLocked(page));
 146         pool_id = page->mapping->host->i_sb->cleancache_poolid;
 147         if (pool_id >= 0 &&
 148               cleancache_get_key(page->mapping->host, &key) >= 0) {
 149                 (*cleancache_ops.put_page)(pool_id, key, page->index, page);
 150                 cleancache_puts++;
 151         }
 152 }
 153 EXPORT_SYMBOL(__cleancache_put_page);
 154
 155 /*
 156  * Invalidate any data from cleancache associated with the poolid and the
 157  * page's inode and page index so that a subsequent "get" will fail.
 158  */
 159 void __cleancache_invalidate_page(struct address_space *mapping,
 160                                         struct page *page)
 161 {
 162         /* careful... page->mapping is NULL sometimes when this is called */
 163         int pool_id = mapping->host->i_sb->cleancache_poolid;
 164         struct cleancache_filekey key = { .u.key = { 0 } };
 165
 166         if (pool_id >= 0) {
 167                 VM_BUG_ON(!PageLocked(page));
 168                 if (cleancache_get_key(mapping->host, &key) >= 0) {
 169                         (*cleancache_ops.invalidate_page)(pool_id,
 170                                                           key, page->index);
 171                         cleancache_invalidates++;
 172                 }
 173         }
 174 }
 175 EXPORT_SYMBOL(__cleancache_invalidate_page);
 176
 177 /*
 178  * Invalidate all data from cleancache associated with the poolid and the
 179  * mappings's inode so that all subsequent gets to this poolid/inode
 180  * will fail.
 181  */
 182 void __cleancache_invalidate_inode(struct address_space *mapping)
 183 {
 184         int pool_id = mapping->host->i_sb->cleancache_poolid;
 185         struct cleancache_filekey key = { .u.key = { 0 } };
 186
 187         if (pool_id >= 0 && cleancache_get_key(mapping->host, &key) >= 0)
 188                 (*cleancache_ops.invalidate_inode)(pool_id, key);
 189 }
 190 EXPORT_SYMBOL(__cleancache_invalidate_inode);
 191
 192 /*
 193  * Called by any cleancache-enabled filesystem at time of unmount;
 194  * note that pool_id is surrendered and may be reutrned by a subsequent
 195  * cleancache_init_fs or cleancache_init_shared_fs
 196  */
 197 void __cleancache_invalidate_fs(struct super_block *sb)
 198 {
 199         if (sb->cleancache_poolid >= 0) {
 200                 int old_poolid = sb->cleancache_poolid;
 201                 sb->cleancache_poolid = -1;
 202                 (*cleancache_ops.invalidate_fs)(old_poolid);
 203         }
 204 }
 205 EXPORT_SYMBOL(__cleancache_invalidate_fs);
 206
 207 static int __init init_cleancache(void)
 208 {
 209 #ifdef CONFIG_DEBUG_FS
 210         struct dentry *root = debugfs_create_dir("cleancache", NULL);
 211         if (root == NULL)
 212                 return -ENXIO;
 213         debugfs_create_u64("succ_gets", S_IRUGO, root, &cleancache_succ_gets);
 214         debugfs_create_u64("failed_gets", S_IRUGO,
 215                                 root, &cleancache_failed_gets);
 216         debugfs_create_u64("puts", S_IRUGO, root, &cleancache_puts);
 217         debugfs_create_u64("invalidates", S_IRUGO,
 218                                 root, &cleancache_invalidates);
 219 #endif
 220         return 0;
 221 }
 222 module_init(init_cleancache)