blob: 5646c740f613ed1ec8b34a094f76d7934eed1aac [file] [log] [blame]
Dan Magenheimer077b1f82011-05-26 10:01:36 -06001/*
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 Magenheimer417fc2c2011-09-21 12:28:04 -040018#include <linux/debugfs.h>
Dan Magenheimer077b1f82011-05-26 10:01:36 -060019#include <linux/cleancache.h>
20
21/*
22 * This global enablement flag may be read thousands of times per second
Dan Magenheimer31677602011-09-21 11:56:28 -040023 * by cleancache_get/put/invalidate even on systems where cleancache_ops
Dan Magenheimer077b1f82011-05-26 10:01:36 -060024 * 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 */
Dan Magenheimer072611e2011-09-21 12:21:20 -040028int cleancache_enabled __read_mostly;
Dan Magenheimer077b1f82011-05-26 10:01:36 -060029EXPORT_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 */
Dan Magenheimer072611e2011-09-21 12:21:20 -040035static struct cleancache_ops cleancache_ops __read_mostly;
Dan Magenheimer077b1f82011-05-26 10:01:36 -060036
Dan Magenheimer417fc2c2011-09-21 12:28:04 -040037/*
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 */
42static u64 cleancache_succ_gets;
43static u64 cleancache_failed_gets;
44static u64 cleancache_puts;
45static u64 cleancache_invalidates;
Dan Magenheimer077b1f82011-05-26 10:01:36 -060046
47/*
48 * register operations for cleancache, returning previous thus allowing
49 * detection of multiple backends and possible nesting
50 */
51struct 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}
59EXPORT_SYMBOL(cleancache_register_ops);
60
61/* Called by a cleancache-enabled filesystem at time of mount */
62void __cleancache_init_fs(struct super_block *sb)
63{
64 sb->cleancache_poolid = (*cleancache_ops.init_fs)(PAGE_SIZE);
65}
66EXPORT_SYMBOL(__cleancache_init_fs);
67
68/* Called by a cleancache-enabled clustered filesystem at time of mount */
69void __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}
74EXPORT_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 */
80static 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 */
110int __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++;
129out:
130 return ret;
131}
132EXPORT_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 */
140void __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}
153EXPORT_SYMBOL(__cleancache_put_page);
154
155/*
Dan Magenheimer31677602011-09-21 11:56:28 -0400156 * Invalidate any data from cleancache associated with the poolid and the
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600157 * page's inode and page index so that a subsequent "get" will fail.
158 */
Dan Magenheimer31677602011-09-21 11:56:28 -0400159void __cleancache_invalidate_page(struct address_space *mapping,
160 struct page *page)
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600161{
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) {
Dan Magenheimer91c6cc92012-01-12 14:03:25 -0500169 (*cleancache_ops.invalidate_page)(pool_id,
170 key, page->index);
Dan Magenheimer417fc2c2011-09-21 12:28:04 -0400171 cleancache_invalidates++;
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600172 }
173 }
174}
Dan Magenheimer31677602011-09-21 11:56:28 -0400175EXPORT_SYMBOL(__cleancache_invalidate_page);
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600176
177/*
Dan Magenheimer31677602011-09-21 11:56:28 -0400178 * Invalidate all data from cleancache associated with the poolid and the
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600179 * mappings's inode so that all subsequent gets to this poolid/inode
180 * will fail.
181 */
Dan Magenheimer31677602011-09-21 11:56:28 -0400182void __cleancache_invalidate_inode(struct address_space *mapping)
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600183{
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)
Dan Magenheimer91c6cc92012-01-12 14:03:25 -0500188 (*cleancache_ops.invalidate_inode)(pool_id, key);
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600189}
Dan Magenheimer31677602011-09-21 11:56:28 -0400190EXPORT_SYMBOL(__cleancache_invalidate_inode);
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600191
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 */
Dan Magenheimer31677602011-09-21 11:56:28 -0400197void __cleancache_invalidate_fs(struct super_block *sb)
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600198{
199 if (sb->cleancache_poolid >= 0) {
200 int old_poolid = sb->cleancache_poolid;
201 sb->cleancache_poolid = -1;
Dan Magenheimer91c6cc92012-01-12 14:03:25 -0500202 (*cleancache_ops.invalidate_fs)(old_poolid);
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600203 }
204}
Dan Magenheimer31677602011-09-21 11:56:28 -0400205EXPORT_SYMBOL(__cleancache_invalidate_fs);
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600206
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600207static int __init init_cleancache(void)
208{
Dan Magenheimer417fc2c2011-09-21 12:28:04 -0400209#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
Dan Magenheimer077b1f82011-05-26 10:01:36 -0600220 return 0;
221}
222module_init(init_cleancache)