* [PATCH 01/11] zcache2: s/int/bool/ on the various options.
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 02/11] zcache: Module license is defined twice Konrad Rzeszutek Wilk
` (9 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
There are so many, but this allows us to at least have them
right in as bool.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 46 ++++++++++++++++----------------
1 files changed, 23 insertions(+), 23 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 42a9d81..5c0c7db 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -30,11 +30,11 @@
#include "zbud.h"
#include "ramster.h"
#ifdef CONFIG_RAMSTER
-static int ramster_enabled;
-static int disable_frontswap_selfshrink;
+static bool ramster_enabled __read_mostly;
+static bool disable_frontswap_selfshrink __read_mostly;
#else
-#define ramster_enabled 0
-#define disable_frontswap_selfshrink 0
+#define ramster_enabled false
+#define disable_frontswap_selfshrink false
#endif
#ifndef __PG_WAS_ACTIVE
@@ -57,11 +57,11 @@ static inline void frontswap_tmem_exclusive_gets(bool b)
}
#endif
-static int zcache_enabled __read_mostly;
-static int disable_cleancache __read_mostly;
-static int disable_frontswap __read_mostly;
-static int disable_frontswap_ignore_nonactive __read_mostly;
-static int disable_cleancache_ignore_nonactive __read_mostly;
+static bool zcache_enabled __read_mostly;
+static bool disable_cleancache __read_mostly;
+static bool disable_frontswap __read_mostly;
+static bool disable_frontswap_ignore_nonactive __read_mostly;
+static bool disable_cleancache_ignore_nonactive __read_mostly;
static char *namestr __read_mostly = "zcache";
#define ZCACHE_GFP_MASK \
@@ -1649,16 +1649,16 @@ struct frontswap_ops zcache_frontswap_register_ops(void)
#ifndef CONFIG_ZCACHE2_MODULE
static int __init enable_zcache(char *s)
{
- zcache_enabled = 1;
+ zcache_enabled = true;
return 1;
}
__setup("zcache", enable_zcache);
static int __init enable_ramster(char *s)
{
- zcache_enabled = 1;
+ zcache_enabled = true;
#ifdef CONFIG_RAMSTER
- ramster_enabled = 1;
+ ramster_enabled = true;
#endif
return 1;
}
@@ -1668,7 +1668,7 @@ __setup("ramster", enable_ramster);
static int __init no_cleancache(char *s)
{
- disable_cleancache = 1;
+ disable_cleancache = true;
return 1;
}
@@ -1676,7 +1676,7 @@ __setup("nocleancache", no_cleancache);
static int __init no_frontswap(char *s)
{
- disable_frontswap = 1;
+ disable_frontswap = true;
return 1;
}
@@ -1692,7 +1692,7 @@ __setup("nofrontswapexclusivegets", no_frontswap_exclusive_gets);
static int __init no_frontswap_ignore_nonactive(char *s)
{
- disable_frontswap_ignore_nonactive = 1;
+ disable_frontswap_ignore_nonactive = true;
return 1;
}
@@ -1700,7 +1700,7 @@ __setup("nofrontswapignorenonactive", no_frontswap_ignore_nonactive);
static int __init no_cleancache_ignore_nonactive(char *s)
{
- disable_cleancache_ignore_nonactive = 1;
+ disable_cleancache_ignore_nonactive = true;
return 1;
}
@@ -1709,7 +1709,7 @@ __setup("nocleancacheignorenonactive", no_cleancache_ignore_nonactive);
static int __init enable_zcache_compressor(char *s)
{
strncpy(zcache_comp_name, s, ZCACHE_COMP_NAME_SZ);
- zcache_enabled = 1;
+ zcache_enabled = true;
return 1;
}
__setup("zcache=", enable_zcache_compressor);
@@ -1759,7 +1759,7 @@ static int zcache_init(void)
int ret = 0;
#ifdef CONFIG_ZCACHE2_MODULE
- zcache_enabled = 1;
+ zcache_enabled = true;
#endif
if (ramster_enabled) {
namestr = "ramster";
@@ -1840,15 +1840,15 @@ out:
#ifdef CONFIG_ZCACHE2_MODULE
#ifdef CONFIG_RAMSTER
-module_param(ramster_enabled, int, S_IRUGO);
-module_param(disable_frontswap_selfshrink, int, S_IRUGO);
+module_param(ramster_enabled, bool, S_IRUGO);
+module_param(disable_frontswap_selfshrink, bool, S_IRUGO);
#endif
-module_param(disable_cleancache, int, S_IRUGO);
-module_param(disable_frontswap, int, S_IRUGO);
+module_param(disable_cleancache, bool, S_IRUGO);
+module_param(disable_frontswap, bool, S_IRUGO);
#ifdef FRONTSWAP_HAS_EXCLUSIVE_GETS
module_param(frontswap_has_exclusive_gets, bool, S_IRUGO);
#endif
-module_param(disable_frontswap_ignore_nonactive, int, S_IRUGO);
+module_param(disable_frontswap_ignore_nonactive, bool, S_IRUGO);
module_param(zcache_comp_name, charp, S_IRUGO);
module_init(zcache_init);
MODULE_LICENSE("GPL");
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 02/11] zcache: Module license is defined twice.
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 01/11] zcache2: s/int/bool/ on the various options Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 03/11] zcache: Provide accessory functions for counter increase Konrad Rzeszutek Wilk
` (8 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
The other (same license) is at the end of the file.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 2 --
1 files changed, 0 insertions(+), 2 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 5c0c7db..2b9ad55 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -67,8 +67,6 @@ static char *namestr __read_mostly = "zcache";
#define ZCACHE_GFP_MASK \
(__GFP_FS | __GFP_NORETRY | __GFP_NOWARN | __GFP_NOMEMALLOC)
-MODULE_LICENSE("GPL");
-
/* crypto API for zcache */
#ifdef CONFIG_ZCACHE2_MODULE
static char *zcache_comp_name = "lzo";
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 03/11] zcache: Provide accessory functions for counter increase
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 01/11] zcache2: s/int/bool/ on the various options Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 02/11] zcache: Module license is defined twice Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 04/11] zcache: Provide accessory functions for counter decrease Konrad Rzeszutek Wilk
` (7 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
This is the first step in moving the debugfs code out of the
main file in-to another file. And also allow the code to run
without CONFIG_DEBUG_FS defined.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 103 ++++++++++++++++++++++-----------
1 files changed, 68 insertions(+), 35 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 2b9ad55..6fd7f0e 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -135,32 +135,88 @@ static DEFINE_PER_CPU(struct zcache_preload, zcache_preloads) = { 0, };
static long zcache_obj_count;
static atomic_t zcache_obj_atomic = ATOMIC_INIT(0);
static long zcache_obj_count_max;
+static inline void inc_zcache_obj_count(void)
+{
+ zcache_obj_count = atomic_inc_return(&zcache_obj_atomic);
+ if (zcache_obj_count > zcache_obj_count_max)
+ zcache_obj_count_max = zcache_obj_count;
+}
+
static long zcache_objnode_count;
static atomic_t zcache_objnode_atomic = ATOMIC_INIT(0);
static long zcache_objnode_count_max;
+static inline void inc_zcache_objnode_count(void)
+{
+ zcache_objnode_count = atomic_inc_return(&zcache_objnode_atomic);
+ if (zcache_objnode_count > zcache_objnode_count_max)
+ zcache_objnode_count_max = zcache_objnode_count;
+};
static u64 zcache_eph_zbytes;
static atomic_long_t zcache_eph_zbytes_atomic = ATOMIC_INIT(0);
static u64 zcache_eph_zbytes_max;
+static inline void inc_zcache_eph_zbytes(unsigned clen)
+{
+ zcache_eph_zbytes = atomic_long_add_return(clen, &zcache_eph_zbytes_atomic);
+ if (zcache_eph_zbytes > zcache_eph_zbytes_max)
+ zcache_eph_zbytes_max = zcache_eph_zbytes;
+};
static u64 zcache_pers_zbytes;
static atomic_long_t zcache_pers_zbytes_atomic = ATOMIC_INIT(0);
static u64 zcache_pers_zbytes_max;
+static inline void inc_zcache_pers_zbytes(unsigned clen)
+{
+ zcache_pers_zbytes = atomic_long_add_return(clen, &zcache_pers_zbytes_atomic);
+ if (zcache_pers_zbytes > zcache_pers_zbytes_max)
+ zcache_pers_zbytes_max = zcache_pers_zbytes;
+}
static long zcache_eph_pageframes;
static atomic_t zcache_eph_pageframes_atomic = ATOMIC_INIT(0);
static long zcache_eph_pageframes_max;
+static inline void inc_zcache_eph_pageframes(void)
+{
+ zcache_eph_pageframes = atomic_inc_return(&zcache_eph_pageframes_atomic);
+ if (zcache_eph_pageframes > zcache_eph_pageframes_max)
+ zcache_eph_pageframes_max = zcache_eph_pageframes;
+};
static long zcache_pers_pageframes;
static atomic_t zcache_pers_pageframes_atomic = ATOMIC_INIT(0);
static long zcache_pers_pageframes_max;
+static inline void inc_zcache_pers_pageframes(void)
+{
+ zcache_pers_pageframes = atomic_inc_return(&zcache_pers_pageframes_atomic);
+ if (zcache_pers_pageframes > zcache_pers_pageframes_max)
+ zcache_pers_pageframes_max = zcache_pers_pageframes;
+}
static long zcache_pageframes_alloced;
static atomic_t zcache_pageframes_alloced_atomic = ATOMIC_INIT(0);
+static inline void inc_zcache_pageframes_alloced(void)
+{
+ zcache_pageframes_alloced = atomic_inc_return(&zcache_pageframes_alloced_atomic);
+};
static long zcache_pageframes_freed;
static atomic_t zcache_pageframes_freed_atomic = ATOMIC_INIT(0);
+static inline void inc_zcache_pageframes_freed(void)
+{
+ zcache_pageframes_freed = atomic_inc_return(&zcache_pageframes_freed_atomic);
+}
static long zcache_eph_zpages;
static atomic_t zcache_eph_zpages_atomic = ATOMIC_INIT(0);
static long zcache_eph_zpages_max;
+static inline void inc_zcache_eph_zpages(void)
+{
+ zcache_eph_zpages = atomic_inc_return(&zcache_eph_zpages_atomic);
+ if (zcache_eph_zpages > zcache_eph_zpages_max)
+ zcache_eph_zpages_max = zcache_eph_zpages;
+}
static long zcache_pers_zpages;
static atomic_t zcache_pers_zpages_atomic = ATOMIC_INIT(0);
static long zcache_pers_zpages_max;
-
+static inline void inc_zcache_pers_zpages(void)
+{
+ zcache_pers_zpages = atomic_inc_return(&zcache_pers_zpages_atomic);
+ if (zcache_pers_zpages > zcache_pers_zpages_max)
+ zcache_pers_zpages_max = zcache_pers_zpages;
+}
/* but for the rest of these, counting races are ok */
static unsigned long zcache_flush_total;
static unsigned long zcache_flush_found;
@@ -398,9 +454,7 @@ static struct tmem_objnode *zcache_objnode_alloc(struct tmem_pool *pool)
}
}
BUG_ON(objnode == NULL);
- zcache_objnode_count = atomic_inc_return(&zcache_objnode_atomic);
- if (zcache_objnode_count > zcache_objnode_count_max)
- zcache_objnode_count_max = zcache_objnode_count;
+ inc_zcache_objnode_count();
return objnode;
}
@@ -422,9 +476,7 @@ static struct tmem_obj *zcache_obj_alloc(struct tmem_pool *pool)
obj = kp->obj;
BUG_ON(obj == NULL);
kp->obj = NULL;
- zcache_obj_count = atomic_inc_return(&zcache_obj_atomic);
- if (zcache_obj_count > zcache_obj_count_max)
- zcache_obj_count_max = zcache_obj_count;
+ inc_zcache_obj_count();
return obj;
}
@@ -448,16 +500,14 @@ static struct page *zcache_alloc_page(void)
struct page *page = alloc_page(ZCACHE_GFP_MASK);
if (page != NULL)
- zcache_pageframes_alloced =
- atomic_inc_return(&zcache_pageframes_alloced_atomic);
+ inc_zcache_pageframes_alloced();
return page;
}
#ifdef FRONTSWAP_HAS_UNUSE
static void zcache_unacct_page(void)
{
- zcache_pageframes_freed =
- atomic_inc_return(&zcache_pageframes_freed_atomic);
+ inc_zcache_pageframes_freed();
}
#endif
@@ -469,8 +519,7 @@ static void zcache_free_page(struct page *page)
if (page == NULL)
BUG();
__free_page(page);
- zcache_pageframes_freed =
- atomic_inc_return(&zcache_pageframes_freed_atomic);
+ inc_zcache_pageframes_freed();
curr_pageframes = zcache_pageframes_alloced -
atomic_read(&zcache_pageframes_freed_atomic) -
atomic_read(&zcache_eph_pageframes_atomic) -
@@ -535,19 +584,11 @@ static void *zcache_pampd_eph_create(char *data, size_t size, bool raw,
create_in_new_page:
pampd = (void *)zbud_create_prep(th, true, cdata, clen, newpage);
BUG_ON(pampd == NULL);
- zcache_eph_pageframes =
- atomic_inc_return(&zcache_eph_pageframes_atomic);
- if (zcache_eph_pageframes > zcache_eph_pageframes_max)
- zcache_eph_pageframes_max = zcache_eph_pageframes;
+ inc_zcache_eph_pageframes();
got_pampd:
- zcache_eph_zbytes =
- atomic_long_add_return(clen, &zcache_eph_zbytes_atomic);
- if (zcache_eph_zbytes > zcache_eph_zbytes_max)
- zcache_eph_zbytes_max = zcache_eph_zbytes;
- zcache_eph_zpages = atomic_inc_return(&zcache_eph_zpages_atomic);
- if (zcache_eph_zpages > zcache_eph_zpages_max)
- zcache_eph_zpages_max = zcache_eph_zpages;
+ inc_zcache_eph_zbytes(clen);
+ inc_zcache_eph_zpages();
if (ramster_enabled && raw)
ramster_count_foreign_pages(true, 1);
out:
@@ -617,19 +658,11 @@ create_pampd:
create_in_new_page:
pampd = (void *)zbud_create_prep(th, false, cdata, clen, newpage);
BUG_ON(pampd == NULL);
- zcache_pers_pageframes =
- atomic_inc_return(&zcache_pers_pageframes_atomic);
- if (zcache_pers_pageframes > zcache_pers_pageframes_max)
- zcache_pers_pageframes_max = zcache_pers_pageframes;
+ inc_zcache_pers_pageframes();
got_pampd:
- zcache_pers_zpages = atomic_inc_return(&zcache_pers_zpages_atomic);
- if (zcache_pers_zpages > zcache_pers_zpages_max)
- zcache_pers_zpages_max = zcache_pers_zpages;
- zcache_pers_zbytes =
- atomic_long_add_return(clen, &zcache_pers_zbytes_atomic);
- if (zcache_pers_zbytes > zcache_pers_zbytes_max)
- zcache_pers_zbytes_max = zcache_pers_zbytes;
+ inc_zcache_pers_zpages();
+ inc_zcache_pers_zbytes(clen);
if (ramster_enabled && raw)
ramster_count_foreign_pages(false, 1);
out:
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 04/11] zcache: Provide accessory functions for counter decrease.
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (2 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 03/11] zcache: Provide accessory functions for counter increase Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 05/11] zcache: The last of the atomic reads has now an accessory function Konrad Rzeszutek Wilk
` (6 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
This way we can have all wrapped with these functions and
can disable/enable this with CONFIG_DEBUG_FS.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 88 +++++++++++++++++++--------------
1 files changed, 51 insertions(+), 37 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 6fd7f0e..29ffbf1 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -141,8 +141,12 @@ static inline void inc_zcache_obj_count(void)
if (zcache_obj_count > zcache_obj_count_max)
zcache_obj_count_max = zcache_obj_count;
}
-
static long zcache_objnode_count;
+static inline void dec_zcache_obj_count(void)
+{
+ zcache_obj_count = atomic_dec_return(&zcache_obj_atomic);
+ BUG_ON(zcache_obj_count < 0);
+};
static atomic_t zcache_objnode_atomic = ATOMIC_INIT(0);
static long zcache_objnode_count_max;
static inline void inc_zcache_objnode_count(void)
@@ -151,6 +155,11 @@ static inline void inc_zcache_objnode_count(void)
if (zcache_objnode_count > zcache_objnode_count_max)
zcache_objnode_count_max = zcache_objnode_count;
};
+static inline void dec_zcache_objnode_count(void)
+{
+ zcache_objnode_count = atomic_dec_return(&zcache_objnode_atomic);
+ BUG_ON(zcache_objnode_count < 0);
+};
static u64 zcache_eph_zbytes;
static atomic_long_t zcache_eph_zbytes_atomic = ATOMIC_INIT(0);
static u64 zcache_eph_zbytes_max;
@@ -160,6 +169,10 @@ static inline void inc_zcache_eph_zbytes(unsigned clen)
if (zcache_eph_zbytes > zcache_eph_zbytes_max)
zcache_eph_zbytes_max = zcache_eph_zbytes;
};
+static inline void dec_zcache_eph_zbytes(unsigned zsize)
+{
+ zcache_eph_zbytes = atomic_long_sub_return(zsize, &zcache_eph_zbytes_atomic);
+};
static u64 zcache_pers_zbytes;
static atomic_long_t zcache_pers_zbytes_atomic = ATOMIC_INIT(0);
static u64 zcache_pers_zbytes_max;
@@ -170,6 +183,10 @@ static inline void inc_zcache_pers_zbytes(unsigned clen)
zcache_pers_zbytes_max = zcache_pers_zbytes;
}
static long zcache_eph_pageframes;
+static inline void dec_zcache_pers_zbytes(unsigned zsize)
+{
+ zcache_pers_zbytes = atomic_long_sub_return(zsize, &zcache_pers_zbytes_atomic);
+}
static atomic_t zcache_eph_pageframes_atomic = ATOMIC_INIT(0);
static long zcache_eph_pageframes_max;
static inline void inc_zcache_eph_pageframes(void)
@@ -179,6 +196,10 @@ static inline void inc_zcache_eph_pageframes(void)
zcache_eph_pageframes_max = zcache_eph_pageframes;
};
static long zcache_pers_pageframes;
+static inline void dec_zcache_eph_pageframes(void)
+{
+ zcache_eph_pageframes = atomic_dec_return(&zcache_eph_pageframes_atomic);
+};
static atomic_t zcache_pers_pageframes_atomic = ATOMIC_INIT(0);
static long zcache_pers_pageframes_max;
static inline void inc_zcache_pers_pageframes(void)
@@ -188,6 +209,10 @@ static inline void inc_zcache_pers_pageframes(void)
zcache_pers_pageframes_max = zcache_pers_pageframes;
}
static long zcache_pageframes_alloced;
+static inline void dec_zcache_pers_pageframes(void)
+{
+ zcache_pers_pageframes = atomic_dec_return(&zcache_pers_pageframes_atomic);
+}
static atomic_t zcache_pageframes_alloced_atomic = ATOMIC_INIT(0);
static inline void inc_zcache_pageframes_alloced(void)
{
@@ -209,6 +234,10 @@ static inline void inc_zcache_eph_zpages(void)
zcache_eph_zpages_max = zcache_eph_zpages;
}
static long zcache_pers_zpages;
+static inline void dec_zcache_eph_zpages(unsigned zpages)
+{
+ zcache_eph_zpages = atomic_sub_return(zpages, &zcache_eph_zpages_atomic);
+}
static atomic_t zcache_pers_zpages_atomic = ATOMIC_INIT(0);
static long zcache_pers_zpages_max;
static inline void inc_zcache_pers_zpages(void)
@@ -217,6 +246,10 @@ static inline void inc_zcache_pers_zpages(void)
if (zcache_pers_zpages > zcache_pers_zpages_max)
zcache_pers_zpages_max = zcache_pers_zpages;
}
+static inline void dec_zcache_pers_zpages(unsigned zpages)
+{
+ zcache_pers_zpages = atomic_sub_return(zpages, &zcache_pers_zpages_atomic);
+}
/* but for the rest of these, counting races are ok */
static unsigned long zcache_flush_total;
static unsigned long zcache_flush_found;
@@ -461,9 +494,7 @@ static struct tmem_objnode *zcache_objnode_alloc(struct tmem_pool *pool)
static void zcache_objnode_free(struct tmem_objnode *objnode,
struct tmem_pool *pool)
{
- zcache_objnode_count =
- atomic_dec_return(&zcache_objnode_atomic);
- BUG_ON(zcache_objnode_count < 0);
+ dec_zcache_objnode_count();
kmem_cache_free(zcache_objnode_cache, objnode);
}
@@ -482,9 +513,7 @@ static struct tmem_obj *zcache_obj_alloc(struct tmem_pool *pool)
static void zcache_obj_free(struct tmem_obj *obj, struct tmem_pool *pool)
{
- zcache_obj_count =
- atomic_dec_return(&zcache_obj_atomic);
- BUG_ON(zcache_obj_count < 0);
+ dec_zcache_obj_count();
kmem_cache_free(zcache_obj_cache, obj);
}
@@ -811,20 +840,14 @@ static int zcache_pampd_get_data_and_free(char *data, size_t *sizep, bool raw,
&zsize, &zpages);
if (eph) {
if (page)
- zcache_eph_pageframes =
- atomic_dec_return(&zcache_eph_pageframes_atomic);
- zcache_eph_zpages =
- atomic_sub_return(zpages, &zcache_eph_zpages_atomic);
- zcache_eph_zbytes =
- atomic_long_sub_return(zsize, &zcache_eph_zbytes_atomic);
+ dec_zcache_eph_pageframes();
+ dec_zcache_eph_zpages(zpages);
+ dec_zcache_eph_zbytes(zsize);
} else {
if (page)
- zcache_pers_pageframes =
- atomic_dec_return(&zcache_pers_pageframes_atomic);
- zcache_pers_zpages =
- atomic_sub_return(zpages, &zcache_pers_zpages_atomic);
- zcache_pers_zbytes =
- atomic_long_sub_return(zsize, &zcache_pers_zbytes_atomic);
+ dec_zcache_pers_pageframes();
+ dec_zcache_pers_zpages(zpages);
+ dec_zcache_pers_zbytes(zsize);
}
if (!is_local_client(pool->client))
ramster_count_foreign_pages(eph, -1);
@@ -854,23 +877,17 @@ static void zcache_pampd_free(void *pampd, struct tmem_pool *pool,
page = zbud_free_and_delist((struct zbudref *)pampd,
true, &zsize, &zpages);
if (page)
- zcache_eph_pageframes =
- atomic_dec_return(&zcache_eph_pageframes_atomic);
- zcache_eph_zpages =
- atomic_sub_return(zpages, &zcache_eph_zpages_atomic);
- zcache_eph_zbytes =
- atomic_long_sub_return(zsize, &zcache_eph_zbytes_atomic);
+ dec_zcache_eph_pageframes();
+ dec_zcache_eph_zpages(zpages);
+ dec_zcache_eph_zbytes(zsize);
/* FIXME CONFIG_RAMSTER... check acct parameter? */
} else {
page = zbud_free_and_delist((struct zbudref *)pampd,
false, &zsize, &zpages);
if (page)
- zcache_pers_pageframes =
- atomic_dec_return(&zcache_pers_pageframes_atomic);
- zcache_pers_zpages =
- atomic_sub_return(zpages, &zcache_pers_zpages_atomic);
- zcache_pers_zbytes =
- atomic_long_sub_return(zsize, &zcache_pers_zbytes_atomic);
+ dec_zcache_pers_pageframes();
+ dec_zcache_pers_zpages(zpages);
+ dec_zcache_pers_zbytes(zsize);
}
if (!is_local_client(pool->client))
ramster_count_foreign_pages(is_ephemeral(pool), -1);
@@ -992,13 +1009,10 @@ static struct page *zcache_evict_eph_pageframe(void)
page = zbud_evict_pageframe_lru(&zsize, &zpages);
if (page == NULL)
goto out;
- zcache_eph_zbytes = atomic_long_sub_return(zsize,
- &zcache_eph_zbytes_atomic);
- zcache_eph_zpages = atomic_sub_return(zpages,
- &zcache_eph_zpages_atomic);
+ dec_zcache_eph_zbytes(zsize);
+ dec_zcache_eph_zpages(zpages);
zcache_evicted_eph_zpages++;
- zcache_eph_pageframes =
- atomic_dec_return(&zcache_eph_pageframes_atomic);
+ dec_zcache_eph_pageframes();
zcache_evicted_eph_pageframes++;
out:
return page;
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 05/11] zcache: The last of the atomic reads has now an accessory function.
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (3 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 04/11] zcache: Provide accessory functions for counter decrease Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 06/11] zcache: Fix compile warnings due to usage of debugfs_create_size_t Konrad Rzeszutek Wilk
` (5 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
And now we can move the code to its own file.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 13 +++++++++----
1 files changed, 9 insertions(+), 4 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 29ffbf1..3402acc 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -250,6 +250,14 @@ static inline void dec_zcache_pers_zpages(unsigned zpages)
{
zcache_pers_zpages = atomic_sub_return(zpages, &zcache_pers_zpages_atomic);
}
+
+static inline unsigned long curr_pageframes_count(void)
+{
+ return zcache_pageframes_alloced -
+ atomic_read(&zcache_pageframes_freed_atomic) -
+ atomic_read(&zcache_eph_pageframes_atomic) -
+ atomic_read(&zcache_pers_pageframes_atomic);
+};
/* but for the rest of these, counting races are ok */
static unsigned long zcache_flush_total;
static unsigned long zcache_flush_found;
@@ -549,10 +557,7 @@ static void zcache_free_page(struct page *page)
BUG();
__free_page(page);
inc_zcache_pageframes_freed();
- curr_pageframes = zcache_pageframes_alloced -
- atomic_read(&zcache_pageframes_freed_atomic) -
- atomic_read(&zcache_eph_pageframes_atomic) -
- atomic_read(&zcache_pers_pageframes_atomic);
+ curr_pageframes = curr_pageframes_count();
if (curr_pageframes > max_pageframes)
max_pageframes = curr_pageframes;
if (curr_pageframes < min_pageframes)
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 06/11] zcache: Fix compile warnings due to usage of debugfs_create_size_t
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (4 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 05/11] zcache: The last of the atomic reads has now an accessory function Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 07/11] zcache: Make the debug code use pr_debug Konrad Rzeszutek Wilk
` (4 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
When we compile we get tons of:
include/linux/debugfs.h:80:16: note: expected ‘size_t *’ but argument is
of type ‘long int *’
drivers/staging/ramster/zcache-main.c:279:2: warning: passing argument 4
of ‘debugfs_create_size_t’ from incompatible pointer type [enabled by d
efault]
which is b/c we end up using 'unsigned' or 'unsigned long' instead
of 'ssize_t'. So lets fix this up and use the proper type.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 135 +++++++++++++++++----------------
1 files changed, 68 insertions(+), 67 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 3402acc..1f354f2 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -132,23 +132,23 @@ static struct kmem_cache *zcache_obj_cache;
static DEFINE_PER_CPU(struct zcache_preload, zcache_preloads) = { 0, };
/* we try to keep these statistics SMP-consistent */
-static long zcache_obj_count;
+static ssize_t zcache_obj_count;
static atomic_t zcache_obj_atomic = ATOMIC_INIT(0);
-static long zcache_obj_count_max;
+static ssize_t zcache_obj_count_max;
static inline void inc_zcache_obj_count(void)
{
zcache_obj_count = atomic_inc_return(&zcache_obj_atomic);
if (zcache_obj_count > zcache_obj_count_max)
zcache_obj_count_max = zcache_obj_count;
}
-static long zcache_objnode_count;
+static ssize_t zcache_objnode_count;
static inline void dec_zcache_obj_count(void)
{
zcache_obj_count = atomic_dec_return(&zcache_obj_atomic);
BUG_ON(zcache_obj_count < 0);
};
static atomic_t zcache_objnode_atomic = ATOMIC_INIT(0);
-static long zcache_objnode_count_max;
+static ssize_t zcache_objnode_count_max;
static inline void inc_zcache_objnode_count(void)
{
zcache_objnode_count = atomic_inc_return(&zcache_objnode_atomic);
@@ -182,64 +182,65 @@ static inline void inc_zcache_pers_zbytes(unsigned clen)
if (zcache_pers_zbytes > zcache_pers_zbytes_max)
zcache_pers_zbytes_max = zcache_pers_zbytes;
}
-static long zcache_eph_pageframes;
+static ssize_t zcache_eph_pageframes;
static inline void dec_zcache_pers_zbytes(unsigned zsize)
{
zcache_pers_zbytes = atomic_long_sub_return(zsize, &zcache_pers_zbytes_atomic);
}
static atomic_t zcache_eph_pageframes_atomic = ATOMIC_INIT(0);
-static long zcache_eph_pageframes_max;
+static ssize_t zcache_eph_pageframes_max;
static inline void inc_zcache_eph_pageframes(void)
{
zcache_eph_pageframes = atomic_inc_return(&zcache_eph_pageframes_atomic);
if (zcache_eph_pageframes > zcache_eph_pageframes_max)
zcache_eph_pageframes_max = zcache_eph_pageframes;
};
-static long zcache_pers_pageframes;
+static ssize_t zcache_pers_pageframes;
static inline void dec_zcache_eph_pageframes(void)
{
zcache_eph_pageframes = atomic_dec_return(&zcache_eph_pageframes_atomic);
};
static atomic_t zcache_pers_pageframes_atomic = ATOMIC_INIT(0);
-static long zcache_pers_pageframes_max;
+static ssize_t zcache_pers_pageframes_max;
static inline void inc_zcache_pers_pageframes(void)
{
zcache_pers_pageframes = atomic_inc_return(&zcache_pers_pageframes_atomic);
if (zcache_pers_pageframes > zcache_pers_pageframes_max)
zcache_pers_pageframes_max = zcache_pers_pageframes;
}
-static long zcache_pageframes_alloced;
+static ssize_t zcache_pageframes_alloced;
static inline void dec_zcache_pers_pageframes(void)
{
zcache_pers_pageframes = atomic_dec_return(&zcache_pers_pageframes_atomic);
}
static atomic_t zcache_pageframes_alloced_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_pageframes_freed;
+static atomic_t zcache_pageframes_freed_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_eph_zpages;
static inline void inc_zcache_pageframes_alloced(void)
{
zcache_pageframes_alloced = atomic_inc_return(&zcache_pageframes_alloced_atomic);
};
-static long zcache_pageframes_freed;
-static atomic_t zcache_pageframes_freed_atomic = ATOMIC_INIT(0);
static inline void inc_zcache_pageframes_freed(void)
{
zcache_pageframes_freed = atomic_inc_return(&zcache_pageframes_freed_atomic);
}
-static long zcache_eph_zpages;
+static ssize_t zcache_eph_zpages;
static atomic_t zcache_eph_zpages_atomic = ATOMIC_INIT(0);
-static long zcache_eph_zpages_max;
+static ssize_t zcache_eph_zpages_max;
static inline void inc_zcache_eph_zpages(void)
{
zcache_eph_zpages = atomic_inc_return(&zcache_eph_zpages_atomic);
if (zcache_eph_zpages > zcache_eph_zpages_max)
zcache_eph_zpages_max = zcache_eph_zpages;
}
-static long zcache_pers_zpages;
+static ssize_t zcache_pers_zpages;
static inline void dec_zcache_eph_zpages(unsigned zpages)
{
zcache_eph_zpages = atomic_sub_return(zpages, &zcache_eph_zpages_atomic);
}
static atomic_t zcache_pers_zpages_atomic = ATOMIC_INIT(0);
-static long zcache_pers_zpages_max;
+static ssize_t zcache_pers_zpages_max;
static inline void inc_zcache_pers_zpages(void)
{
zcache_pers_zpages = atomic_inc_return(&zcache_pers_zpages_atomic);
@@ -259,29 +260,29 @@ static inline unsigned long curr_pageframes_count(void)
atomic_read(&zcache_pers_pageframes_atomic);
};
/* but for the rest of these, counting races are ok */
-static unsigned long zcache_flush_total;
-static unsigned long zcache_flush_found;
-static unsigned long zcache_flobj_total;
-static unsigned long zcache_flobj_found;
-static unsigned long zcache_failed_eph_puts;
-static unsigned long zcache_failed_pers_puts;
-static unsigned long zcache_failed_getfreepages;
-static unsigned long zcache_failed_alloc;
-static unsigned long zcache_put_to_flush;
-static unsigned long zcache_compress_poor;
-static unsigned long zcache_mean_compress_poor;
-static unsigned long zcache_eph_ate_tail;
-static unsigned long zcache_eph_ate_tail_failed;
-static unsigned long zcache_pers_ate_eph;
-static unsigned long zcache_pers_ate_eph_failed;
-static unsigned long zcache_evicted_eph_zpages;
-static unsigned long zcache_evicted_eph_pageframes;
-static unsigned long zcache_last_active_file_pageframes;
-static unsigned long zcache_last_inactive_file_pageframes;
-static unsigned long zcache_last_active_anon_pageframes;
-static unsigned long zcache_last_inactive_anon_pageframes;
-static unsigned long zcache_eph_nonactive_puts_ignored;
-static unsigned long zcache_pers_nonactive_puts_ignored;
+static ssize_t zcache_flush_total;
+static ssize_t zcache_flush_found;
+static ssize_t zcache_flobj_total;
+static ssize_t zcache_flobj_found;
+static ssize_t zcache_failed_eph_puts;
+static ssize_t zcache_failed_pers_puts;
+static ssize_t zcache_failed_getfreepages;
+static ssize_t zcache_failed_alloc;
+static ssize_t zcache_put_to_flush;
+static ssize_t zcache_compress_poor;
+static ssize_t zcache_mean_compress_poor;
+static ssize_t zcache_eph_ate_tail;
+static ssize_t zcache_eph_ate_tail_failed;
+static ssize_t zcache_pers_ate_eph;
+static ssize_t zcache_pers_ate_eph_failed;
+static ssize_t zcache_evicted_eph_zpages;
+static ssize_t zcache_evicted_eph_pageframes;
+static ssize_t zcache_last_active_file_pageframes;
+static ssize_t zcache_last_inactive_file_pageframes;
+static ssize_t zcache_last_active_anon_pageframes;
+static ssize_t zcache_last_inactive_anon_pageframes;
+static ssize_t zcache_eph_nonactive_puts_ignored;
+static ssize_t zcache_pers_nonactive_puts_ignored;
#ifdef CONFIG_DEBUG_FS
#include <linux/debugfs.h>
@@ -351,41 +352,41 @@ static int zcache_debugfs_init(void)
/* developers can call this in case of ooms, e.g. to find memory leaks */
void zcache_dump(void)
{
- pr_info("zcache: obj_count=%lu\n", zcache_obj_count);
- pr_info("zcache: obj_count_max=%lu\n", zcache_obj_count_max);
- pr_info("zcache: objnode_count=%lu\n", zcache_objnode_count);
- pr_info("zcache: objnode_count_max=%lu\n", zcache_objnode_count_max);
- pr_info("zcache: flush_total=%lu\n", zcache_flush_total);
- pr_info("zcache: flush_found=%lu\n", zcache_flush_found);
- pr_info("zcache: flobj_total=%lu\n", zcache_flobj_total);
- pr_info("zcache: flobj_found=%lu\n", zcache_flobj_found);
- pr_info("zcache: failed_eph_puts=%lu\n", zcache_failed_eph_puts);
- pr_info("zcache: failed_pers_puts=%lu\n", zcache_failed_pers_puts);
- pr_info("zcache: failed_get_free_pages=%lu\n",
+ pr_info("zcache: obj_count=%u\n", zcache_obj_count);
+ pr_info("zcache: obj_count_max=%u\n", zcache_obj_count_max);
+ pr_info("zcache: objnode_count=%u\n", zcache_objnode_count);
+ pr_info("zcache: objnode_count_max=%u\n", zcache_objnode_count_max);
+ pr_info("zcache: flush_total=%u\n", zcache_flush_total);
+ pr_info("zcache: flush_found=%u\n", zcache_flush_found);
+ pr_info("zcache: flobj_total=%u\n", zcache_flobj_total);
+ pr_info("zcache: flobj_found=%u\n", zcache_flobj_found);
+ pr_info("zcache: failed_eph_puts=%u\n", zcache_failed_eph_puts);
+ pr_info("zcache: failed_pers_puts=%u\n", zcache_failed_pers_puts);
+ pr_info("zcache: failed_get_free_pages=%u\n",
zcache_failed_getfreepages);
- pr_info("zcache: failed_alloc=%lu\n", zcache_failed_alloc);
- pr_info("zcache: put_to_flush=%lu\n", zcache_put_to_flush);
- pr_info("zcache: compress_poor=%lu\n", zcache_compress_poor);
- pr_info("zcache: mean_compress_poor=%lu\n",
+ pr_info("zcache: failed_alloc=%u\n", zcache_failed_alloc);
+ pr_info("zcache: put_to_flush=%u\n", zcache_put_to_flush);
+ pr_info("zcache: compress_poor=%u\n", zcache_compress_poor);
+ pr_info("zcache: mean_compress_poor=%u\n",
zcache_mean_compress_poor);
- pr_info("zcache: eph_ate_tail=%lu\n", zcache_eph_ate_tail);
- pr_info("zcache: eph_ate_tail_failed=%lu\n",
+ pr_info("zcache: eph_ate_tail=%u\n", zcache_eph_ate_tail);
+ pr_info("zcache: eph_ate_tail_failed=%u\n",
zcache_eph_ate_tail_failed);
- pr_info("zcache: pers_ate_eph=%lu\n", zcache_pers_ate_eph);
- pr_info("zcache: pers_ate_eph_failed=%lu\n",
+ pr_info("zcache: pers_ate_eph=%u\n", zcache_pers_ate_eph);
+ pr_info("zcache: pers_ate_eph_failed=%u\n",
zcache_pers_ate_eph_failed);
- pr_info("zcache: evicted_eph_zpages=%lu\n", zcache_evicted_eph_zpages);
- pr_info("zcache: evicted_eph_pageframes=%lu\n",
+ pr_info("zcache: evicted_eph_zpages=%u\n", zcache_evicted_eph_zpages);
+ pr_info("zcache: evicted_eph_pageframes=%u\n",
zcache_evicted_eph_pageframes);
- pr_info("zcache: eph_pageframes=%lu\n", zcache_eph_pageframes);
- pr_info("zcache: eph_pageframes_max=%lu\n", zcache_eph_pageframes_max);
- pr_info("zcache: pers_pageframes=%lu\n", zcache_pers_pageframes);
- pr_info("zcache: pers_pageframes_max=%lu\n",
+ pr_info("zcache: eph_pageframes=%u\n", zcache_eph_pageframes);
+ pr_info("zcache: eph_pageframes_max=%u\n", zcache_eph_pageframes_max);
+ pr_info("zcache: pers_pageframes=%u\n", zcache_pers_pageframes);
+ pr_info("zcache: pers_pageframes_max=%u\n",
zcache_pers_pageframes_max);
- pr_info("zcache: eph_zpages=%lu\n", zcache_eph_zpages);
- pr_info("zcache: eph_zpages_max=%lu\n", zcache_eph_zpages_max);
- pr_info("zcache: pers_zpages=%lu\n", zcache_pers_zpages);
- pr_info("zcache: pers_zpages_max=%lu\n", zcache_pers_zpages_max);
+ pr_info("zcache: eph_zpages=%u\n", zcache_eph_zpages);
+ pr_info("zcache: eph_zpages_max=%u\n", zcache_eph_zpages_max);
+ pr_info("zcache: pers_zpages=%u\n", zcache_pers_zpages);
+ pr_info("zcache: pers_zpages_max=%u\n", zcache_pers_zpages_max);
pr_info("zcache: eph_zbytes=%llu\n",
(unsigned long long)zcache_eph_zbytes);
pr_info("zcache: eph_zbytes_max=%llu\n",
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 07/11] zcache: Make the debug code use pr_debug
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (5 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 06/11] zcache: Fix compile warnings due to usage of debugfs_create_size_t Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 08/11] zcache: Move debugfs code out of zcache-main.c file Konrad Rzeszutek Wilk
` (3 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
as if you are debugging this driver you would be using 'debug'
on the command line anyhow - and this would dump the debug
data on the proper loglevel.
While at it also remove the unconditional #define ZCACHE_DEBUG.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/zcache-main.c | 69 ++++++++++++++++-----------------
1 files changed, 33 insertions(+), 36 deletions(-)
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 1f354f2..470ce5c 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -347,56 +347,53 @@ static int zcache_debugfs_init(void)
#undef zdfs64
#endif
-#define ZCACHE_DEBUG
-#ifdef ZCACHE_DEBUG
/* developers can call this in case of ooms, e.g. to find memory leaks */
void zcache_dump(void)
{
- pr_info("zcache: obj_count=%u\n", zcache_obj_count);
- pr_info("zcache: obj_count_max=%u\n", zcache_obj_count_max);
- pr_info("zcache: objnode_count=%u\n", zcache_objnode_count);
- pr_info("zcache: objnode_count_max=%u\n", zcache_objnode_count_max);
- pr_info("zcache: flush_total=%u\n", zcache_flush_total);
- pr_info("zcache: flush_found=%u\n", zcache_flush_found);
- pr_info("zcache: flobj_total=%u\n", zcache_flobj_total);
- pr_info("zcache: flobj_found=%u\n", zcache_flobj_found);
- pr_info("zcache: failed_eph_puts=%u\n", zcache_failed_eph_puts);
- pr_info("zcache: failed_pers_puts=%u\n", zcache_failed_pers_puts);
- pr_info("zcache: failed_get_free_pages=%u\n",
+ pr_debug("zcache: obj_count=%u\n", zcache_obj_count);
+ pr_debug("zcache: obj_count_max=%u\n", zcache_obj_count_max);
+ pr_debug("zcache: objnode_count=%u\n", zcache_objnode_count);
+ pr_debug("zcache: objnode_count_max=%u\n", zcache_objnode_count_max);
+ pr_debug("zcache: flush_total=%u\n", zcache_flush_total);
+ pr_debug("zcache: flush_found=%u\n", zcache_flush_found);
+ pr_debug("zcache: flobj_total=%u\n", zcache_flobj_total);
+ pr_debug("zcache: flobj_found=%u\n", zcache_flobj_found);
+ pr_debug("zcache: failed_eph_puts=%u\n", zcache_failed_eph_puts);
+ pr_debug("zcache: failed_pers_puts=%u\n", zcache_failed_pers_puts);
+ pr_debug("zcache: failed_get_free_pages=%u\n",
zcache_failed_getfreepages);
- pr_info("zcache: failed_alloc=%u\n", zcache_failed_alloc);
- pr_info("zcache: put_to_flush=%u\n", zcache_put_to_flush);
- pr_info("zcache: compress_poor=%u\n", zcache_compress_poor);
- pr_info("zcache: mean_compress_poor=%u\n",
+ pr_debug("zcache: failed_alloc=%u\n", zcache_failed_alloc);
+ pr_debug("zcache: put_to_flush=%u\n", zcache_put_to_flush);
+ pr_debug("zcache: compress_poor=%u\n", zcache_compress_poor);
+ pr_debug("zcache: mean_compress_poor=%u\n",
zcache_mean_compress_poor);
- pr_info("zcache: eph_ate_tail=%u\n", zcache_eph_ate_tail);
- pr_info("zcache: eph_ate_tail_failed=%u\n",
+ pr_debug("zcache: eph_ate_tail=%u\n", zcache_eph_ate_tail);
+ pr_debug("zcache: eph_ate_tail_failed=%u\n",
zcache_eph_ate_tail_failed);
- pr_info("zcache: pers_ate_eph=%u\n", zcache_pers_ate_eph);
- pr_info("zcache: pers_ate_eph_failed=%u\n",
+ pr_debug("zcache: pers_ate_eph=%u\n", zcache_pers_ate_eph);
+ pr_debug("zcache: pers_ate_eph_failed=%u\n",
zcache_pers_ate_eph_failed);
- pr_info("zcache: evicted_eph_zpages=%u\n", zcache_evicted_eph_zpages);
- pr_info("zcache: evicted_eph_pageframes=%u\n",
+ pr_debug("zcache: evicted_eph_zpages=%u\n", zcache_evicted_eph_zpages);
+ pr_debug("zcache: evicted_eph_pageframes=%u\n",
zcache_evicted_eph_pageframes);
- pr_info("zcache: eph_pageframes=%u\n", zcache_eph_pageframes);
- pr_info("zcache: eph_pageframes_max=%u\n", zcache_eph_pageframes_max);
- pr_info("zcache: pers_pageframes=%u\n", zcache_pers_pageframes);
- pr_info("zcache: pers_pageframes_max=%u\n",
+ pr_debug("zcache: eph_pageframes=%u\n", zcache_eph_pageframes);
+ pr_debug("zcache: eph_pageframes_max=%u\n", zcache_eph_pageframes_max);
+ pr_debug("zcache: pers_pageframes=%u\n", zcache_pers_pageframes);
+ pr_debug("zcache: pers_pageframes_max=%u\n",
zcache_pers_pageframes_max);
- pr_info("zcache: eph_zpages=%u\n", zcache_eph_zpages);
- pr_info("zcache: eph_zpages_max=%u\n", zcache_eph_zpages_max);
- pr_info("zcache: pers_zpages=%u\n", zcache_pers_zpages);
- pr_info("zcache: pers_zpages_max=%u\n", zcache_pers_zpages_max);
- pr_info("zcache: eph_zbytes=%llu\n",
+ pr_debug("zcache: eph_zpages=%u\n", zcache_eph_zpages);
+ pr_debug("zcache: eph_zpages_max=%u\n", zcache_eph_zpages_max);
+ pr_debug("zcache: pers_zpages=%u\n", zcache_pers_zpages);
+ pr_debug("zcache: pers_zpages_max=%u\n", zcache_pers_zpages_max);
+ pr_debug("zcache: eph_zbytes=%llu\n",
(unsigned long long)zcache_eph_zbytes);
- pr_info("zcache: eph_zbytes_max=%llu\n",
+ pr_debug("zcache: eph_zbytes_max=%llu\n",
(unsigned long long)zcache_eph_zbytes_max);
- pr_info("zcache: pers_zbytes=%llu\n",
+ pr_debug("zcache: pers_zbytes=%llu\n",
(unsigned long long)zcache_pers_zbytes);
- pr_info("zcache: pers_zbytes_max=%llu\n",
+ pr_debug("zcache: pers_zbytes_max=%llu\n",
(unsigned long long)zcache_pers_zbytes_max);
}
-#endif
/*
* zcache core code starts here
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 08/11] zcache: Move debugfs code out of zcache-main.c file.
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (6 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 07/11] zcache: Make the debug code use pr_debug Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 09/11] zcache: Use an array to initialize/use debugfs attributes Konrad Rzeszutek Wilk
` (2 subsequent siblings)
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/Makefile | 1 +
drivers/staging/ramster/debug.c | 113 +++++++++++++++
drivers/staging/ramster/debug.h | 183 ++++++++++++++++++++++++
drivers/staging/ramster/zcache-main.c | 247 +--------------------------------
4 files changed, 304 insertions(+), 240 deletions(-)
create mode 100644 drivers/staging/ramster/debug.c
create mode 100644 drivers/staging/ramster/debug.h
diff --git a/drivers/staging/ramster/Makefile b/drivers/staging/ramster/Makefile
index fcb25cb..61f5050 100644
--- a/drivers/staging/ramster/Makefile
+++ b/drivers/staging/ramster/Makefile
@@ -4,4 +4,5 @@ zcache-y += ramster/ramster.o ramster/r2net.o
zcache-y += ramster/nodemanager.o ramster/tcp.o
zcache-y += ramster/heartbeat.o ramster/masklog.o
endif
+zcache-y-$(CONFIG_ZCACHE_DEBUG) += debug.o
obj-$(CONFIG_MODULES) += zcache.o
diff --git a/drivers/staging/ramster/debug.c b/drivers/staging/ramster/debug.c
new file mode 100644
index 0000000..0d19715
--- /dev/null
+++ b/drivers/staging/ramster/debug.c
@@ -0,0 +1,113 @@
+#include <linux/atomic.h>
+#include "debug.h"
+
+#ifdef CONFIG_DEBUG_FS
+#include <linux/debugfs.h>
+#define zdfs debugfs_create_size_t
+#define zdfs64 debugfs_create_u64
+int zcache_debugfs_init(void)
+{
+ struct dentry *root = debugfs_create_dir("zcache", NULL);
+ if (root == NULL)
+ return -ENXIO;
+
+ zdfs("obj_count", S_IRUGO, root, &zcache_obj_count);
+ zdfs("obj_count_max", S_IRUGO, root, &zcache_obj_count_max);
+ zdfs("objnode_count", S_IRUGO, root, &zcache_objnode_count);
+ zdfs("objnode_count_max", S_IRUGO, root, &zcache_objnode_count_max);
+ zdfs("flush_total", S_IRUGO, root, &zcache_flush_total);
+ zdfs("flush_found", S_IRUGO, root, &zcache_flush_found);
+ zdfs("flobj_total", S_IRUGO, root, &zcache_flobj_total);
+ zdfs("flobj_found", S_IRUGO, root, &zcache_flobj_found);
+ zdfs("failed_eph_puts", S_IRUGO, root, &zcache_failed_eph_puts);
+ zdfs("failed_pers_puts", S_IRUGO, root, &zcache_failed_pers_puts);
+ zdfs("failed_get_free_pages", S_IRUGO, root,
+ &zcache_failed_getfreepages);
+ zdfs("failed_alloc", S_IRUGO, root, &zcache_failed_alloc);
+ zdfs("put_to_flush", S_IRUGO, root, &zcache_put_to_flush);
+ zdfs("compress_poor", S_IRUGO, root, &zcache_compress_poor);
+ zdfs("mean_compress_poor", S_IRUGO, root, &zcache_mean_compress_poor);
+ zdfs("eph_ate_tail", S_IRUGO, root, &zcache_eph_ate_tail);
+ zdfs("eph_ate_tail_failed", S_IRUGO, root, &zcache_eph_ate_tail_failed);
+ zdfs("pers_ate_eph", S_IRUGO, root, &zcache_pers_ate_eph);
+ zdfs("pers_ate_eph_failed", S_IRUGO, root, &zcache_pers_ate_eph_failed);
+ zdfs("evicted_eph_zpages", S_IRUGO, root, &zcache_evicted_eph_zpages);
+ zdfs("evicted_eph_pageframes", S_IRUGO, root,
+ &zcache_evicted_eph_pageframes);
+ zdfs("eph_pageframes", S_IRUGO, root, &zcache_eph_pageframes);
+ zdfs("eph_pageframes_max", S_IRUGO, root, &zcache_eph_pageframes_max);
+ zdfs("pers_pageframes", S_IRUGO, root, &zcache_pers_pageframes);
+ zdfs("pers_pageframes_max", S_IRUGO, root, &zcache_pers_pageframes_max);
+ zdfs("eph_zpages", S_IRUGO, root, &zcache_eph_zpages);
+ zdfs("eph_zpages_max", S_IRUGO, root, &zcache_eph_zpages_max);
+ zdfs("pers_zpages", S_IRUGO, root, &zcache_pers_zpages);
+ zdfs("pers_zpages_max", S_IRUGO, root, &zcache_pers_zpages_max);
+ zdfs("last_active_file_pageframes", S_IRUGO, root,
+ &zcache_last_active_file_pageframes);
+ zdfs("last_inactive_file_pageframes", S_IRUGO, root,
+ &zcache_last_inactive_file_pageframes);
+ zdfs("last_active_anon_pageframes", S_IRUGO, root,
+ &zcache_last_active_anon_pageframes);
+ zdfs("last_inactive_anon_pageframes", S_IRUGO, root,
+ &zcache_last_inactive_anon_pageframes);
+ zdfs("eph_nonactive_puts_ignored", S_IRUGO, root,
+ &zcache_eph_nonactive_puts_ignored);
+ zdfs("pers_nonactive_puts_ignored", S_IRUGO, root,
+ &zcache_pers_nonactive_puts_ignored);
+ zdfs64("eph_zbytes", S_IRUGO, root, &zcache_eph_zbytes);
+ zdfs64("eph_zbytes_max", S_IRUGO, root, &zcache_eph_zbytes_max);
+ zdfs64("pers_zbytes", S_IRUGO, root, &zcache_pers_zbytes);
+ zdfs64("pers_zbytes_max", S_IRUGO, root, &zcache_pers_zbytes_max);
+ return 0;
+}
+#undef zdebugfs
+#undef zdfs64
+
+/* developers can call this in case of ooms, e.g. to find memory leaks */
+void zcache_dump(void)
+{
+ pr_debug("zcache: obj_count=%u\n", zcache_obj_count);
+ pr_debug("zcache: obj_count_max=%u\n", zcache_obj_count_max);
+ pr_debug("zcache: objnode_count=%u\n", zcache_objnode_count);
+ pr_debug("zcache: objnode_count_max=%u\n", zcache_objnode_count_max);
+ pr_debug("zcache: flush_total=%u\n", zcache_flush_total);
+ pr_debug("zcache: flush_found=%u\n", zcache_flush_found);
+ pr_debug("zcache: flobj_total=%u\n", zcache_flobj_total);
+ pr_debug("zcache: flobj_found=%u\n", zcache_flobj_found);
+ pr_debug("zcache: failed_eph_puts=%u\n", zcache_failed_eph_puts);
+ pr_debug("zcache: failed_pers_puts=%u\n", zcache_failed_pers_puts);
+ pr_debug("zcache: failed_get_free_pages=%u\n",
+ zcache_failed_getfreepages);
+ pr_debug("zcache: failed_alloc=%u\n", zcache_failed_alloc);
+ pr_debug("zcache: put_to_flush=%u\n", zcache_put_to_flush);
+ pr_debug("zcache: compress_poor=%u\n", zcache_compress_poor);
+ pr_debug("zcache: mean_compress_poor=%u\n",
+ zcache_mean_compress_poor);
+ pr_debug("zcache: eph_ate_tail=%u\n", zcache_eph_ate_tail);
+ pr_debug("zcache: eph_ate_tail_failed=%u\n",
+ zcache_eph_ate_tail_failed);
+ pr_debug("zcache: pers_ate_eph=%u\n", zcache_pers_ate_eph);
+ pr_debug("zcache: pers_ate_eph_failed=%u\n",
+ zcache_pers_ate_eph_failed);
+ pr_debug("zcache: evicted_eph_zpages=%u\n", zcache_evicted_eph_zpages);
+ pr_debug("zcache: evicted_eph_pageframes=%u\n",
+ zcache_evicted_eph_pageframes);
+ pr_debug("zcache: eph_pageframes=%u\n", zcache_eph_pageframes);
+ pr_debug("zcache: eph_pageframes_max=%u\n", zcache_eph_pageframes_max);
+ pr_debug("zcache: pers_pageframes=%u\n", zcache_pers_pageframes);
+ pr_debug("zcache: pers_pageframes_max=%u\n",
+ zcache_pers_pageframes_max);
+ pr_debug("zcache: eph_zpages=%u\n", zcache_eph_zpages);
+ pr_debug("zcache: eph_zpages_max=%u\n", zcache_eph_zpages_max);
+ pr_debug("zcache: pers_zpages=%u\n", zcache_pers_zpages);
+ pr_debug("zcache: pers_zpages_max=%u\n", zcache_pers_zpages_max);
+ pr_debug("zcache: eph_zbytes=%llu\n",
+ (unsigned long long)zcache_eph_zbytes);
+ pr_debug("zcache: eph_zbytes_max=%llu\n",
+ (unsigned long long)zcache_eph_zbytes_max);
+ pr_debug("zcache: pers_zbytes=%llu\n",
+ (unsigned long long)zcache_pers_zbytes);
+ pr_debug("zcache: pers_zbytes_max=%llu\n",
+ (unsigned long long)zcache_pers_zbytes_max);
+}
+#endif
diff --git a/drivers/staging/ramster/debug.h b/drivers/staging/ramster/debug.h
new file mode 100644
index 0000000..496735b
--- /dev/null
+++ b/drivers/staging/ramster/debug.h
@@ -0,0 +1,183 @@
+#ifdef CONFIG_ZCACHE_DEBUG
+
+/* we try to keep these statistics SMP-consistent */
+static ssize_t zcache_obj_count;
+static atomic_t zcache_obj_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_obj_count_max;
+static inline void inc_zcache_obj_count(void)
+{
+ zcache_obj_count = atomic_inc_return(&zcache_obj_atomic);
+ if (zcache_obj_count > zcache_obj_count_max)
+ zcache_obj_count_max = zcache_obj_count;
+}
+static inline void dec_zcache_obj_count(void)
+{
+ zcache_obj_count = atomic_dec_return(&zcache_obj_atomic);
+ BUG_ON(zcache_obj_count < 0);
+};
+static ssize_t zcache_objnode_count;
+static atomic_t zcache_objnode_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_objnode_count_max;
+static inline void inc_zcache_objnode_count(void)
+{
+ zcache_objnode_count = atomic_inc_return(&zcache_objnode_atomic);
+ if (zcache_objnode_count > zcache_objnode_count_max)
+ zcache_objnode_count_max = zcache_objnode_count;
+};
+static inline void dec_zcache_objnode_count(void)
+{
+ zcache_objnode_count = atomic_dec_return(&zcache_objnode_atomic);
+ BUG_ON(zcache_objnode_count < 0);
+};
+static u64 zcache_eph_zbytes;
+static atomic_long_t zcache_eph_zbytes_atomic = ATOMIC_INIT(0);
+static u64 zcache_eph_zbytes_max;
+static inline void inc_zcache_eph_zbytes(unsigned clen)
+{
+ zcache_eph_zbytes = atomic_long_add_return(clen, &zcache_eph_zbytes_atomic);
+ if (zcache_eph_zbytes > zcache_eph_zbytes_max)
+ zcache_eph_zbytes_max = zcache_eph_zbytes;
+};
+static inline void dec_zcache_eph_zbytes(unsigned zsize)
+{
+ zcache_eph_zbytes = atomic_long_sub_return(zsize, &zcache_eph_zbytes_atomic);
+};
+extern u64 zcache_pers_zbytes;
+static atomic_long_t zcache_pers_zbytes_atomic = ATOMIC_INIT(0);
+static u64 zcache_pers_zbytes_max;
+static inline void inc_zcache_pers_zbytes(unsigned clen)
+{
+ zcache_pers_zbytes = atomic_long_add_return(clen, &zcache_pers_zbytes_atomic);
+ if (zcache_pers_zbytes > zcache_pers_zbytes_max)
+ zcache_pers_zbytes_max = zcache_pers_zbytes;
+}
+static inline void dec_zcache_pers_zbytes(unsigned zsize)
+{
+ zcache_pers_zbytes = atomic_long_sub_return(zsize, &zcache_pers_zbytes_atomic);
+}
+extern ssize_t zcache_eph_pageframes;
+static atomic_t zcache_eph_pageframes_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_eph_pageframes_max;
+static inline void inc_zcache_eph_pageframes(void)
+{
+ zcache_eph_pageframes = atomic_inc_return(&zcache_eph_pageframes_atomic);
+ if (zcache_eph_pageframes > zcache_eph_pageframes_max)
+ zcache_eph_pageframes_max = zcache_eph_pageframes;
+};
+static inline void dec_zcache_eph_pageframes(void)
+{
+ zcache_eph_pageframes = atomic_dec_return(&zcache_eph_pageframes_atomic);
+};
+extern ssize_t zcache_pers_pageframes;
+static atomic_t zcache_pers_pageframes_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_pers_pageframes_max;
+static inline void inc_zcache_pers_pageframes(void)
+{
+ zcache_pers_pageframes = atomic_inc_return(&zcache_pers_pageframes_atomic);
+ if (zcache_pers_pageframes > zcache_pers_pageframes_max)
+ zcache_pers_pageframes_max = zcache_pers_pageframes;
+}
+static inline void dec_zcache_pers_pageframes(void)
+{
+ zcache_pers_pageframes = atomic_dec_return(&zcache_pers_pageframes_atomic);
+}
+static ssize_t zcache_pageframes_alloced;
+static atomic_t zcache_pageframes_alloced_atomic = ATOMIC_INIT(0);
+static inline void inc_zcache_pageframes_alloced(void)
+{
+ zcache_pageframes_alloced = atomic_inc_return(&zcache_pageframes_alloced_atomic);
+};
+static ssize_t zcache_pageframes_freed;
+static atomic_t zcache_pageframes_freed_atomic = ATOMIC_INIT(0);
+static inline void inc_zcache_pageframes_freed(void)
+{
+ zcache_pageframes_freed = atomic_inc_return(&zcache_pageframes_freed_atomic);
+}
+static ssize_t zcache_eph_zpages;
+static atomic_t zcache_eph_zpages_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_eph_zpages_max;
+static inline void inc_zcache_eph_zpages(void)
+{
+ zcache_eph_zpages = atomic_inc_return(&zcache_eph_zpages_atomic);
+ if (zcache_eph_zpages > zcache_eph_zpages_max)
+ zcache_eph_zpages_max = zcache_eph_zpages;
+}
+static inline void dec_zcache_eph_zpages(unsigned zpages)
+{
+ zcache_eph_zpages = atomic_sub_return(zpages, &zcache_eph_zpages_atomic);
+}
+extern ssize_t zcache_pers_zpages;
+static atomic_t zcache_pers_zpages_atomic = ATOMIC_INIT(0);
+static ssize_t zcache_pers_zpages_max;
+static inline void inc_zcache_pers_zpages(void)
+{
+ zcache_pers_zpages = atomic_inc_return(&zcache_pers_zpages_atomic);
+ if (zcache_pers_zpages > zcache_pers_zpages_max)
+ zcache_pers_zpages_max = zcache_pers_zpages;
+}
+static inline void dec_zcache_pers_zpages(unsigned zpages)
+{
+ zcache_pers_zpages = atomic_sub_return(zpages, &zcache_pers_zpages_atomic);
+}
+
+static inline unsigned long curr_pageframes_count(void)
+{
+ return zcache_pageframes_alloced -
+ atomic_read(&zcache_pageframes_freed_atomic) -
+ atomic_read(&zcache_eph_pageframes_atomic) -
+ atomic_read(&zcache_pers_pageframes_atomic);
+};
+/* but for the rest of these, counting races are ok */
+extern ssize_t zcache_flush_total;
+extern ssize_t zcache_flush_found;
+extern ssize_t zcache_flobj_total;
+extern ssize_t zcache_flobj_found;
+extern ssize_t zcache_failed_eph_puts;
+extern ssize_t zcache_failed_pers_puts;
+extern ssize_t zcache_failed_getfreepages;
+extern ssize_t zcache_failed_alloc;
+extern ssize_t zcache_put_to_flush;
+extern ssize_t zcache_compress_poor;
+extern ssize_t zcache_mean_compress_poor;
+extern ssize_t zcache_eph_ate_tail;
+extern ssize_t zcache_eph_ate_tail_failed;
+extern ssize_t zcache_pers_ate_eph;
+extern ssize_t zcache_pers_ate_eph_failed;
+extern ssize_t zcache_evicted_eph_zpages;
+extern ssize_t zcache_evicted_eph_pageframes;
+extern ssize_t zcache_last_active_file_pageframes;
+extern ssize_t zcache_last_inactive_file_pageframes;
+extern ssize_t zcache_last_active_anon_pageframes;
+extern ssize_t zcache_last_inactive_anon_pageframes;
+extern ssize_t zcache_eph_nonactive_puts_ignored;
+extern ssize_t zcache_pers_nonactive_puts_ignored;
+
+int zcache_debugfs_init(void);
+#else
+static inline void inc_zcache_obj_count(void) { };
+static inline void dec_zcache_obj_count(void) { };
+static inline void inc_zcache_objnode_count(void) { };
+static inline void dec_zcache_objnode_count(void) { };
+static inline void inc_zcache_eph_zbytes(unsigned clen) { };
+static inline void dec_zcache_eph_zbytes(unsigned zsize) { };
+static inline void inc_zcache_pers_zbytes(unsigned clen) { };
+static inline void dec_zcache_pers_zbytes(unsigned zsize) { };
+static inline void inc_zcache_eph_pageframes(void) { };
+static inline void dec_zcache_eph_pageframes(void) { };
+static inline void inc_zcache_pers_pageframes(void) { };
+static inline void dec_zcache_pers_pageframes(void) { };
+static inline void inc_zcache_pageframes_alloced(void) { };
+static inline void inc_zcache_pageframes_freed(void) { };
+static inline void inc_zcache_eph_zpages(void) { };
+static inline void dec_zcache_eph_zpages(unsigned zpages) { };
+static inline void inc_zcache_pers_zpages(void) { };
+static inline void dec_zcache_pers_zpages(unsigned zpages) { };
+static inline unsigned long curr_pageframes_count(void)
+{
+ return 0;
+};
+static inline int zcache_debugfs_init(void)
+{
+ return 0;
+};
+#endif
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 470ce5c..013bfa4 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -29,6 +29,7 @@
#include "zcache.h"
#include "zbud.h"
#include "ramster.h"
+#include "debug.h"
#ifdef CONFIG_RAMSTER
static bool ramster_enabled __read_mostly;
static bool disable_frontswap_selfshrink __read_mostly;
@@ -131,135 +132,13 @@ static struct kmem_cache *zcache_obj_cache;
static DEFINE_PER_CPU(struct zcache_preload, zcache_preloads) = { 0, };
-/* we try to keep these statistics SMP-consistent */
-static ssize_t zcache_obj_count;
-static atomic_t zcache_obj_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_obj_count_max;
-static inline void inc_zcache_obj_count(void)
-{
- zcache_obj_count = atomic_inc_return(&zcache_obj_atomic);
- if (zcache_obj_count > zcache_obj_count_max)
- zcache_obj_count_max = zcache_obj_count;
-}
-static ssize_t zcache_objnode_count;
-static inline void dec_zcache_obj_count(void)
-{
- zcache_obj_count = atomic_dec_return(&zcache_obj_atomic);
- BUG_ON(zcache_obj_count < 0);
-};
-static atomic_t zcache_objnode_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_objnode_count_max;
-static inline void inc_zcache_objnode_count(void)
-{
- zcache_objnode_count = atomic_inc_return(&zcache_objnode_atomic);
- if (zcache_objnode_count > zcache_objnode_count_max)
- zcache_objnode_count_max = zcache_objnode_count;
-};
-static inline void dec_zcache_objnode_count(void)
-{
- zcache_objnode_count = atomic_dec_return(&zcache_objnode_atomic);
- BUG_ON(zcache_objnode_count < 0);
-};
-static u64 zcache_eph_zbytes;
-static atomic_long_t zcache_eph_zbytes_atomic = ATOMIC_INIT(0);
-static u64 zcache_eph_zbytes_max;
-static inline void inc_zcache_eph_zbytes(unsigned clen)
-{
- zcache_eph_zbytes = atomic_long_add_return(clen, &zcache_eph_zbytes_atomic);
- if (zcache_eph_zbytes > zcache_eph_zbytes_max)
- zcache_eph_zbytes_max = zcache_eph_zbytes;
-};
-static inline void dec_zcache_eph_zbytes(unsigned zsize)
-{
- zcache_eph_zbytes = atomic_long_sub_return(zsize, &zcache_eph_zbytes_atomic);
-};
-static u64 zcache_pers_zbytes;
-static atomic_long_t zcache_pers_zbytes_atomic = ATOMIC_INIT(0);
-static u64 zcache_pers_zbytes_max;
-static inline void inc_zcache_pers_zbytes(unsigned clen)
-{
- zcache_pers_zbytes = atomic_long_add_return(clen, &zcache_pers_zbytes_atomic);
- if (zcache_pers_zbytes > zcache_pers_zbytes_max)
- zcache_pers_zbytes_max = zcache_pers_zbytes;
-}
-static ssize_t zcache_eph_pageframes;
-static inline void dec_zcache_pers_zbytes(unsigned zsize)
-{
- zcache_pers_zbytes = atomic_long_sub_return(zsize, &zcache_pers_zbytes_atomic);
-}
-static atomic_t zcache_eph_pageframes_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_eph_pageframes_max;
-static inline void inc_zcache_eph_pageframes(void)
-{
- zcache_eph_pageframes = atomic_inc_return(&zcache_eph_pageframes_atomic);
- if (zcache_eph_pageframes > zcache_eph_pageframes_max)
- zcache_eph_pageframes_max = zcache_eph_pageframes;
-};
-static ssize_t zcache_pers_pageframes;
-static inline void dec_zcache_eph_pageframes(void)
-{
- zcache_eph_pageframes = atomic_dec_return(&zcache_eph_pageframes_atomic);
-};
-static atomic_t zcache_pers_pageframes_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_pers_pageframes_max;
-static inline void inc_zcache_pers_pageframes(void)
-{
- zcache_pers_pageframes = atomic_inc_return(&zcache_pers_pageframes_atomic);
- if (zcache_pers_pageframes > zcache_pers_pageframes_max)
- zcache_pers_pageframes_max = zcache_pers_pageframes;
-}
-static ssize_t zcache_pageframes_alloced;
-static inline void dec_zcache_pers_pageframes(void)
-{
- zcache_pers_pageframes = atomic_dec_return(&zcache_pers_pageframes_atomic);
-}
-static atomic_t zcache_pageframes_alloced_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_pageframes_freed;
-static atomic_t zcache_pageframes_freed_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_eph_zpages;
-static inline void inc_zcache_pageframes_alloced(void)
-{
- zcache_pageframes_alloced = atomic_inc_return(&zcache_pageframes_alloced_atomic);
-};
-static inline void inc_zcache_pageframes_freed(void)
-{
- zcache_pageframes_freed = atomic_inc_return(&zcache_pageframes_freed_atomic);
-}
-static ssize_t zcache_eph_zpages;
-static atomic_t zcache_eph_zpages_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_eph_zpages_max;
-static inline void inc_zcache_eph_zpages(void)
-{
- zcache_eph_zpages = atomic_inc_return(&zcache_eph_zpages_atomic);
- if (zcache_eph_zpages > zcache_eph_zpages_max)
- zcache_eph_zpages_max = zcache_eph_zpages;
-}
-static ssize_t zcache_pers_zpages;
-static inline void dec_zcache_eph_zpages(unsigned zpages)
-{
- zcache_eph_zpages = atomic_sub_return(zpages, &zcache_eph_zpages_atomic);
-}
-static atomic_t zcache_pers_zpages_atomic = ATOMIC_INIT(0);
-static ssize_t zcache_pers_zpages_max;
-static inline void inc_zcache_pers_zpages(void)
-{
- zcache_pers_zpages = atomic_inc_return(&zcache_pers_zpages_atomic);
- if (zcache_pers_zpages > zcache_pers_zpages_max)
- zcache_pers_zpages_max = zcache_pers_zpages;
-}
-static inline void dec_zcache_pers_zpages(unsigned zpages)
-{
- zcache_pers_zpages = atomic_sub_return(zpages, &zcache_pers_zpages_atomic);
-}
+/* Used by debug.c */
+ssize_t zcache_pers_zpages;
+u64 zcache_pers_zbytes;
+ssize_t zcache_eph_pageframes;
+ssize_t zcache_pers_pageframes;
-static inline unsigned long curr_pageframes_count(void)
-{
- return zcache_pageframes_alloced -
- atomic_read(&zcache_pageframes_freed_atomic) -
- atomic_read(&zcache_eph_pageframes_atomic) -
- atomic_read(&zcache_pers_pageframes_atomic);
-};
-/* but for the rest of these, counting races are ok */
+/* Used by this code. */
static ssize_t zcache_flush_total;
static ssize_t zcache_flush_found;
static ssize_t zcache_flobj_total;
@@ -283,118 +162,6 @@ static ssize_t zcache_last_active_anon_pageframes;
static ssize_t zcache_last_inactive_anon_pageframes;
static ssize_t zcache_eph_nonactive_puts_ignored;
static ssize_t zcache_pers_nonactive_puts_ignored;
-
-#ifdef CONFIG_DEBUG_FS
-#include <linux/debugfs.h>
-#define zdfs debugfs_create_size_t
-#define zdfs64 debugfs_create_u64
-static int zcache_debugfs_init(void)
-{
- struct dentry *root = debugfs_create_dir("zcache", NULL);
- if (root == NULL)
- return -ENXIO;
-
- zdfs("obj_count", S_IRUGO, root, &zcache_obj_count);
- zdfs("obj_count_max", S_IRUGO, root, &zcache_obj_count_max);
- zdfs("objnode_count", S_IRUGO, root, &zcache_objnode_count);
- zdfs("objnode_count_max", S_IRUGO, root, &zcache_objnode_count_max);
- zdfs("flush_total", S_IRUGO, root, &zcache_flush_total);
- zdfs("flush_found", S_IRUGO, root, &zcache_flush_found);
- zdfs("flobj_total", S_IRUGO, root, &zcache_flobj_total);
- zdfs("flobj_found", S_IRUGO, root, &zcache_flobj_found);
- zdfs("failed_eph_puts", S_IRUGO, root, &zcache_failed_eph_puts);
- zdfs("failed_pers_puts", S_IRUGO, root, &zcache_failed_pers_puts);
- zdfs("failed_get_free_pages", S_IRUGO, root,
- &zcache_failed_getfreepages);
- zdfs("failed_alloc", S_IRUGO, root, &zcache_failed_alloc);
- zdfs("put_to_flush", S_IRUGO, root, &zcache_put_to_flush);
- zdfs("compress_poor", S_IRUGO, root, &zcache_compress_poor);
- zdfs("mean_compress_poor", S_IRUGO, root, &zcache_mean_compress_poor);
- zdfs("eph_ate_tail", S_IRUGO, root, &zcache_eph_ate_tail);
- zdfs("eph_ate_tail_failed", S_IRUGO, root, &zcache_eph_ate_tail_failed);
- zdfs("pers_ate_eph", S_IRUGO, root, &zcache_pers_ate_eph);
- zdfs("pers_ate_eph_failed", S_IRUGO, root, &zcache_pers_ate_eph_failed);
- zdfs("evicted_eph_zpages", S_IRUGO, root, &zcache_evicted_eph_zpages);
- zdfs("evicted_eph_pageframes", S_IRUGO, root,
- &zcache_evicted_eph_pageframes);
- zdfs("eph_pageframes", S_IRUGO, root, &zcache_eph_pageframes);
- zdfs("eph_pageframes_max", S_IRUGO, root, &zcache_eph_pageframes_max);
- zdfs("pers_pageframes", S_IRUGO, root, &zcache_pers_pageframes);
- zdfs("pers_pageframes_max", S_IRUGO, root, &zcache_pers_pageframes_max);
- zdfs("eph_zpages", S_IRUGO, root, &zcache_eph_zpages);
- zdfs("eph_zpages_max", S_IRUGO, root, &zcache_eph_zpages_max);
- zdfs("pers_zpages", S_IRUGO, root, &zcache_pers_zpages);
- zdfs("pers_zpages_max", S_IRUGO, root, &zcache_pers_zpages_max);
- zdfs("last_active_file_pageframes", S_IRUGO, root,
- &zcache_last_active_file_pageframes);
- zdfs("last_inactive_file_pageframes", S_IRUGO, root,
- &zcache_last_inactive_file_pageframes);
- zdfs("last_active_anon_pageframes", S_IRUGO, root,
- &zcache_last_active_anon_pageframes);
- zdfs("last_inactive_anon_pageframes", S_IRUGO, root,
- &zcache_last_inactive_anon_pageframes);
- zdfs("eph_nonactive_puts_ignored", S_IRUGO, root,
- &zcache_eph_nonactive_puts_ignored);
- zdfs("pers_nonactive_puts_ignored", S_IRUGO, root,
- &zcache_pers_nonactive_puts_ignored);
- zdfs64("eph_zbytes", S_IRUGO, root, &zcache_eph_zbytes);
- zdfs64("eph_zbytes_max", S_IRUGO, root, &zcache_eph_zbytes_max);
- zdfs64("pers_zbytes", S_IRUGO, root, &zcache_pers_zbytes);
- zdfs64("pers_zbytes_max", S_IRUGO, root, &zcache_pers_zbytes_max);
- return 0;
-}
-#undef zdebugfs
-#undef zdfs64
-#endif
-
-/* developers can call this in case of ooms, e.g. to find memory leaks */
-void zcache_dump(void)
-{
- pr_debug("zcache: obj_count=%u\n", zcache_obj_count);
- pr_debug("zcache: obj_count_max=%u\n", zcache_obj_count_max);
- pr_debug("zcache: objnode_count=%u\n", zcache_objnode_count);
- pr_debug("zcache: objnode_count_max=%u\n", zcache_objnode_count_max);
- pr_debug("zcache: flush_total=%u\n", zcache_flush_total);
- pr_debug("zcache: flush_found=%u\n", zcache_flush_found);
- pr_debug("zcache: flobj_total=%u\n", zcache_flobj_total);
- pr_debug("zcache: flobj_found=%u\n", zcache_flobj_found);
- pr_debug("zcache: failed_eph_puts=%u\n", zcache_failed_eph_puts);
- pr_debug("zcache: failed_pers_puts=%u\n", zcache_failed_pers_puts);
- pr_debug("zcache: failed_get_free_pages=%u\n",
- zcache_failed_getfreepages);
- pr_debug("zcache: failed_alloc=%u\n", zcache_failed_alloc);
- pr_debug("zcache: put_to_flush=%u\n", zcache_put_to_flush);
- pr_debug("zcache: compress_poor=%u\n", zcache_compress_poor);
- pr_debug("zcache: mean_compress_poor=%u\n",
- zcache_mean_compress_poor);
- pr_debug("zcache: eph_ate_tail=%u\n", zcache_eph_ate_tail);
- pr_debug("zcache: eph_ate_tail_failed=%u\n",
- zcache_eph_ate_tail_failed);
- pr_debug("zcache: pers_ate_eph=%u\n", zcache_pers_ate_eph);
- pr_debug("zcache: pers_ate_eph_failed=%u\n",
- zcache_pers_ate_eph_failed);
- pr_debug("zcache: evicted_eph_zpages=%u\n", zcache_evicted_eph_zpages);
- pr_debug("zcache: evicted_eph_pageframes=%u\n",
- zcache_evicted_eph_pageframes);
- pr_debug("zcache: eph_pageframes=%u\n", zcache_eph_pageframes);
- pr_debug("zcache: eph_pageframes_max=%u\n", zcache_eph_pageframes_max);
- pr_debug("zcache: pers_pageframes=%u\n", zcache_pers_pageframes);
- pr_debug("zcache: pers_pageframes_max=%u\n",
- zcache_pers_pageframes_max);
- pr_debug("zcache: eph_zpages=%u\n", zcache_eph_zpages);
- pr_debug("zcache: eph_zpages_max=%u\n", zcache_eph_zpages_max);
- pr_debug("zcache: pers_zpages=%u\n", zcache_pers_zpages);
- pr_debug("zcache: pers_zpages_max=%u\n", zcache_pers_zpages_max);
- pr_debug("zcache: eph_zbytes=%llu\n",
- (unsigned long long)zcache_eph_zbytes);
- pr_debug("zcache: eph_zbytes_max=%llu\n",
- (unsigned long long)zcache_eph_zbytes_max);
- pr_debug("zcache: pers_zbytes=%llu\n",
- (unsigned long long)zcache_pers_zbytes);
- pr_debug("zcache: pers_zbytes_max=%llu\n",
- (unsigned long long)zcache_pers_zbytes_max);
-}
-
/*
* zcache core code starts here
*/
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 09/11] zcache: Use an array to initialize/use debugfs attributes.
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (7 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 08/11] zcache: Move debugfs code out of zcache-main.c file Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 10/11] zcache: Move the last of the debugfs counters out Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 11/11] zcache: Coalesce all debug under CONFIG_ZCACHE2_DEBUG Konrad Rzeszutek Wilk
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
It makes it neater and also allows us to piggyback on that
in the zcache_dump function.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/debug.c | 141 +++++++++++++--------------------------
1 files changed, 47 insertions(+), 94 deletions(-)
diff --git a/drivers/staging/ramster/debug.c b/drivers/staging/ramster/debug.c
index 0d19715..3a252a5 100644
--- a/drivers/staging/ramster/debug.c
+++ b/drivers/staging/ramster/debug.c
@@ -3,111 +3,64 @@
#ifdef CONFIG_DEBUG_FS
#include <linux/debugfs.h>
-#define zdfs debugfs_create_size_t
-#define zdfs64 debugfs_create_u64
+
+#define ATTR(x) { .name = #x, .val = &zcache_##x, }
+static struct debug_entry {
+ const char *name;
+ ssize_t *val;
+} attrs[] = {
+ ATTR(obj_count), ATTR(obj_count_max),
+ ATTR(objnode_count), ATTR(objnode_count_max),
+ ATTR(flush_total), ATTR(flush_found),
+ ATTR(flobj_total), ATTR(flobj_found),
+ ATTR(failed_eph_puts), ATTR(failed_pers_puts),
+ ATTR(failed_getfreepages), ATTR(failed_alloc),
+ ATTR(put_to_flush),
+ ATTR(compress_poor), ATTR(mean_compress_poor),
+ ATTR(eph_ate_tail), ATTR(eph_ate_tail_failed),
+ ATTR(pers_ate_eph), ATTR(pers_ate_eph_failed),
+ ATTR(evicted_eph_zpages), ATTR(evicted_eph_pageframes),
+ ATTR(eph_pageframes), ATTR(eph_pageframes_max),
+ ATTR(eph_zpages), ATTR(eph_zpages_max),
+ ATTR(pers_zpages), ATTR(pers_zpages_max),
+ ATTR(last_active_file_pageframes),
+ ATTR(last_inactive_file_pageframes),
+ ATTR(last_active_anon_pageframes),
+ ATTR(last_inactive_anon_pageframes),
+ ATTR(eph_nonactive_puts_ignored),
+ ATTR(pers_nonactive_puts_ignored),
+};
+#undef ATTR
int zcache_debugfs_init(void)
{
+ unsigned int i;
struct dentry *root = debugfs_create_dir("zcache", NULL);
if (root == NULL)
return -ENXIO;
- zdfs("obj_count", S_IRUGO, root, &zcache_obj_count);
- zdfs("obj_count_max", S_IRUGO, root, &zcache_obj_count_max);
- zdfs("objnode_count", S_IRUGO, root, &zcache_objnode_count);
- zdfs("objnode_count_max", S_IRUGO, root, &zcache_objnode_count_max);
- zdfs("flush_total", S_IRUGO, root, &zcache_flush_total);
- zdfs("flush_found", S_IRUGO, root, &zcache_flush_found);
- zdfs("flobj_total", S_IRUGO, root, &zcache_flobj_total);
- zdfs("flobj_found", S_IRUGO, root, &zcache_flobj_found);
- zdfs("failed_eph_puts", S_IRUGO, root, &zcache_failed_eph_puts);
- zdfs("failed_pers_puts", S_IRUGO, root, &zcache_failed_pers_puts);
- zdfs("failed_get_free_pages", S_IRUGO, root,
- &zcache_failed_getfreepages);
- zdfs("failed_alloc", S_IRUGO, root, &zcache_failed_alloc);
- zdfs("put_to_flush", S_IRUGO, root, &zcache_put_to_flush);
- zdfs("compress_poor", S_IRUGO, root, &zcache_compress_poor);
- zdfs("mean_compress_poor", S_IRUGO, root, &zcache_mean_compress_poor);
- zdfs("eph_ate_tail", S_IRUGO, root, &zcache_eph_ate_tail);
- zdfs("eph_ate_tail_failed", S_IRUGO, root, &zcache_eph_ate_tail_failed);
- zdfs("pers_ate_eph", S_IRUGO, root, &zcache_pers_ate_eph);
- zdfs("pers_ate_eph_failed", S_IRUGO, root, &zcache_pers_ate_eph_failed);
- zdfs("evicted_eph_zpages", S_IRUGO, root, &zcache_evicted_eph_zpages);
- zdfs("evicted_eph_pageframes", S_IRUGO, root,
- &zcache_evicted_eph_pageframes);
- zdfs("eph_pageframes", S_IRUGO, root, &zcache_eph_pageframes);
- zdfs("eph_pageframes_max", S_IRUGO, root, &zcache_eph_pageframes_max);
- zdfs("pers_pageframes", S_IRUGO, root, &zcache_pers_pageframes);
- zdfs("pers_pageframes_max", S_IRUGO, root, &zcache_pers_pageframes_max);
- zdfs("eph_zpages", S_IRUGO, root, &zcache_eph_zpages);
- zdfs("eph_zpages_max", S_IRUGO, root, &zcache_eph_zpages_max);
- zdfs("pers_zpages", S_IRUGO, root, &zcache_pers_zpages);
- zdfs("pers_zpages_max", S_IRUGO, root, &zcache_pers_zpages_max);
- zdfs("last_active_file_pageframes", S_IRUGO, root,
- &zcache_last_active_file_pageframes);
- zdfs("last_inactive_file_pageframes", S_IRUGO, root,
- &zcache_last_inactive_file_pageframes);
- zdfs("last_active_anon_pageframes", S_IRUGO, root,
- &zcache_last_active_anon_pageframes);
- zdfs("last_inactive_anon_pageframes", S_IRUGO, root,
- &zcache_last_inactive_anon_pageframes);
- zdfs("eph_nonactive_puts_ignored", S_IRUGO, root,
- &zcache_eph_nonactive_puts_ignored);
- zdfs("pers_nonactive_puts_ignored", S_IRUGO, root,
- &zcache_pers_nonactive_puts_ignored);
- zdfs64("eph_zbytes", S_IRUGO, root, &zcache_eph_zbytes);
- zdfs64("eph_zbytes_max", S_IRUGO, root, &zcache_eph_zbytes_max);
- zdfs64("pers_zbytes", S_IRUGO, root, &zcache_pers_zbytes);
- zdfs64("pers_zbytes_max", S_IRUGO, root, &zcache_pers_zbytes_max);
+ for (i = 0; i < ARRAY_SIZE(attrs); i++)
+ if (!debugfs_create_size_t(attrs[i].name, S_IRUGO, root, attrs[i].val))
+ goto out;
+
+ debugfs_create_u64("eph_zbytes", S_IRUGO, root, &zcache_eph_zbytes);
+ debugfs_create_u64("eph_zbytes_max", S_IRUGO, root, &zcache_eph_zbytes_max);
+ debugfs_create_u64("pers_zbytes", S_IRUGO, root, &zcache_pers_zbytes);
+ debugfs_create_u64("pers_zbytes_max", S_IRUGO, root, &zcache_pers_zbytes_max);
return 0;
+out:
+ return -ENODEV;
}
-#undef zdebugfs
-#undef zdfs64
/* developers can call this in case of ooms, e.g. to find memory leaks */
void zcache_dump(void)
{
- pr_debug("zcache: obj_count=%u\n", zcache_obj_count);
- pr_debug("zcache: obj_count_max=%u\n", zcache_obj_count_max);
- pr_debug("zcache: objnode_count=%u\n", zcache_objnode_count);
- pr_debug("zcache: objnode_count_max=%u\n", zcache_objnode_count_max);
- pr_debug("zcache: flush_total=%u\n", zcache_flush_total);
- pr_debug("zcache: flush_found=%u\n", zcache_flush_found);
- pr_debug("zcache: flobj_total=%u\n", zcache_flobj_total);
- pr_debug("zcache: flobj_found=%u\n", zcache_flobj_found);
- pr_debug("zcache: failed_eph_puts=%u\n", zcache_failed_eph_puts);
- pr_debug("zcache: failed_pers_puts=%u\n", zcache_failed_pers_puts);
- pr_debug("zcache: failed_get_free_pages=%u\n",
- zcache_failed_getfreepages);
- pr_debug("zcache: failed_alloc=%u\n", zcache_failed_alloc);
- pr_debug("zcache: put_to_flush=%u\n", zcache_put_to_flush);
- pr_debug("zcache: compress_poor=%u\n", zcache_compress_poor);
- pr_debug("zcache: mean_compress_poor=%u\n",
- zcache_mean_compress_poor);
- pr_debug("zcache: eph_ate_tail=%u\n", zcache_eph_ate_tail);
- pr_debug("zcache: eph_ate_tail_failed=%u\n",
- zcache_eph_ate_tail_failed);
- pr_debug("zcache: pers_ate_eph=%u\n", zcache_pers_ate_eph);
- pr_debug("zcache: pers_ate_eph_failed=%u\n",
- zcache_pers_ate_eph_failed);
- pr_debug("zcache: evicted_eph_zpages=%u\n", zcache_evicted_eph_zpages);
- pr_debug("zcache: evicted_eph_pageframes=%u\n",
- zcache_evicted_eph_pageframes);
- pr_debug("zcache: eph_pageframes=%u\n", zcache_eph_pageframes);
- pr_debug("zcache: eph_pageframes_max=%u\n", zcache_eph_pageframes_max);
- pr_debug("zcache: pers_pageframes=%u\n", zcache_pers_pageframes);
- pr_debug("zcache: pers_pageframes_max=%u\n",
- zcache_pers_pageframes_max);
- pr_debug("zcache: eph_zpages=%u\n", zcache_eph_zpages);
- pr_debug("zcache: eph_zpages_max=%u\n", zcache_eph_zpages_max);
- pr_debug("zcache: pers_zpages=%u\n", zcache_pers_zpages);
- pr_debug("zcache: pers_zpages_max=%u\n", zcache_pers_zpages_max);
- pr_debug("zcache: eph_zbytes=%llu\n",
- (unsigned long long)zcache_eph_zbytes);
- pr_debug("zcache: eph_zbytes_max=%llu\n",
- (unsigned long long)zcache_eph_zbytes_max);
- pr_debug("zcache: pers_zbytes=%llu\n",
- (unsigned long long)zcache_pers_zbytes);
- pr_debug("zcache: pers_zbytes_max=%llu\n",
- (unsigned long long)zcache_pers_zbytes_max);
+ unsigned int i;
+ for (i = 0; i < ARRAY_SIZE(attrs); i++)
+ pr_debug("zcache: %s=%u\n", attrs[i].name, *attrs[i].val);
+
+ pr_debug("zcache: eph_zbytes=%llu\n", (unsigned long long)zcache_eph_zbytes);
+ pr_debug("zcache: eph_zbytes_max=%llu\n", (unsigned long long)zcache_eph_zbytes_max);
+ pr_debug("zcache: pers_zbytes=%llu\n", (unsigned long long)zcache_pers_zbytes);
+ pr_debug("zcache: pers_zbytes_max=%llu\n", (unsigned long long)zcache_pers_zbytes_max);
}
#endif
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 10/11] zcache: Move the last of the debugfs counters out
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (8 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 09/11] zcache: Use an array to initialize/use debugfs attributes Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
2012-11-05 14:37 ` [PATCH 11/11] zcache: Coalesce all debug under CONFIG_ZCACHE2_DEBUG Konrad Rzeszutek Wilk
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
We now have in zcache-main only the counters that are
are not debugfs related.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/debug.h | 80 +++++++++++++++++++++++++--------
drivers/staging/ramster/zcache-main.c | 71 +++++++++++------------------
2 files changed, 87 insertions(+), 64 deletions(-)
diff --git a/drivers/staging/ramster/debug.h b/drivers/staging/ramster/debug.h
index 496735b..35af06d 100644
--- a/drivers/staging/ramster/debug.h
+++ b/drivers/staging/ramster/debug.h
@@ -128,29 +128,51 @@ static inline unsigned long curr_pageframes_count(void)
atomic_read(&zcache_pers_pageframes_atomic);
};
/* but for the rest of these, counting races are ok */
-extern ssize_t zcache_flush_total;
-extern ssize_t zcache_flush_found;
-extern ssize_t zcache_flobj_total;
-extern ssize_t zcache_flobj_found;
-extern ssize_t zcache_failed_eph_puts;
-extern ssize_t zcache_failed_pers_puts;
-extern ssize_t zcache_failed_getfreepages;
-extern ssize_t zcache_failed_alloc;
-extern ssize_t zcache_put_to_flush;
-extern ssize_t zcache_compress_poor;
-extern ssize_t zcache_mean_compress_poor;
-extern ssize_t zcache_eph_ate_tail;
-extern ssize_t zcache_eph_ate_tail_failed;
-extern ssize_t zcache_pers_ate_eph;
-extern ssize_t zcache_pers_ate_eph_failed;
-extern ssize_t zcache_evicted_eph_zpages;
-extern ssize_t zcache_evicted_eph_pageframes;
+static ssize_t zcache_flush_total;
+static ssize_t zcache_flush_found;
+static ssize_t zcache_flobj_total;
+static ssize_t zcache_flobj_found;
+static ssize_t zcache_failed_eph_puts;
+static ssize_t zcache_failed_pers_puts;
+static ssize_t zcache_failed_getfreepages;
+static ssize_t zcache_failed_alloc;
+static ssize_t zcache_put_to_flush;
+static ssize_t zcache_compress_poor;
+static ssize_t zcache_mean_compress_poor;
+static ssize_t zcache_eph_ate_tail;
+static ssize_t zcache_eph_ate_tail_failed;
+static ssize_t zcache_pers_ate_eph;
+static ssize_t zcache_pers_ate_eph_failed;
+static ssize_t zcache_evicted_eph_zpages;
+static ssize_t zcache_evicted_eph_pageframes;
+
extern ssize_t zcache_last_active_file_pageframes;
extern ssize_t zcache_last_inactive_file_pageframes;
extern ssize_t zcache_last_active_anon_pageframes;
extern ssize_t zcache_last_inactive_anon_pageframes;
-extern ssize_t zcache_eph_nonactive_puts_ignored;
-extern ssize_t zcache_pers_nonactive_puts_ignored;
+static ssize_t zcache_eph_nonactive_puts_ignored;
+static ssize_t zcache_pers_nonactive_puts_ignored;
+
+static inline void inc_zcache_flush_total(void) { zcache_flush_total ++; };
+static inline void inc_zcache_flush_found(void) { zcache_flush_found ++; };
+static inline void inc_zcache_flobj_total(void) { zcache_flobj_total ++; };
+static inline void inc_zcache_flobj_found(void) { zcache_flobj_found ++; };
+static inline void inc_zcache_failed_eph_puts(void) { zcache_failed_eph_puts ++; };
+static inline void inc_zcache_failed_pers_puts(void) { zcache_failed_pers_puts ++; };
+static inline void inc_zcache_failed_getfreepages(void) { zcache_failed_getfreepages ++; };
+static inline void inc_zcache_failed_alloc(void) { zcache_failed_alloc ++; };
+static inline void inc_zcache_put_to_flush(void) { zcache_put_to_flush ++; };
+static inline void inc_zcache_compress_poor(void) { zcache_compress_poor ++; };
+static inline void inc_zcache_mean_compress_poor(void) { zcache_mean_compress_poor ++; };
+static inline void inc_zcache_eph_ate_tail(void) { zcache_eph_ate_tail ++; };
+static inline void inc_zcache_eph_ate_tail_failed(void) { zcache_eph_ate_tail_failed ++; };
+static inline void inc_zcache_pers_ate_eph(void) { zcache_pers_ate_eph ++; };
+static inline void inc_zcache_pers_ate_eph_failed(void) { zcache_pers_ate_eph_failed ++; };
+static inline void inc_zcache_evicted_eph_zpages(void) { zcache_evicted_eph_zpages ++; };
+static inline void inc_zcache_evicted_eph_pageframes(void) { zcache_evicted_eph_pageframes ++; };
+
+static inline void inc_zcache_eph_nonactive_puts_ignored(void) { zcache_eph_nonactive_puts_ignored ++; };
+static inline void inc_zcache_pers_nonactive_puts_ignored(void) { zcache_pers_nonactive_puts_ignored ++; };
int zcache_debugfs_init(void);
#else
@@ -180,4 +202,24 @@ static inline int zcache_debugfs_init(void)
{
return 0;
};
+static inline void inc_zcache_flush_total(void) { };
+static inline void inc_zcache_flush_found(void) { };
+static inline void inc_zcache_flobj_total(void) { };
+static inline void inc_zcache_flobj_found(void) { };
+static inline void inc_zcache_failed_eph_puts(void) { };
+static inline void inc_zcache_failed_pers_puts(void) { };
+static inline void inc_zcache_failed_getfreepages(void) { };
+static inline void inc_zcache_failed_alloc(void) { };
+static inline void inc_zcache_put_to_flush(void) { };
+static inline void inc_zcache_compress_poor(void) { };
+static inline void inc_zcache_mean_compress_poor(void) { };
+static inline void inc_zcache_eph_ate_tail(void) { };
+static inline void inc_zcache_eph_ate_tail_failed(void) { };
+static inline void inc_zcache_pers_ate_eph(void) { };
+static inline void inc_zcache_pers_ate_eph_failed(void) { };
+static inline void inc_zcache_evicted_eph_zpages(void) { };
+static inline void inc_zcache_evicted_eph_pageframes(void) { };
+
+static inline void inc_zcache_eph_nonactive_puts_ignored(void) { };
+static inline void inc_zcache_pers_nonactive_puts_ignored(void) { };
#endif
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index 013bfa4..d91868d 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -139,29 +139,10 @@ ssize_t zcache_eph_pageframes;
ssize_t zcache_pers_pageframes;
/* Used by this code. */
-static ssize_t zcache_flush_total;
-static ssize_t zcache_flush_found;
-static ssize_t zcache_flobj_total;
-static ssize_t zcache_flobj_found;
-static ssize_t zcache_failed_eph_puts;
-static ssize_t zcache_failed_pers_puts;
-static ssize_t zcache_failed_getfreepages;
-static ssize_t zcache_failed_alloc;
-static ssize_t zcache_put_to_flush;
-static ssize_t zcache_compress_poor;
-static ssize_t zcache_mean_compress_poor;
-static ssize_t zcache_eph_ate_tail;
-static ssize_t zcache_eph_ate_tail_failed;
-static ssize_t zcache_pers_ate_eph;
-static ssize_t zcache_pers_ate_eph_failed;
-static ssize_t zcache_evicted_eph_zpages;
-static ssize_t zcache_evicted_eph_pageframes;
-static ssize_t zcache_last_active_file_pageframes;
-static ssize_t zcache_last_inactive_file_pageframes;
-static ssize_t zcache_last_active_anon_pageframes;
-static ssize_t zcache_last_inactive_anon_pageframes;
-static ssize_t zcache_eph_nonactive_puts_ignored;
-static ssize_t zcache_pers_nonactive_puts_ignored;
+ssize_t zcache_last_active_file_pageframes;
+ssize_t zcache_last_inactive_file_pageframes;
+ssize_t zcache_last_active_anon_pageframes;
+ssize_t zcache_last_inactive_anon_pageframes;
/*
* zcache core code starts here
*/
@@ -354,7 +335,7 @@ static void *zcache_pampd_eph_create(char *data, size_t size, bool raw,
if (!raw) {
zcache_compress(page, &cdata, &clen);
if (clen > zbud_max_buddy_size()) {
- zcache_compress_poor++;
+ inc_zcache_compress_poor();
goto out;
}
} else {
@@ -371,14 +352,14 @@ static void *zcache_pampd_eph_create(char *data, size_t size, bool raw,
if (newpage != NULL)
goto create_in_new_page;
- zcache_failed_getfreepages++;
+ inc_zcache_failed_getfreepages();
/* can't allocate a page, evict an ephemeral page via LRU */
newpage = zcache_evict_eph_pageframe();
if (newpage == NULL) {
- zcache_eph_ate_tail_failed++;
+ inc_zcache_eph_ate_tail_failed();
goto out;
}
- zcache_eph_ate_tail++;
+ inc_zcache_eph_ate_tail();
create_in_new_page:
pampd = (void *)zbud_create_prep(th, true, cdata, clen, newpage);
@@ -413,7 +394,7 @@ static void *zcache_pampd_pers_create(char *data, size_t size, bool raw,
zcache_compress(page, &cdata, &clen);
/* reject if compression is too poor */
if (clen > zbud_max_zsize) {
- zcache_compress_poor++;
+ inc_zcache_compress_poor();
goto out;
}
/* reject if mean compression is too poor */
@@ -424,7 +405,7 @@ static void *zcache_pampd_pers_create(char *data, size_t size, bool raw,
zbud_mean_zsize = div_u64(total_zsize,
curr_pers_zpages);
if (zbud_mean_zsize > zbud_max_mean_zsize) {
- zcache_mean_compress_poor++;
+ inc_zcache_mean_compress_poor();
goto out;
}
}
@@ -445,14 +426,14 @@ create_pampd:
* (global_page_state(NR_LRU_BASE + LRU_ACTIVE_FILE) +
* global_page_state(NR_LRU_BASE + LRU_INACTIVE_FILE)))
*/
- zcache_failed_getfreepages++;
+ inc_zcache_failed_getfreepages();
/* can't allocate a page, evict an ephemeral page via LRU */
newpage = zcache_evict_eph_pageframe();
if (newpage == NULL) {
- zcache_pers_ate_eph_failed++;
+ inc_zcache_pers_ate_eph_failed();
goto out;
}
- zcache_pers_ate_eph++;
+ inc_zcache_pers_ate_eph();
create_in_new_page:
pampd = (void *)zbud_create_prep(th, false, cdata, clen, newpage);
@@ -492,7 +473,7 @@ void *zcache_pampd_create(char *data, unsigned int size, bool raw,
objnode = kmem_cache_alloc(zcache_objnode_cache,
ZCACHE_GFP_MASK);
if (unlikely(objnode == NULL)) {
- zcache_failed_alloc++;
+ inc_zcache_failed_alloc();
goto out;
}
kp->objnodes[i] = objnode;
@@ -503,7 +484,7 @@ void *zcache_pampd_create(char *data, unsigned int size, bool raw,
kp->obj = obj;
}
if (unlikely(kp->obj == NULL)) {
- zcache_failed_alloc++;
+ inc_zcache_failed_alloc();
goto out;
}
/*
@@ -781,9 +762,9 @@ static struct page *zcache_evict_eph_pageframe(void)
goto out;
dec_zcache_eph_zbytes(zsize);
dec_zcache_eph_zpages(zpages);
- zcache_evicted_eph_zpages++;
+ inc_zcache_evicted_eph_zpages();
dec_zcache_eph_pageframes();
- zcache_evicted_eph_pageframes++;
+ inc_zcache_evicted_eph_pageframes();
out:
return page;
}
@@ -976,9 +957,9 @@ int zcache_put_page(int cli_id, int pool_id, struct tmem_oid *oidp,
if (pampd == NULL) {
ret = -ENOMEM;
if (ephemeral)
- zcache_failed_eph_puts++;
+ inc_zcache_failed_eph_puts();
else
- zcache_failed_pers_puts++;
+ inc_zcache_failed_pers_puts();
} else {
if (ramster_enabled)
ramster_do_preload_flnode(pool);
@@ -988,7 +969,7 @@ int zcache_put_page(int cli_id, int pool_id, struct tmem_oid *oidp,
}
zcache_put_pool(pool);
} else {
- zcache_put_to_flush++;
+ inc_zcache_put_to_flush();
if (ramster_enabled)
ramster_do_preload_flnode(pool);
if (atomic_read(&pool->obj_count) > 0)
@@ -1038,7 +1019,7 @@ int zcache_flush_page(int cli_id, int pool_id,
unsigned long flags;
local_irq_save(flags);
- zcache_flush_total++;
+ inc_zcache_flush_total();
pool = zcache_get_pool_by_id(cli_id, pool_id);
if (ramster_enabled)
ramster_do_preload_flnode(pool);
@@ -1048,7 +1029,7 @@ int zcache_flush_page(int cli_id, int pool_id,
zcache_put_pool(pool);
}
if (ret >= 0)
- zcache_flush_found++;
+ inc_zcache_flush_found();
local_irq_restore(flags);
return ret;
}
@@ -1061,7 +1042,7 @@ int zcache_flush_object(int cli_id, int pool_id,
unsigned long flags;
local_irq_save(flags);
- zcache_flobj_total++;
+ inc_zcache_flobj_total();
pool = zcache_get_pool_by_id(cli_id, pool_id);
if (ramster_enabled)
ramster_do_preload_flnode(pool);
@@ -1071,7 +1052,7 @@ int zcache_flush_object(int cli_id, int pool_id,
zcache_put_pool(pool);
}
if (ret >= 0)
- zcache_flobj_found++;
+ inc_zcache_flobj_found();
local_irq_restore(flags);
return ret;
}
@@ -1237,7 +1218,7 @@ static void zcache_cleancache_put_page(int pool_id,
struct tmem_oid oid = *(struct tmem_oid *)&key;
if (!disable_cleancache_ignore_nonactive && !PageWasActive(page)) {
- zcache_eph_nonactive_puts_ignored++;
+ inc_zcache_eph_nonactive_puts_ignored();
return;
}
if (likely(ind == index))
@@ -1366,7 +1347,7 @@ static int zcache_frontswap_put_page(unsigned type, pgoff_t offset,
BUG_ON(!PageLocked(page));
if (!disable_frontswap_ignore_nonactive && !PageWasActive(page)) {
- zcache_pers_nonactive_puts_ignored++;
+ inc_zcache_pers_nonactive_puts_ignored();
ret = -ERANGE;
goto out;
}
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread* [PATCH 11/11] zcache: Coalesce all debug under CONFIG_ZCACHE2_DEBUG
2012-11-05 14:37 [RFC PATCH] zcache2 cleanups (s/int/bool + debugfs movement) Konrad Rzeszutek Wilk
` (9 preceding siblings ...)
2012-11-05 14:37 ` [PATCH 10/11] zcache: Move the last of the debugfs counters out Konrad Rzeszutek Wilk
@ 2012-11-05 14:37 ` Konrad Rzeszutek Wilk
10 siblings, 0 replies; 13+ messages in thread
From: Konrad Rzeszutek Wilk @ 2012-11-05 14:37 UTC (permalink / raw)
To: linux-kernel, sjenning, dan.magenheimer, ngupta, minchan, rcj,
linux-mm, gregkh, devel
Cc: akpm, Konrad Rzeszutek Wilk
and also define this extra attribute in the Kconfig entry.
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
---
drivers/staging/ramster/Kconfig | 8 ++++++++
drivers/staging/ramster/Makefile | 2 +-
drivers/staging/ramster/debug.h | 2 +-
drivers/staging/ramster/zcache-main.c | 8 +++-----
4 files changed, 13 insertions(+), 7 deletions(-)
diff --git a/drivers/staging/ramster/Kconfig b/drivers/staging/ramster/Kconfig
index 9ce2590..24c8704 100644
--- a/drivers/staging/ramster/Kconfig
+++ b/drivers/staging/ramster/Kconfig
@@ -15,6 +15,14 @@ config ZCACHE2
again in the future. Until then, zcache2 is a single-node
version of ramster.
+config ZCACHE2_DEBUG
+ bool "Enable debug statistics"
+ depends on DEBUG_FS && ZCACHE2
+ default n
+ help
+ This is used to provide an debugfs directory with counters of
+ how zcache2 is doing. You probably want to set this to 'N'.
+
config RAMSTER
tristate "Cross-machine RAM capacity sharing, aka peer-to-peer tmem"
depends on CONFIGFS_FS && SYSFS && !HIGHMEM && ZCACHE2
diff --git a/drivers/staging/ramster/Makefile b/drivers/staging/ramster/Makefile
index 61f5050..d341a23 100644
--- a/drivers/staging/ramster/Makefile
+++ b/drivers/staging/ramster/Makefile
@@ -4,5 +4,5 @@ zcache-y += ramster/ramster.o ramster/r2net.o
zcache-y += ramster/nodemanager.o ramster/tcp.o
zcache-y += ramster/heartbeat.o ramster/masklog.o
endif
-zcache-y-$(CONFIG_ZCACHE_DEBUG) += debug.o
+zcache-y-$(CONFIG_ZCACHE2_DEBUG) += debug.o
obj-$(CONFIG_MODULES) += zcache.o
diff --git a/drivers/staging/ramster/debug.h b/drivers/staging/ramster/debug.h
index 35af06d..51e3d74 100644
--- a/drivers/staging/ramster/debug.h
+++ b/drivers/staging/ramster/debug.h
@@ -1,4 +1,4 @@
-#ifdef CONFIG_ZCACHE_DEBUG
+#ifdef CONFIG_ZCACHE2_DEBUG
/* we try to keep these statistics SMP-consistent */
static ssize_t zcache_obj_count;
diff --git a/drivers/staging/ramster/zcache-main.c b/drivers/staging/ramster/zcache-main.c
index d91868d..d58341a 100644
--- a/drivers/staging/ramster/zcache-main.c
+++ b/drivers/staging/ramster/zcache-main.c
@@ -308,7 +308,7 @@ static void zcache_free_page(struct page *page)
max_pageframes = curr_pageframes;
if (curr_pageframes < min_pageframes)
min_pageframes = curr_pageframes;
-#ifdef ZCACHE_DEBUG
+#ifdef CONFIG_ZCACHE2_DEBUG
if (curr_pageframes > 2L || curr_pageframes < -2L) {
/* pr_info here */
}
@@ -1561,9 +1561,7 @@ static int zcache_init(void)
namestr = "ramster";
ramster_register_pamops(&zcache_pamops);
}
-#ifdef CONFIG_DEBUG_FS
zcache_debugfs_init();
-#endif
if (zcache_enabled) {
unsigned int cpu;
@@ -1603,7 +1601,7 @@ static int zcache_init(void)
old_ops = zcache_cleancache_register_ops();
pr_info("%s: cleancache enabled using kernel transcendent "
"memory and compression buddies\n", namestr);
-#ifdef ZCACHE_DEBUG
+#ifdef CONFIG_ZCACHE2_DEBUG
pr_info("%s: cleancache: ignorenonactive = %d\n",
namestr, !disable_cleancache_ignore_nonactive);
#endif
@@ -1618,7 +1616,7 @@ static int zcache_init(void)
frontswap_tmem_exclusive_gets(true);
pr_info("%s: frontswap enabled using kernel transcendent "
"memory and compression buddies\n", namestr);
-#ifdef ZCACHE_DEBUG
+#ifdef CONFIG_ZCACHE2_DEBUG
pr_info("%s: frontswap: excl gets = %d active only = %d\n",
namestr, frontswap_has_exclusive_gets,
!disable_frontswap_ignore_nonactive);
--
1.7.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related [flat|nested] 13+ messages in thread