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 */
cleancache_register_ops(struct cleancache_ops * ops)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 */
__cleancache_init_fs(struct super_block * sb)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 */
__cleancache_init_shared_fs(char * uuid,struct super_block * sb)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 */
cleancache_get_key(struct inode * inode,struct cleancache_filekey * key)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 */
__cleancache_get_page(struct page * page)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 */
__cleancache_put_page(struct page * page)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 */
__cleancache_invalidate_page(struct address_space * mapping,struct page * page)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 */
__cleancache_invalidate_inode(struct address_space * mapping)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 */
__cleancache_invalidate_fs(struct super_block * sb)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
init_cleancache(void)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)
223