hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cleancache: Make cleancache_init use a pointer for the ops 

Instead of using a backend_registered to determine whether a backend is
enabled.  This allows us to remove the backend_register check and just
do 'if (cleancache_ops)'

[v1: Rebase on top of b97c4b430b0a (ramster->zcache move]
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Signed-off-by: Bob Liu <lliubbo@gmail.com>
Cc: Wanpeng Li <liwanp@linux.vnet.ibm.com>
Cc: Andor Daam <andor.daam@googlemail.com>
Cc: Dan Magenheimer <dan.magenheimer@oracle.com>
Cc: Florian Schmaus <fschmaus@gmail.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Stefan Hengelein <ilendir@googlemail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Konrad Rzeszutek Wilk 2013-04-30 15:26:57 -07:00 committed by Linus Torvalds
parent 49a9ab815a
commit 833f8662af
4 changed files with 40 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
drivers/staging/zcache/zcache-main.c
View File

@ -1576,9 +1576,9 @@ static struct cleancache_ops zcache_cleancache_ops = {
.init_fs = zcache_cleancache_init_fs .init_fs = zcache_cleancache_init_fs
}; };
struct cleancache_ops zcache_cleancache_register_ops(void) struct cleancache_ops *zcache_cleancache_register_ops(void)
{ {
struct cleancache_ops old_ops = struct cleancache_ops *old_ops =
cleancache_register_ops(&zcache_cleancache_ops); cleancache_register_ops(&zcache_cleancache_ops);
return old_ops; return old_ops;
@ -1860,7 +1860,7 @@ static int __init zcache_init(void)
} }
zbud_init(); zbud_init();
if (zcache_enabled && !disable_cleancache) { if (zcache_enabled && !disable_cleancache) {
struct cleancache_ops old_ops; struct cleancache_ops *old_ops;
register_shrinker(&zcache_shrinker); register_shrinker(&zcache_shrinker);
old_ops = zcache_cleancache_register_ops(); old_ops = zcache_cleancache_register_ops();
@ -1870,7 +1870,7 @@ static int __init zcache_init(void)
pr_info("%s: cleancache: ignorenonactive = %d\n", pr_info("%s: cleancache: ignorenonactive = %d\n",
namestr, !disable_cleancache_ignore_nonactive); namestr, !disable_cleancache_ignore_nonactive);
#endif #endif
if (old_ops.init_fs != NULL) if (old_ops != NULL)
pr_warn("%s: cleancache_ops overridden\n", namestr); pr_warn("%s: cleancache_ops overridden\n", namestr);
} }
if (zcache_enabled && !disable_frontswap) { if (zcache_enabled && !disable_frontswap) {

6
drivers/xen/tmem.c
View File

@ -236,7 +236,7 @@ static int __init no_cleancache(char *s)
} }
__setup("nocleancache", no_cleancache); __setup("nocleancache", no_cleancache);
static struct cleancache_ops __initdata tmem_cleancache_ops = { static struct cleancache_ops tmem_cleancache_ops = {
.put_page = tmem_cleancache_put_page, .put_page = tmem_cleancache_put_page,
.get_page = tmem_cleancache_get_page, .get_page = tmem_cleancache_get_page,
.invalidate_page = tmem_cleancache_flush_page, .invalidate_page = tmem_cleancache_flush_page,
@ -392,9 +392,9 @@ static int __init xen_tmem_init(void)
BUG_ON(sizeof(struct cleancache_filekey) != sizeof(struct tmem_oid)); BUG_ON(sizeof(struct cleancache_filekey) != sizeof(struct tmem_oid));
if (tmem_enabled && use_cleancache) { if (tmem_enabled && use_cleancache) {
char *s = ""; char *s = "";
struct cleancache_ops old_ops = struct cleancache_ops *old_ops =
cleancache_register_ops(&tmem_cleancache_ops); cleancache_register_ops(&tmem_cleancache_ops);
if (old_ops.init_fs != NULL) if (old_ops)
s = " (WARNING: cleancache_ops overridden)"; s = " (WARNING: cleancache_ops overridden)";
printk(KERN_INFO "cleancache enabled, RAM provided by " printk(KERN_INFO "cleancache enabled, RAM provided by "
"Xen Transcendent Memory%s\n", s); "Xen Transcendent Memory%s\n", s);

2
include/linux/cleancache.h
View File

@ -33,7 +33,7 @@ struct cleancache_ops {
void (*invalidate_fs)(int); void (*invalidate_fs)(int);
}; };
extern struct cleancache_ops extern struct cleancache_ops *
cleancache_register_ops(struct cleancache_ops *ops); cleancache_register_ops(struct cleancache_ops *ops);
extern void __cleancache_init_fs(struct super_block *); extern void __cleancache_init_fs(struct super_block *);
extern void __cleancache_init_shared_fs(char *, struct super_block *); extern void __cleancache_init_shared_fs(char *, struct super_block *);

62
mm/cleancache.c
View File

@ -32,7 +32,7 @@ EXPORT_SYMBOL(cleancache_enabled);
* cleancache_ops is set by cleancache_ops_register to contain the pointers * cleancache_ops is set by cleancache_ops_register to contain the pointers
* to the cleancache "backend" implementation functions. * to the cleancache "backend" implementation functions.
*/ */
static struct cleancache_ops cleancache_ops __read_mostly; static struct cleancache_ops *cleancache_ops __read_mostly;
/* /*
* Counters available via /sys/kernel/debug/frontswap (if debugfs is * Counters available via /sys/kernel/debug/frontswap (if debugfs is
@ -72,15 +72,14 @@ static DEFINE_MUTEX(poolid_mutex);
/* /*
* When set to false (default) all calls to the cleancache functions, except * When set to false (default) all calls to the cleancache functions, except
* the __cleancache_invalidate_fs and __cleancache_init_[shared|]fs are guarded * the __cleancache_invalidate_fs and __cleancache_init_[shared|]fs are guarded
* by the if (!backend_registered) return. This means multiple threads (from * by the if (!cleancache_ops) return. This means multiple threads (from
* different filesystems) will be checking backend_registered. The usage of a * different filesystems) will be checking cleancache_ops. The usage of a
* bool instead of a atomic_t or a bool guarded by a spinlock is OK - we are * bool instead of a atomic_t or a bool guarded by a spinlock is OK - we are
* OK if the time between the backend's have been initialized (and * OK if the time between the backend's have been initialized (and
* backend_registered has been set to true) and when the filesystems start * cleancache_ops has been set to not NULL) and when the filesystems start
* actually calling the backends. The inverse (when unloading) is obviously * actually calling the backends. The inverse (when unloading) is obviously
* not good - but this shim does not do that (yet). * not good - but this shim does not do that (yet).
*/ */
static bool backend_registered __read_mostly;
/* /*
* The backends and filesystems work all asynchronously. This is b/c the * The backends and filesystems work all asynchronously. This is b/c the
@ -90,13 +89,13 @@ static bool backend_registered __read_mostly;
* [shared_|]fs_poolid_map and uuids for. * [shared_|]fs_poolid_map and uuids for.
* *
* b). user does I/Os -> we call the rest of __cleancache_* functions * b). user does I/Os -> we call the rest of __cleancache_* functions
* which return immediately as backend_registered is false. * which return immediately as cleancache_ops is false.
* *
* c). modprobe zcache -> cleancache_register_ops. We init the backend * c). modprobe zcache -> cleancache_register_ops. We init the backend
* and set backend_registered to true, and for any fs_poolid_map * and set cleancache_ops to true, and for any fs_poolid_map
* (which is set by __cleancache_init_fs) we initialize the poolid. * (which is set by __cleancache_init_fs) we initialize the poolid.
* *
* d). user does I/Os -> now that backend_registered is true all the * d). user does I/Os -> now that cleancache_ops is true all the
* __cleancache_* functions can call the backend. They all check * __cleancache_* functions can call the backend. They all check
* that fs_poolid_map is valid and if so invoke the backend. * that fs_poolid_map is valid and if so invoke the backend.
* *
@ -120,23 +119,26 @@ static bool backend_registered __read_mostly;
* Register operations for cleancache, returning previous thus allowing * Register operations for cleancache, returning previous thus allowing
* detection of multiple backends and possible nesting. * detection of multiple backends and possible nesting.
*/ */
struct cleancache_ops cleancache_register_ops(struct cleancache_ops *ops) struct cleancache_ops *cleancache_register_ops(struct cleancache_ops *ops)
{ {
struct cleancache_ops old = cleancache_ops; struct cleancache_ops *old = cleancache_ops;
int i; int i;
mutex_lock(&poolid_mutex); mutex_lock(&poolid_mutex);
cleancache_ops = *ops;
backend_registered = true;
for (i = 0; i < MAX_INITIALIZABLE_FS; i++) { for (i = 0; i < MAX_INITIALIZABLE_FS; i++) {
if (fs_poolid_map[i] == FS_NO_BACKEND) if (fs_poolid_map[i] == FS_NO_BACKEND)
fs_poolid_map[i] = (*cleancache_ops.init_fs)(PAGE_SIZE); fs_poolid_map[i] = ops->init_fs(PAGE_SIZE);
if (shared_fs_poolid_map[i] == FS_NO_BACKEND) if (shared_fs_poolid_map[i] == FS_NO_BACKEND)
shared_fs_poolid_map[i] = (*cleancache_ops.init_shared_fs) shared_fs_poolid_map[i] = ops->init_shared_fs
(uuids[i], PAGE_SIZE); (uuids[i], PAGE_SIZE);
} }
out: /*
* We MUST set cleancache_ops _after_ we have called the backends
* init_fs or init_shared_fs functions. Otherwise the compiler might
* re-order where cleancache_ops is set in this function.
*/
barrier();
cleancache_ops = ops;
mutex_unlock(&poolid_mutex); mutex_unlock(&poolid_mutex);
return old; return old;
} }
@ -151,8 +153,8 @@ void __cleancache_init_fs(struct super_block *sb)
for (i = 0; i < MAX_INITIALIZABLE_FS; i++) { for (i = 0; i < MAX_INITIALIZABLE_FS; i++) {
if (fs_poolid_map[i] == FS_UNKNOWN) { if (fs_poolid_map[i] == FS_UNKNOWN) {
sb->cleancache_poolid = i + FAKE_FS_POOLID_OFFSET; sb->cleancache_poolid = i + FAKE_FS_POOLID_OFFSET;
if (backend_registered) if (cleancache_ops)
fs_poolid_map[i] = (*cleancache_ops.init_fs)(PAGE_SIZE); fs_poolid_map[i] = cleancache_ops->init_fs(PAGE_SIZE);
else else
fs_poolid_map[i] = FS_NO_BACKEND; fs_poolid_map[i] = FS_NO_BACKEND;
break; break;
@ -172,8 +174,8 @@ void __cleancache_init_shared_fs(char *uuid, struct super_block *sb)
if (shared_fs_poolid_map[i] == FS_UNKNOWN) { if (shared_fs_poolid_map[i] == FS_UNKNOWN) {
sb->cleancache_poolid = i + FAKE_SHARED_FS_POOLID_OFFSET; sb->cleancache_poolid = i + FAKE_SHARED_FS_POOLID_OFFSET;
uuids[i] = uuid; uuids[i] = uuid;
if (backend_registered) if (cleancache_ops)
shared_fs_poolid_map[i] = (*cleancache_ops.init_shared_fs) shared_fs_poolid_map[i] = cleancache_ops->init_shared_fs
(uuid, PAGE_SIZE); (uuid, PAGE_SIZE);
else else
shared_fs_poolid_map[i] = FS_NO_BACKEND; shared_fs_poolid_map[i] = FS_NO_BACKEND;
@ -240,7 +242,7 @@ int __cleancache_get_page(struct page *page)
int fake_pool_id; int fake_pool_id;
struct cleancache_filekey key = { .u.key = { 0 } }; struct cleancache_filekey key = { .u.key = { 0 } };
if (!backend_registered) { if (!cleancache_ops) {
cleancache_failed_gets++; cleancache_failed_gets++;
goto out; goto out;
} }
@ -255,7 +257,7 @@ int __cleancache_get_page(struct page *page)
goto out; goto out;
if (pool_id >= 0) if (pool_id >= 0)
ret = (*cleancache_ops.get_page)(pool_id, ret = cleancache_ops->get_page(pool_id,
key, page->index, page); key, page->index, page);
if (ret == 0) if (ret == 0)
cleancache_succ_gets++; cleancache_succ_gets++;
@ -282,7 +284,7 @@ void __cleancache_put_page(struct page *page)
int fake_pool_id; int fake_pool_id;
struct cleancache_filekey key = { .u.key = { 0 } }; struct cleancache_filekey key = { .u.key = { 0 } };
if (!backend_registered) { if (!cleancache_ops) {
cleancache_puts++; cleancache_puts++;
return; return;
} }
@ -296,7 +298,7 @@ void __cleancache_put_page(struct page *page)
if (pool_id >= 0 && if (pool_id >= 0 &&
cleancache_get_key(page->mapping->host, &key) >= 0) { cleancache_get_key(page->mapping->host, &key) >= 0) {
(*cleancache_ops.put_page)(pool_id, key, page->index, page); cleancache_ops->put_page(pool_id, key, page->index, page);
cleancache_puts++; cleancache_puts++;
} }
} }
@ -318,7 +320,7 @@ void __cleancache_invalidate_page(struct address_space *mapping,
int fake_pool_id = mapping->host->i_sb->cleancache_poolid; int fake_pool_id = mapping->host->i_sb->cleancache_poolid;
struct cleancache_filekey key = { .u.key = { 0 } }; struct cleancache_filekey key = { .u.key = { 0 } };
if (!backend_registered) if (!cleancache_ops)
return; return;
if (fake_pool_id >= 0) { if (fake_pool_id >= 0) {
@ -328,7 +330,7 @@ void __cleancache_invalidate_page(struct address_space *mapping,
VM_BUG_ON(!PageLocked(page)); VM_BUG_ON(!PageLocked(page));
if (cleancache_get_key(mapping->host, &key) >= 0) { if (cleancache_get_key(mapping->host, &key) >= 0) {
(*cleancache_ops.invalidate_page)(pool_id, cleancache_ops->invalidate_page(pool_id,
key, page->index); key, page->index);
cleancache_invalidates++; cleancache_invalidates++;
} }
@ -351,7 +353,7 @@ void __cleancache_invalidate_inode(struct address_space *mapping)
int fake_pool_id = mapping->host->i_sb->cleancache_poolid; int fake_pool_id = mapping->host->i_sb->cleancache_poolid;
struct cleancache_filekey key = { .u.key = { 0 } }; struct cleancache_filekey key = { .u.key = { 0 } };
if (!backend_registered) if (!cleancache_ops)
return; return;
if (fake_pool_id < 0) if (fake_pool_id < 0)
@ -360,7 +362,7 @@ void __cleancache_invalidate_inode(struct address_space *mapping)
pool_id = get_poolid_from_fake(fake_pool_id); pool_id = get_poolid_from_fake(fake_pool_id);
if (pool_id >= 0 && cleancache_get_key(mapping->host, &key) >= 0) if (pool_id >= 0 && cleancache_get_key(mapping->host, &key) >= 0)
(*cleancache_ops.invalidate_inode)(pool_id, key); cleancache_ops->invalidate_inode(pool_id, key);
} }
EXPORT_SYMBOL(__cleancache_invalidate_inode); EXPORT_SYMBOL(__cleancache_invalidate_inode);
@ -387,8 +389,8 @@ void __cleancache_invalidate_fs(struct super_block *sb)
fs_poolid_map[index] = FS_UNKNOWN; fs_poolid_map[index] = FS_UNKNOWN;
} }
sb->cleancache_poolid = -1; sb->cleancache_poolid = -1;
if (backend_registered) if (cleancache_ops)
(*cleancache_ops.invalidate_fs)(old_poolid); cleancache_ops->invalidate_fs(old_poolid);
mutex_unlock(&poolid_mutex); mutex_unlock(&poolid_mutex);
} }
EXPORT_SYMBOL(__cleancache_invalidate_fs); EXPORT_SYMBOL(__cleancache_invalidate_fs);