Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 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> |
Dan Magenheimer | 417fc2c | 2011-09-21 12:28:04 -0400 | [diff] [blame] | 18 | #include <linux/debugfs.h> |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 19 | #include <linux/cleancache.h> |
| 20 | |
| 21 | /* |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 22 | * cleancache_ops is set by cleancache_register_ops to contain the pointers |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 23 | * to the cleancache "backend" implementation functions. |
| 24 | */ |
Julia Lawall | b3c6de4 | 2016-01-21 16:47:29 +0100 | [diff] [blame] | 25 | static const struct cleancache_ops *cleancache_ops __read_mostly; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 26 | |
Dan Magenheimer | 417fc2c | 2011-09-21 12:28:04 -0400 | [diff] [blame] | 27 | /* |
Marcin Jabrzyk | 8fc8f4d | 2015-01-07 11:14:41 +0100 | [diff] [blame] | 28 | * Counters available via /sys/kernel/debug/cleancache (if debugfs is |
Dan Magenheimer | 417fc2c | 2011-09-21 12:28:04 -0400 | [diff] [blame] | 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; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 36 | |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 37 | static void cleancache_register_ops_sb(struct super_block *sb, void *unused) |
| 38 | { |
| 39 | switch (sb->cleancache_poolid) { |
| 40 | case CLEANCACHE_NO_BACKEND: |
| 41 | __cleancache_init_fs(sb); |
| 42 | break; |
| 43 | case CLEANCACHE_NO_BACKEND_SHARED: |
| 44 | __cleancache_init_shared_fs(sb); |
| 45 | break; |
| 46 | } |
| 47 | } |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 48 | |
| 49 | /* |
Vladimir Davydov | 53d85c9 | 2015-04-14 15:46:45 -0700 | [diff] [blame] | 50 | * Register operations for cleancache. Returns 0 on success. |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 51 | */ |
Julia Lawall | b3c6de4 | 2016-01-21 16:47:29 +0100 | [diff] [blame] | 52 | int cleancache_register_ops(const struct cleancache_ops *ops) |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 53 | { |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 54 | if (cmpxchg(&cleancache_ops, NULL, ops)) |
Vladimir Davydov | 53d85c9 | 2015-04-14 15:46:45 -0700 | [diff] [blame] | 55 | return -EBUSY; |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 56 | |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 57 | /* |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 58 | * A cleancache backend can be built as a module and hence loaded after |
| 59 | * a cleancache enabled filesystem has called cleancache_init_fs. To |
| 60 | * handle such a scenario, here we call ->init_fs or ->init_shared_fs |
| 61 | * for each active super block. To differentiate between local and |
| 62 | * shared filesystems, we temporarily initialize sb->cleancache_poolid |
| 63 | * to CLEANCACHE_NO_BACKEND or CLEANCACHE_NO_BACKEND_SHARED |
| 64 | * respectively in case there is no backend registered at the time |
| 65 | * cleancache_init_fs or cleancache_init_shared_fs is called. |
| 66 | * |
| 67 | * Since filesystems can be mounted concurrently with cleancache |
| 68 | * backend registration, we have to be careful to guarantee that all |
| 69 | * cleancache enabled filesystems that has been mounted by the time |
| 70 | * cleancache_register_ops is called has got and all mounted later will |
| 71 | * get cleancache_poolid. This is assured by the following statements |
| 72 | * tied together: |
| 73 | * |
| 74 | * a) iterate_supers skips only those super blocks that has started |
| 75 | * ->kill_sb |
| 76 | * |
| 77 | * b) if iterate_supers encounters a super block that has not finished |
| 78 | * ->mount yet, it waits until it is finished |
| 79 | * |
| 80 | * c) cleancache_init_fs is called from ->mount and |
| 81 | * cleancache_invalidate_fs is called from ->kill_sb |
| 82 | * |
| 83 | * d) we call iterate_supers after cleancache_ops has been set |
| 84 | * |
| 85 | * From a) it follows that if iterate_supers skips a super block, then |
| 86 | * either the super block is already dead, in which case we do not need |
| 87 | * to bother initializing cleancache for it, or it was mounted after we |
| 88 | * initiated iterate_supers. In the latter case, it must have seen |
| 89 | * cleancache_ops set according to d) and initialized cleancache from |
| 90 | * ->mount by itself according to c). This proves that we call |
| 91 | * ->init_fs at least once for each active super block. |
| 92 | * |
| 93 | * From b) and c) it follows that if iterate_supers encounters a super |
| 94 | * block that has already started ->init_fs, it will wait until ->mount |
| 95 | * and hence ->init_fs has finished, then check cleancache_poolid, see |
| 96 | * that it has already been set and therefore do nothing. This proves |
| 97 | * that we call ->init_fs no more than once for each super block. |
| 98 | * |
| 99 | * Combined together, the last two paragraphs prove the function |
| 100 | * correctness. |
| 101 | * |
| 102 | * Note that various cleancache callbacks may proceed before this |
| 103 | * function is called or even concurrently with it, but since |
| 104 | * CLEANCACHE_NO_BACKEND is negative, they will all result in a noop |
| 105 | * until the corresponding ->init_fs has been actually called and |
| 106 | * cleancache_ops has been set. |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 107 | */ |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 108 | iterate_supers(cleancache_register_ops_sb, NULL); |
Vladimir Davydov | 53d85c9 | 2015-04-14 15:46:45 -0700 | [diff] [blame] | 109 | return 0; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 110 | } |
| 111 | EXPORT_SYMBOL(cleancache_register_ops); |
| 112 | |
| 113 | /* Called by a cleancache-enabled filesystem at time of mount */ |
| 114 | void __cleancache_init_fs(struct super_block *sb) |
| 115 | { |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 116 | int pool_id = CLEANCACHE_NO_BACKEND; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 117 | |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 118 | if (cleancache_ops) { |
| 119 | pool_id = cleancache_ops->init_fs(PAGE_SIZE); |
| 120 | if (pool_id < 0) |
| 121 | pool_id = CLEANCACHE_NO_POOL; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 122 | } |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 123 | sb->cleancache_poolid = pool_id; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 124 | } |
| 125 | EXPORT_SYMBOL(__cleancache_init_fs); |
| 126 | |
| 127 | /* Called by a cleancache-enabled clustered filesystem at time of mount */ |
Vladimir Davydov | 9de1626 | 2015-04-14 15:46:42 -0700 | [diff] [blame] | 128 | void __cleancache_init_shared_fs(struct super_block *sb) |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 129 | { |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 130 | int pool_id = CLEANCACHE_NO_BACKEND_SHARED; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 131 | |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 132 | if (cleancache_ops) { |
| 133 | pool_id = cleancache_ops->init_shared_fs(sb->s_uuid, PAGE_SIZE); |
| 134 | if (pool_id < 0) |
| 135 | pool_id = CLEANCACHE_NO_POOL; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 136 | } |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 137 | sb->cleancache_poolid = pool_id; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 138 | } |
| 139 | EXPORT_SYMBOL(__cleancache_init_shared_fs); |
| 140 | |
| 141 | /* |
| 142 | * If the filesystem uses exportable filehandles, use the filehandle as |
| 143 | * the key, else use the inode number. |
| 144 | */ |
| 145 | static int cleancache_get_key(struct inode *inode, |
| 146 | struct cleancache_filekey *key) |
| 147 | { |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 148 | int (*fhfn)(struct inode *, __u32 *fh, int *, struct inode *); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 149 | int len = 0, maxlen = CLEANCACHE_KEY_MAX; |
| 150 | struct super_block *sb = inode->i_sb; |
| 151 | |
| 152 | key->u.ino = inode->i_ino; |
| 153 | if (sb->s_export_op != NULL) { |
| 154 | fhfn = sb->s_export_op->encode_fh; |
| 155 | if (fhfn) { |
Al Viro | b0b0382 | 2012-04-02 14:34:06 -0400 | [diff] [blame] | 156 | len = (*fhfn)(inode, &key->u.fh[0], &maxlen, NULL); |
Namjae Jeon | 94e07a75 | 2013-02-17 15:48:11 +0900 | [diff] [blame] | 157 | if (len <= FILEID_ROOT || len == FILEID_INVALID) |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 158 | return -1; |
| 159 | if (maxlen > CLEANCACHE_KEY_MAX) |
| 160 | return -1; |
| 161 | } |
| 162 | } |
| 163 | return 0; |
| 164 | } |
| 165 | |
| 166 | /* |
| 167 | * "Get" data from cleancache associated with the poolid/inode/index |
| 168 | * that were specified when the data was put to cleanache and, if |
| 169 | * successful, use it to fill the specified page with data and return 0. |
| 170 | * The pageframe is unchanged and returns -1 if the get fails. |
| 171 | * Page must be locked by caller. |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 172 | * |
| 173 | * The function has two checks before any action is taken - whether |
| 174 | * a backend is registered and whether the sb->cleancache_poolid |
| 175 | * is correct. |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 176 | */ |
| 177 | int __cleancache_get_page(struct page *page) |
| 178 | { |
| 179 | int ret = -1; |
| 180 | int pool_id; |
| 181 | struct cleancache_filekey key = { .u.key = { 0 } }; |
| 182 | |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 183 | if (!cleancache_ops) { |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 184 | cleancache_failed_gets++; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 185 | goto out; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 186 | } |
| 187 | |
Sasha Levin | 309381fea | 2014-01-23 15:52:54 -0800 | [diff] [blame] | 188 | VM_BUG_ON_PAGE(!PageLocked(page), page); |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 189 | pool_id = page->mapping->host->i_sb->cleancache_poolid; |
| 190 | if (pool_id < 0) |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 191 | goto out; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 192 | |
| 193 | if (cleancache_get_key(page->mapping->host, &key) < 0) |
| 194 | goto out; |
| 195 | |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 196 | ret = cleancache_ops->get_page(pool_id, key, page->index, page); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 197 | if (ret == 0) |
| 198 | cleancache_succ_gets++; |
| 199 | else |
| 200 | cleancache_failed_gets++; |
| 201 | out: |
| 202 | return ret; |
| 203 | } |
| 204 | EXPORT_SYMBOL(__cleancache_get_page); |
| 205 | |
| 206 | /* |
| 207 | * "Put" data from a page to cleancache and associate it with the |
| 208 | * (previously-obtained per-filesystem) poolid and the page's, |
| 209 | * inode and page index. Page must be locked. Note that a put_page |
| 210 | * always "succeeds", though a subsequent get_page may succeed or fail. |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 211 | * |
| 212 | * The function has two checks before any action is taken - whether |
| 213 | * a backend is registered and whether the sb->cleancache_poolid |
| 214 | * is correct. |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 215 | */ |
| 216 | void __cleancache_put_page(struct page *page) |
| 217 | { |
| 218 | int pool_id; |
| 219 | struct cleancache_filekey key = { .u.key = { 0 } }; |
| 220 | |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 221 | if (!cleancache_ops) { |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 222 | cleancache_puts++; |
| 223 | return; |
| 224 | } |
| 225 | |
Sasha Levin | 309381fea | 2014-01-23 15:52:54 -0800 | [diff] [blame] | 226 | VM_BUG_ON_PAGE(!PageLocked(page), page); |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 227 | pool_id = page->mapping->host->i_sb->cleancache_poolid; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 228 | if (pool_id >= 0 && |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 229 | cleancache_get_key(page->mapping->host, &key) >= 0) { |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 230 | cleancache_ops->put_page(pool_id, key, page->index, page); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 231 | cleancache_puts++; |
| 232 | } |
| 233 | } |
| 234 | EXPORT_SYMBOL(__cleancache_put_page); |
| 235 | |
| 236 | /* |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 237 | * Invalidate any data from cleancache associated with the poolid and the |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 238 | * page's inode and page index so that a subsequent "get" will fail. |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 239 | * |
| 240 | * The function has two checks before any action is taken - whether |
| 241 | * a backend is registered and whether the sb->cleancache_poolid |
| 242 | * is correct. |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 243 | */ |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 244 | void __cleancache_invalidate_page(struct address_space *mapping, |
| 245 | struct page *page) |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 246 | { |
| 247 | /* careful... page->mapping is NULL sometimes when this is called */ |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 248 | int pool_id = mapping->host->i_sb->cleancache_poolid; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 249 | struct cleancache_filekey key = { .u.key = { 0 } }; |
| 250 | |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 251 | if (!cleancache_ops) |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 252 | return; |
| 253 | |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 254 | if (pool_id >= 0) { |
Sasha Levin | 309381fea | 2014-01-23 15:52:54 -0800 | [diff] [blame] | 255 | VM_BUG_ON_PAGE(!PageLocked(page), page); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 256 | if (cleancache_get_key(mapping->host, &key) >= 0) { |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 257 | cleancache_ops->invalidate_page(pool_id, |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 258 | key, page->index); |
Dan Magenheimer | 417fc2c | 2011-09-21 12:28:04 -0400 | [diff] [blame] | 259 | cleancache_invalidates++; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 260 | } |
| 261 | } |
| 262 | } |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 263 | EXPORT_SYMBOL(__cleancache_invalidate_page); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 264 | |
| 265 | /* |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 266 | * Invalidate all data from cleancache associated with the poolid and the |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 267 | * mappings's inode so that all subsequent gets to this poolid/inode |
| 268 | * will fail. |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 269 | * |
| 270 | * The function has two checks before any action is taken - whether |
| 271 | * a backend is registered and whether the sb->cleancache_poolid |
| 272 | * is correct. |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 273 | */ |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 274 | void __cleancache_invalidate_inode(struct address_space *mapping) |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 275 | { |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 276 | int pool_id = mapping->host->i_sb->cleancache_poolid; |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 277 | struct cleancache_filekey key = { .u.key = { 0 } }; |
| 278 | |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 279 | if (!cleancache_ops) |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 280 | return; |
| 281 | |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 282 | if (pool_id >= 0 && cleancache_get_key(mapping->host, &key) >= 0) |
Konrad Rzeszutek Wilk | 833f866 | 2013-04-30 15:26:57 -0700 | [diff] [blame] | 283 | cleancache_ops->invalidate_inode(pool_id, key); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 284 | } |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 285 | EXPORT_SYMBOL(__cleancache_invalidate_inode); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 286 | |
| 287 | /* |
| 288 | * Called by any cleancache-enabled filesystem at time of unmount; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 289 | * note that pool_id is surrendered and may be returned by a subsequent |
| 290 | * cleancache_init_fs or cleancache_init_shared_fs. |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 291 | */ |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 292 | void __cleancache_invalidate_fs(struct super_block *sb) |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 293 | { |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 294 | int pool_id; |
Dan Magenheimer | 49a9ab8 | 2013-04-30 15:26:56 -0700 | [diff] [blame] | 295 | |
Vladimir Davydov | 3cb29d1 | 2015-04-14 15:46:48 -0700 | [diff] [blame] | 296 | pool_id = sb->cleancache_poolid; |
| 297 | sb->cleancache_poolid = CLEANCACHE_NO_POOL; |
| 298 | |
| 299 | if (cleancache_ops && pool_id >= 0) |
| 300 | cleancache_ops->invalidate_fs(pool_id); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 301 | } |
Dan Magenheimer | 3167760 | 2011-09-21 11:56:28 -0400 | [diff] [blame] | 302 | EXPORT_SYMBOL(__cleancache_invalidate_fs); |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 303 | |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 304 | static int __init init_cleancache(void) |
| 305 | { |
Dan Magenheimer | 417fc2c | 2011-09-21 12:28:04 -0400 | [diff] [blame] | 306 | #ifdef CONFIG_DEBUG_FS |
| 307 | struct dentry *root = debugfs_create_dir("cleancache", NULL); |
| 308 | if (root == NULL) |
| 309 | return -ENXIO; |
| 310 | debugfs_create_u64("succ_gets", S_IRUGO, root, &cleancache_succ_gets); |
| 311 | debugfs_create_u64("failed_gets", S_IRUGO, |
| 312 | root, &cleancache_failed_gets); |
| 313 | debugfs_create_u64("puts", S_IRUGO, root, &cleancache_puts); |
| 314 | debugfs_create_u64("invalidates", S_IRUGO, |
| 315 | root, &cleancache_invalidates); |
| 316 | #endif |
Dan Magenheimer | 077b1f8 | 2011-05-26 10:01:36 -0600 | [diff] [blame] | 317 | return 0; |
| 318 | } |
| 319 | module_init(init_cleancache) |