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 inode *, __u32 *fh, int *, struct inode *);
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            len = (*fhfn)(inode, &key->u.fh[0], &maxlen, NULL);
92            if (len <= 0 || len == 255)
93                return -1;
94            if (maxlen > CLEANCACHE_KEY_MAX)
95                return -1;
96        }
97    }
98    return 0;
99}
100
101/*
102 * "Get" data from cleancache associated with the poolid/inode/index
103 * that were specified when the data was put to cleanache and, if
104 * successful, use it to fill the specified page with data and return 0.
105 * The pageframe is unchanged and returns -1 if the get fails.
106 * Page must be locked by caller.
107 */
108int __cleancache_get_page(struct page *page)
109{
110    int ret = -1;
111    int pool_id;
112    struct cleancache_filekey key = { .u.key = { 0 } };
113
114    VM_BUG_ON(!PageLocked(page));
115    pool_id = page->mapping->host->i_sb->cleancache_poolid;
116    if (pool_id < 0)
117        goto out;
118
119    if (cleancache_get_key(page->mapping->host, &key) < 0)
120        goto out;
121
122    ret = (*cleancache_ops.get_page)(pool_id, key, page->index, page);
123    if (ret == 0)
124        cleancache_succ_gets++;
125    else
126        cleancache_failed_gets++;
127out:
128    return ret;
129}
130EXPORT_SYMBOL(__cleancache_get_page);
131
132/*
133 * "Put" data from a page to cleancache and associate it with the
134 * (previously-obtained per-filesystem) poolid and the page's,
135 * inode and page index. Page must be locked. Note that a put_page
136 * always "succeeds", though a subsequent get_page may succeed or fail.
137 */
138void __cleancache_put_page(struct page *page)
139{
140    int pool_id;
141    struct cleancache_filekey key = { .u.key = { 0 } };
142
143    VM_BUG_ON(!PageLocked(page));
144    pool_id = page->mapping->host->i_sb->cleancache_poolid;
145    if (pool_id >= 0 &&
146          cleancache_get_key(page->mapping->host, &key) >= 0) {
147        (*cleancache_ops.put_page)(pool_id, key, page->index, page);
148        cleancache_puts++;
149    }
150}
151EXPORT_SYMBOL(__cleancache_put_page);
152
153/*
154 * Invalidate any data from cleancache associated with the poolid and the
155 * page's inode and page index so that a subsequent "get" will fail.
156 */
157void __cleancache_invalidate_page(struct address_space *mapping,
158                    struct page *page)
159{
160    /* careful... page->mapping is NULL sometimes when this is called */
161    int pool_id = mapping->host->i_sb->cleancache_poolid;
162    struct cleancache_filekey key = { .u.key = { 0 } };
163
164    if (pool_id >= 0) {
165        VM_BUG_ON(!PageLocked(page));
166        if (cleancache_get_key(mapping->host, &key) >= 0) {
167            (*cleancache_ops.invalidate_page)(pool_id,
168                              key, page->index);
169            cleancache_invalidates++;
170        }
171    }
172}
173EXPORT_SYMBOL(__cleancache_invalidate_page);
174
175/*
176 * Invalidate all data from cleancache associated with the poolid and the
177 * mappings's inode so that all subsequent gets to this poolid/inode
178 * will fail.
179 */
180void __cleancache_invalidate_inode(struct address_space *mapping)
181{
182    int pool_id = mapping->host->i_sb->cleancache_poolid;
183    struct cleancache_filekey key = { .u.key = { 0 } };
184
185    if (pool_id >= 0 && cleancache_get_key(mapping->host, &key) >= 0)
186        (*cleancache_ops.invalidate_inode)(pool_id, key);
187}
188EXPORT_SYMBOL(__cleancache_invalidate_inode);
189
190/*
191 * Called by any cleancache-enabled filesystem at time of unmount;
192 * note that pool_id is surrendered and may be reutrned by a subsequent
193 * cleancache_init_fs or cleancache_init_shared_fs
194 */
195void __cleancache_invalidate_fs(struct super_block *sb)
196{
197    if (sb->cleancache_poolid >= 0) {
198        int old_poolid = sb->cleancache_poolid;
199        sb->cleancache_poolid = -1;
200        (*cleancache_ops.invalidate_fs)(old_poolid);
201    }
202}
203EXPORT_SYMBOL(__cleancache_invalidate_fs);
204
205static int __init init_cleancache(void)
206{
207#ifdef CONFIG_DEBUG_FS
208    struct dentry *root = debugfs_create_dir("cleancache", NULL);
209    if (root == NULL)
210        return -ENXIO;
211    debugfs_create_u64("succ_gets", S_IRUGO, root, &cleancache_succ_gets);
212    debugfs_create_u64("failed_gets", S_IRUGO,
213                root, &cleancache_failed_gets);
214    debugfs_create_u64("puts", S_IRUGO, root, &cleancache_puts);
215    debugfs_create_u64("invalidates", S_IRUGO,
216                root, &cleancache_invalidates);
217#endif
218    return 0;
219}
220module_init(init_cleancache)
221

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive