mm/page_owner: keep track of page owners
This is the page owner tracking code which is introduced so far ago. It
is resident on Andrew's tree, though, nobody tried to upstream so it
remain as is. Our company uses this feature actively to debug memory leak
or to find a memory hogger so I decide to upstream this feature.
This functionality help us to know who allocates the page. When
allocating a page, we store some information about allocation in extra
memory. Later, if we need to know status of all pages, we can get and
analyze it from this stored information.
In previous version of this feature, extra memory is statically defined in
struct page, but, in this version, extra memory is allocated outside of
struct page. It enables us to turn on/off this feature at boottime
without considerable memory waste.
Although we already have tracepoint for tracing page allocation/free,
using it to analyze page owner is rather complex. We need to enlarge the
trace buffer for preventing overlapping until userspace program launched.
And, launched program continually dump out the trace buffer for later
analysis and it would change system behaviour with more possibility rather
than just keeping it in memory, so bad for debug.
Moreover, we can use page_owner feature further for various purposes. For
example, we can use it for fragmentation statistics implemented in this
patch. And, I also plan to implement some CMA failure debugging feature
using this interface.
I'd like to give the credit for all developers contributed this feature,
but, it's not easy because I don't know exact history. Sorry about that.
Below is people who has "Signed-off-by" in the patches in Andrew's tree.
Contributor:
Alexander Nyberg <alexn@dsv.su.se>
Mel Gorman <mgorman@suse.de>
Dave Hansen <dave@linux.vnet.ibm.com>
Minchan Kim <minchan@kernel.org>
Michal Nazarewicz <mina86@mina86.com>
Andrew Morton <akpm@linux-foundation.org>
Jungsoo Son <jungsoo.son@lge.com>
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Dave Hansen <dave@sr71.net>
Cc: Michal Nazarewicz <mina86@mina86.com>
Cc: Jungsoo Son <jungsoo.son@lge.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 01:56:01 +01:00
|
|
|
/*
|
|
|
|
* User-space helper to sort the output of /sys/kernel/debug/page_owner
|
|
|
|
*
|
|
|
|
* Example use:
|
|
|
|
* cat /sys/kernel/debug/page_owner > page_owner_full.txt
|
|
|
|
* grep -v ^PFN page_owner_full.txt > page_owner.txt
|
|
|
|
* ./sort page_owner.txt sorted_page_owner.txt
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
struct block_list {
|
|
|
|
char *txt;
|
|
|
|
int len;
|
|
|
|
int num;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static struct block_list *list;
|
|
|
|
static int list_size;
|
|
|
|
static int max_size;
|
|
|
|
|
|
|
|
struct block_list *block_head;
|
|
|
|
|
|
|
|
int read_block(char *buf, int buf_size, FILE *fin)
|
|
|
|
{
|
|
|
|
char *curr = buf, *const buf_end = buf + buf_size;
|
|
|
|
|
|
|
|
while (buf_end - curr > 1 && fgets(curr, buf_end - curr, fin)) {
|
|
|
|
if (*curr == '\n') /* empty line */
|
|
|
|
return curr - buf;
|
|
|
|
curr += strlen(curr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1; /* EOF or no space left in buf. */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_txt(const void *p1, const void *p2)
|
|
|
|
{
|
|
|
|
const struct block_list *l1 = p1, *l2 = p2;
|
|
|
|
|
|
|
|
return strcmp(l1->txt, l2->txt);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int compare_num(const void *p1, const void *p2)
|
|
|
|
{
|
|
|
|
const struct block_list *l1 = p1, *l2 = p2;
|
|
|
|
|
|
|
|
return l2->num - l1->num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void add_list(char *buf, int len)
|
|
|
|
{
|
|
|
|
if (list_size != 0 &&
|
|
|
|
len == list[list_size-1].len &&
|
|
|
|
memcmp(buf, list[list_size-1].txt, len) == 0) {
|
|
|
|
list[list_size-1].num++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (list_size == max_size) {
|
|
|
|
printf("max_size too small??\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
list[list_size].txt = malloc(len+1);
|
|
|
|
list[list_size].len = len;
|
|
|
|
list[list_size].num = 1;
|
|
|
|
memcpy(list[list_size].txt, buf, len);
|
|
|
|
list[list_size].txt[len] = 0;
|
|
|
|
list_size++;
|
|
|
|
if (list_size % 1000 == 0) {
|
|
|
|
printf("loaded %d\r", list_size);
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-27 00:23:52 +02:00
|
|
|
#define BUF_SIZE (128 * 1024)
|
mm/page_owner: keep track of page owners
This is the page owner tracking code which is introduced so far ago. It
is resident on Andrew's tree, though, nobody tried to upstream so it
remain as is. Our company uses this feature actively to debug memory leak
or to find a memory hogger so I decide to upstream this feature.
This functionality help us to know who allocates the page. When
allocating a page, we store some information about allocation in extra
memory. Later, if we need to know status of all pages, we can get and
analyze it from this stored information.
In previous version of this feature, extra memory is statically defined in
struct page, but, in this version, extra memory is allocated outside of
struct page. It enables us to turn on/off this feature at boottime
without considerable memory waste.
Although we already have tracepoint for tracing page allocation/free,
using it to analyze page owner is rather complex. We need to enlarge the
trace buffer for preventing overlapping until userspace program launched.
And, launched program continually dump out the trace buffer for later
analysis and it would change system behaviour with more possibility rather
than just keeping it in memory, so bad for debug.
Moreover, we can use page_owner feature further for various purposes. For
example, we can use it for fragmentation statistics implemented in this
patch. And, I also plan to implement some CMA failure debugging feature
using this interface.
I'd like to give the credit for all developers contributed this feature,
but, it's not easy because I don't know exact history. Sorry about that.
Below is people who has "Signed-off-by" in the patches in Andrew's tree.
Contributor:
Alexander Nyberg <alexn@dsv.su.se>
Mel Gorman <mgorman@suse.de>
Dave Hansen <dave@linux.vnet.ibm.com>
Minchan Kim <minchan@kernel.org>
Michal Nazarewicz <mina86@mina86.com>
Andrew Morton <akpm@linux-foundation.org>
Jungsoo Son <jungsoo.son@lge.com>
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Dave Hansen <dave@sr71.net>
Cc: Michal Nazarewicz <mina86@mina86.com>
Cc: Jungsoo Son <jungsoo.son@lge.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 01:56:01 +01:00
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
FILE *fin, *fout;
|
2016-07-27 00:23:52 +02:00
|
|
|
char *buf;
|
mm/page_owner: keep track of page owners
This is the page owner tracking code which is introduced so far ago. It
is resident on Andrew's tree, though, nobody tried to upstream so it
remain as is. Our company uses this feature actively to debug memory leak
or to find a memory hogger so I decide to upstream this feature.
This functionality help us to know who allocates the page. When
allocating a page, we store some information about allocation in extra
memory. Later, if we need to know status of all pages, we can get and
analyze it from this stored information.
In previous version of this feature, extra memory is statically defined in
struct page, but, in this version, extra memory is allocated outside of
struct page. It enables us to turn on/off this feature at boottime
without considerable memory waste.
Although we already have tracepoint for tracing page allocation/free,
using it to analyze page owner is rather complex. We need to enlarge the
trace buffer for preventing overlapping until userspace program launched.
And, launched program continually dump out the trace buffer for later
analysis and it would change system behaviour with more possibility rather
than just keeping it in memory, so bad for debug.
Moreover, we can use page_owner feature further for various purposes. For
example, we can use it for fragmentation statistics implemented in this
patch. And, I also plan to implement some CMA failure debugging feature
using this interface.
I'd like to give the credit for all developers contributed this feature,
but, it's not easy because I don't know exact history. Sorry about that.
Below is people who has "Signed-off-by" in the patches in Andrew's tree.
Contributor:
Alexander Nyberg <alexn@dsv.su.se>
Mel Gorman <mgorman@suse.de>
Dave Hansen <dave@linux.vnet.ibm.com>
Minchan Kim <minchan@kernel.org>
Michal Nazarewicz <mina86@mina86.com>
Andrew Morton <akpm@linux-foundation.org>
Jungsoo Son <jungsoo.son@lge.com>
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Dave Hansen <dave@sr71.net>
Cc: Michal Nazarewicz <mina86@mina86.com>
Cc: Jungsoo Son <jungsoo.son@lge.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 01:56:01 +01:00
|
|
|
int ret, i, count;
|
|
|
|
struct block_list *list2;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (argc < 3) {
|
|
|
|
printf("Usage: ./program <input> <output>\n");
|
|
|
|
perror("open: ");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
fin = fopen(argv[1], "r");
|
|
|
|
fout = fopen(argv[2], "w");
|
|
|
|
if (!fin || !fout) {
|
|
|
|
printf("Usage: ./program <input> <output>\n");
|
|
|
|
perror("open: ");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
fstat(fileno(fin), &st);
|
|
|
|
max_size = st.st_size / 100; /* hack ... */
|
|
|
|
|
|
|
|
list = malloc(max_size * sizeof(*list));
|
2016-07-27 00:23:52 +02:00
|
|
|
buf = malloc(BUF_SIZE);
|
|
|
|
if (!list || !buf) {
|
|
|
|
printf("Out of memory\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
mm/page_owner: keep track of page owners
This is the page owner tracking code which is introduced so far ago. It
is resident on Andrew's tree, though, nobody tried to upstream so it
remain as is. Our company uses this feature actively to debug memory leak
or to find a memory hogger so I decide to upstream this feature.
This functionality help us to know who allocates the page. When
allocating a page, we store some information about allocation in extra
memory. Later, if we need to know status of all pages, we can get and
analyze it from this stored information.
In previous version of this feature, extra memory is statically defined in
struct page, but, in this version, extra memory is allocated outside of
struct page. It enables us to turn on/off this feature at boottime
without considerable memory waste.
Although we already have tracepoint for tracing page allocation/free,
using it to analyze page owner is rather complex. We need to enlarge the
trace buffer for preventing overlapping until userspace program launched.
And, launched program continually dump out the trace buffer for later
analysis and it would change system behaviour with more possibility rather
than just keeping it in memory, so bad for debug.
Moreover, we can use page_owner feature further for various purposes. For
example, we can use it for fragmentation statistics implemented in this
patch. And, I also plan to implement some CMA failure debugging feature
using this interface.
I'd like to give the credit for all developers contributed this feature,
but, it's not easy because I don't know exact history. Sorry about that.
Below is people who has "Signed-off-by" in the patches in Andrew's tree.
Contributor:
Alexander Nyberg <alexn@dsv.su.se>
Mel Gorman <mgorman@suse.de>
Dave Hansen <dave@linux.vnet.ibm.com>
Minchan Kim <minchan@kernel.org>
Michal Nazarewicz <mina86@mina86.com>
Andrew Morton <akpm@linux-foundation.org>
Jungsoo Son <jungsoo.son@lge.com>
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Dave Hansen <dave@sr71.net>
Cc: Michal Nazarewicz <mina86@mina86.com>
Cc: Jungsoo Son <jungsoo.son@lge.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-12-13 01:56:01 +01:00
|
|
|
|
|
|
|
for ( ; ; ) {
|
|
|
|
ret = read_block(buf, BUF_SIZE, fin);
|
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
add_list(buf, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("loaded %d\n", list_size);
|
|
|
|
|
|
|
|
printf("sorting ....\n");
|
|
|
|
|
|
|
|
qsort(list, list_size, sizeof(list[0]), compare_txt);
|
|
|
|
|
|
|
|
list2 = malloc(sizeof(*list) * list_size);
|
|
|
|
|
|
|
|
printf("culling\n");
|
|
|
|
|
|
|
|
for (i = count = 0; i < list_size; i++) {
|
|
|
|
if (count == 0 ||
|
|
|
|
strcmp(list2[count-1].txt, list[i].txt) != 0) {
|
|
|
|
list2[count++] = list[i];
|
|
|
|
} else {
|
|
|
|
list2[count-1].num += list[i].num;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qsort(list2, count, sizeof(list[0]), compare_num);
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++)
|
|
|
|
fprintf(fout, "%d times:\n%s\n", list2[i].num, list2[i].txt);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|