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.
8 * Copyright (C) 2009-2010 Oracle Corp. All rights reserved.
9 * Author: Dan Magenheimer
11 * This work is licensed under the terms of the GNU GPL, version 2.
14 #include <linux/module.h>
16 #include <linux/exportfs.h>
18 #include <linux/debugfs.h>
19 #include <linux/cleancache.h>
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.
28 int cleancache_enabled __read_mostly
;
29 EXPORT_SYMBOL(cleancache_enabled
);
32 * cleancache_ops is set by cleancache_ops_register to contain the pointers
33 * to the cleancache "backend" implementation functions.
35 static struct cleancache_ops cleancache_ops __read_mostly
;
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.
42 static u64 cleancache_succ_gets
;
43 static u64 cleancache_failed_gets
;
44 static u64 cleancache_puts
;
45 static u64 cleancache_invalidates
;
48 * When no backend is registered all calls to init_fs and init_shared_fs
49 * are registered and fake poolids (FAKE_FS_POOLID_OFFSET or
50 * FAKE_SHARED_FS_POOLID_OFFSET, plus offset in the respective array
51 * [shared_|]fs_poolid_map) are given to the respective super block
52 * (sb->cleancache_poolid) and no tmem_pools are created. When a backend
53 * registers with cleancache the previous calls to init_fs and init_shared_fs
54 * are executed to create tmem_pools and set the respective poolids. While no
55 * backend is registered all "puts", "gets" and "flushes" are ignored or failed.
57 #define MAX_INITIALIZABLE_FS 32
58 #define FAKE_FS_POOLID_OFFSET 1000
59 #define FAKE_SHARED_FS_POOLID_OFFSET 2000
61 #define FS_NO_BACKEND (-1)
62 #define FS_UNKNOWN (-2)
63 static int fs_poolid_map
[MAX_INITIALIZABLE_FS
];
64 static int shared_fs_poolid_map
[MAX_INITIALIZABLE_FS
];
65 static char *uuids
[MAX_INITIALIZABLE_FS
];
67 * Mutex for the [shared_|]fs_poolid_map to guard against multiple threads
68 * invoking umount (and ending in __cleancache_invalidate_fs) and also multiple
69 * threads calling mount (and ending up in __cleancache_init_[shared|]fs).
71 static DEFINE_MUTEX(poolid_mutex
);
73 * When set to false (default) all calls to the cleancache functions, except
74 * the __cleancache_invalidate_fs and __cleancache_init_[shared|]fs are guarded
75 * by the if (!backend_registered) return. This means multiple threads (from
76 * different filesystems) will be checking backend_registered. The usage of a
77 * bool instead of a atomic_t or a bool guarded by a spinlock is OK - we are
78 * OK if the time between the backend's have been initialized (and
79 * backend_registered has been set to true) and when the filesystems start
80 * actually calling the backends. The inverse (when unloading) is obviously
81 * not good - but this shim does not do that (yet).
83 static bool backend_registered __read_mostly
;
86 * The backends and filesystems work all asynchronously. This is b/c the
87 * backends can be built as modules.
88 * The usual sequence of events is:
89 * a) mount / -> __cleancache_init_fs is called. We set the
90 * [shared_|]fs_poolid_map and uuids for.
92 * b). user does I/Os -> we call the rest of __cleancache_* functions
93 * which return immediately as backend_registered is false.
95 * c). modprobe zcache -> cleancache_register_ops. We init the backend
96 * and set backend_registered to true, and for any fs_poolid_map
97 * (which is set by __cleancache_init_fs) we initialize the poolid.
99 * d). user does I/Os -> now that backend_registered is true all the
100 * __cleancache_* functions can call the backend. They all check
101 * that fs_poolid_map is valid and if so invoke the backend.
103 * e). umount / -> __cleancache_invalidate_fs, the fs_poolid_map is
104 * reset (which is the second check in the __cleancache_* ops
105 * to call the backend).
107 * The sequence of event could also be c), followed by a), and d). and e). The
108 * c) would not happen anymore. There is also the chance of c), and one thread
109 * doing a) + d), and another doing e). For that case we depend on the
110 * filesystem calling __cleancache_invalidate_fs in the proper sequence (so
111 * that it handles all I/Os before it invalidates the fs (which is last part
112 * of unmounting process).
114 * Note: The acute reader will notice that there is no "rmmod zcache" case.
115 * This is b/c the functionality for that is not yet implemented and when
116 * done, will require some extra locking not yet devised.
120 * Register operations for cleancache, returning previous thus allowing
121 * detection of multiple backends and possible nesting.
123 struct cleancache_ops
cleancache_register_ops(struct cleancache_ops
*ops
)
125 struct cleancache_ops old
= cleancache_ops
;
128 mutex_lock(&poolid_mutex
);
129 cleancache_ops
= *ops
;
131 backend_registered
= true;
132 for (i
= 0; i
< MAX_INITIALIZABLE_FS
; i
++) {
133 if (fs_poolid_map
[i
] == FS_NO_BACKEND
)
134 fs_poolid_map
[i
] = (*cleancache_ops
.init_fs
)(PAGE_SIZE
);
135 if (shared_fs_poolid_map
[i
] == FS_NO_BACKEND
)
136 shared_fs_poolid_map
[i
] = (*cleancache_ops
.init_shared_fs
)
137 (uuids
[i
], PAGE_SIZE
);
140 mutex_unlock(&poolid_mutex
);
143 EXPORT_SYMBOL(cleancache_register_ops
);
145 /* Called by a cleancache-enabled filesystem at time of mount */
146 void __cleancache_init_fs(struct super_block
*sb
)
150 mutex_lock(&poolid_mutex
);
151 for (i
= 0; i
< MAX_INITIALIZABLE_FS
; i
++) {
152 if (fs_poolid_map
[i
] == FS_UNKNOWN
) {
153 sb
->cleancache_poolid
= i
+ FAKE_FS_POOLID_OFFSET
;
154 if (backend_registered
)
155 fs_poolid_map
[i
] = (*cleancache_ops
.init_fs
)(PAGE_SIZE
);
157 fs_poolid_map
[i
] = FS_NO_BACKEND
;
161 mutex_unlock(&poolid_mutex
);
163 EXPORT_SYMBOL(__cleancache_init_fs
);
165 /* Called by a cleancache-enabled clustered filesystem at time of mount */
166 void __cleancache_init_shared_fs(char *uuid
, struct super_block
*sb
)
170 mutex_lock(&poolid_mutex
);
171 for (i
= 0; i
< MAX_INITIALIZABLE_FS
; i
++) {
172 if (shared_fs_poolid_map
[i
] == FS_UNKNOWN
) {
173 sb
->cleancache_poolid
= i
+ FAKE_SHARED_FS_POOLID_OFFSET
;
175 if (backend_registered
)
176 shared_fs_poolid_map
[i
] = (*cleancache_ops
.init_shared_fs
)
179 shared_fs_poolid_map
[i
] = FS_NO_BACKEND
;
183 mutex_unlock(&poolid_mutex
);
185 EXPORT_SYMBOL(__cleancache_init_shared_fs
);
188 * If the filesystem uses exportable filehandles, use the filehandle as
189 * the key, else use the inode number.
191 static int cleancache_get_key(struct inode
*inode
,
192 struct cleancache_filekey
*key
)
194 int (*fhfn
)(struct inode
*, __u32
*fh
, int *, struct inode
*);
195 int len
= 0, maxlen
= CLEANCACHE_KEY_MAX
;
196 struct super_block
*sb
= inode
->i_sb
;
198 key
->u
.ino
= inode
->i_ino
;
199 if (sb
->s_export_op
!= NULL
) {
200 fhfn
= sb
->s_export_op
->encode_fh
;
202 len
= (*fhfn
)(inode
, &key
->u
.fh
[0], &maxlen
, NULL
);
203 if (len
<= FILEID_ROOT
|| len
== FILEID_INVALID
)
205 if (maxlen
> CLEANCACHE_KEY_MAX
)
213 * Returns a pool_id that is associated with a given fake poolid.
215 static int get_poolid_from_fake(int fake_pool_id
)
217 if (fake_pool_id
>= FAKE_SHARED_FS_POOLID_OFFSET
)
218 return shared_fs_poolid_map
[fake_pool_id
-
219 FAKE_SHARED_FS_POOLID_OFFSET
];
220 else if (fake_pool_id
>= FAKE_FS_POOLID_OFFSET
)
221 return fs_poolid_map
[fake_pool_id
- FAKE_FS_POOLID_OFFSET
];
222 return FS_NO_BACKEND
;
226 * "Get" data from cleancache associated with the poolid/inode/index
227 * that were specified when the data was put to cleanache and, if
228 * successful, use it to fill the specified page with data and return 0.
229 * The pageframe is unchanged and returns -1 if the get fails.
230 * Page must be locked by caller.
232 * The function has two checks before any action is taken - whether
233 * a backend is registered and whether the sb->cleancache_poolid
236 int __cleancache_get_page(struct page
*page
)
241 struct cleancache_filekey key
= { .u
.key
= { 0 } };
243 if (!backend_registered
) {
244 cleancache_failed_gets
++;
248 VM_BUG_ON(!PageLocked(page
));
249 fake_pool_id
= page
->mapping
->host
->i_sb
->cleancache_poolid
;
250 if (fake_pool_id
< 0)
252 pool_id
= get_poolid_from_fake(fake_pool_id
);
254 if (cleancache_get_key(page
->mapping
->host
, &key
) < 0)
258 ret
= (*cleancache_ops
.get_page
)(pool_id
,
259 key
, page
->index
, page
);
261 cleancache_succ_gets
++;
263 cleancache_failed_gets
++;
267 EXPORT_SYMBOL(__cleancache_get_page
);
270 * "Put" data from a page to cleancache and associate it with the
271 * (previously-obtained per-filesystem) poolid and the page's,
272 * inode and page index. Page must be locked. Note that a put_page
273 * always "succeeds", though a subsequent get_page may succeed or fail.
275 * The function has two checks before any action is taken - whether
276 * a backend is registered and whether the sb->cleancache_poolid
279 void __cleancache_put_page(struct page
*page
)
283 struct cleancache_filekey key
= { .u
.key
= { 0 } };
285 if (!backend_registered
) {
290 VM_BUG_ON(!PageLocked(page
));
291 fake_pool_id
= page
->mapping
->host
->i_sb
->cleancache_poolid
;
292 if (fake_pool_id
< 0)
295 pool_id
= get_poolid_from_fake(fake_pool_id
);
298 cleancache_get_key(page
->mapping
->host
, &key
) >= 0) {
299 (*cleancache_ops
.put_page
)(pool_id
, key
, page
->index
, page
);
303 EXPORT_SYMBOL(__cleancache_put_page
);
306 * Invalidate any data from cleancache associated with the poolid and the
307 * page's inode and page index so that a subsequent "get" will fail.
309 * The function has two checks before any action is taken - whether
310 * a backend is registered and whether the sb->cleancache_poolid
313 void __cleancache_invalidate_page(struct address_space
*mapping
,
316 /* careful... page->mapping is NULL sometimes when this is called */
318 int fake_pool_id
= mapping
->host
->i_sb
->cleancache_poolid
;
319 struct cleancache_filekey key
= { .u
.key
= { 0 } };
321 if (!backend_registered
)
324 if (fake_pool_id
>= 0) {
325 pool_id
= get_poolid_from_fake(fake_pool_id
);
329 VM_BUG_ON(!PageLocked(page
));
330 if (cleancache_get_key(mapping
->host
, &key
) >= 0) {
331 (*cleancache_ops
.invalidate_page
)(pool_id
,
333 cleancache_invalidates
++;
337 EXPORT_SYMBOL(__cleancache_invalidate_page
);
340 * Invalidate all data from cleancache associated with the poolid and the
341 * mappings's inode so that all subsequent gets to this poolid/inode
344 * The function has two checks before any action is taken - whether
345 * a backend is registered and whether the sb->cleancache_poolid
348 void __cleancache_invalidate_inode(struct address_space
*mapping
)
351 int fake_pool_id
= mapping
->host
->i_sb
->cleancache_poolid
;
352 struct cleancache_filekey key
= { .u
.key
= { 0 } };
354 if (!backend_registered
)
357 if (fake_pool_id
< 0)
360 pool_id
= get_poolid_from_fake(fake_pool_id
);
362 if (pool_id
>= 0 && cleancache_get_key(mapping
->host
, &key
) >= 0)
363 (*cleancache_ops
.invalidate_inode
)(pool_id
, key
);
365 EXPORT_SYMBOL(__cleancache_invalidate_inode
);
368 * Called by any cleancache-enabled filesystem at time of unmount;
369 * note that pool_id is surrendered and may be returned by a subsequent
370 * cleancache_init_fs or cleancache_init_shared_fs.
372 void __cleancache_invalidate_fs(struct super_block
*sb
)
375 int fake_pool_id
= sb
->cleancache_poolid
;
376 int old_poolid
= fake_pool_id
;
378 mutex_lock(&poolid_mutex
);
379 if (fake_pool_id
>= FAKE_SHARED_FS_POOLID_OFFSET
) {
380 index
= fake_pool_id
- FAKE_SHARED_FS_POOLID_OFFSET
;
381 old_poolid
= shared_fs_poolid_map
[index
];
382 shared_fs_poolid_map
[index
] = FS_UNKNOWN
;
384 } else if (fake_pool_id
>= FAKE_FS_POOLID_OFFSET
) {
385 index
= fake_pool_id
- FAKE_FS_POOLID_OFFSET
;
386 old_poolid
= fs_poolid_map
[index
];
387 fs_poolid_map
[index
] = FS_UNKNOWN
;
389 sb
->cleancache_poolid
= -1;
390 if (backend_registered
)
391 (*cleancache_ops
.invalidate_fs
)(old_poolid
);
392 mutex_unlock(&poolid_mutex
);
394 EXPORT_SYMBOL(__cleancache_invalidate_fs
);
396 static int __init
init_cleancache(void)
400 #ifdef CONFIG_DEBUG_FS
401 struct dentry
*root
= debugfs_create_dir("cleancache", NULL
);
404 debugfs_create_u64("succ_gets", S_IRUGO
, root
, &cleancache_succ_gets
);
405 debugfs_create_u64("failed_gets", S_IRUGO
,
406 root
, &cleancache_failed_gets
);
407 debugfs_create_u64("puts", S_IRUGO
, root
, &cleancache_puts
);
408 debugfs_create_u64("invalidates", S_IRUGO
,
409 root
, &cleancache_invalidates
);
411 for (i
= 0; i
< MAX_INITIALIZABLE_FS
; i
++) {
412 fs_poolid_map
[i
] = FS_UNKNOWN
;
413 shared_fs_poolid_map
[i
] = FS_UNKNOWN
;
415 cleancache_enabled
= 1;
418 module_init(init_cleancache
)