Root/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 */
28int cleancache_enabled __read_mostly;
29EXPORT_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 */
35static 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 */
42static u64 cleancache_succ_gets;
43static u64 cleancache_failed_gets;
44static u64 cleancache_puts;
45static u64 cleancache_invalidates;
46
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/*
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 */
159void __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}
175EXPORT_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 */
182void __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}
190EXPORT_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 */
197void __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}
205EXPORT_SYMBOL(__cleancache_invalidate_fs);
206
207static 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}
222module_init(init_cleancache)
223

Archive Download this file



interactive