builtin-kmem.c 17.2 KB
Newer Older
L
Li Zefan 已提交
1 2 3 4 5 6 7 8
#include "builtin.h"
#include "perf.h"

#include "util/util.h"
#include "util/cache.h"
#include "util/symbol.h"
#include "util/thread.h"
#include "util/header.h"
9
#include "util/session.h"
L
Li Zefan 已提交
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

#include "util/parse-options.h"
#include "util/trace-event.h"

#include "util/debug.h"

#include <linux/rbtree.h>

struct alloc_stat;
typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);

static char const		*input_name = "perf.data";

static int			alloc_flag;
static int			caller_flag;

static int			alloc_lines = -1;
static int			caller_lines = -1;

29 30
static bool			raw_ip;

31 32
static char			default_sort_order[] = "frag,hit,bytes";

33 34 35
static int			*cpunode_map;
static int			max_cpu_num;

L
Li Zefan 已提交
36
struct alloc_stat {
37 38
	u64	call_site;
	u64	ptr;
L
Li Zefan 已提交
39 40 41
	u64	bytes_req;
	u64	bytes_alloc;
	u32	hit;
42 43 44
	u32	pingpong;

	short	alloc_cpu;
L
Li Zefan 已提交
45 46 47 48 49 50 51 52 53 54

	struct rb_node node;
};

static struct rb_root root_alloc_stat;
static struct rb_root root_alloc_sorted;
static struct rb_root root_caller_stat;
static struct rb_root root_caller_sorted;

static unsigned long total_requested, total_allocated;
55
static unsigned long nr_allocs, nr_cross_allocs;
L
Li Zefan 已提交
56

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
#define PATH_SYS_NODE	"/sys/devices/system/node"

static void init_cpunode_map(void)
{
	FILE *fp;
	int i;

	fp = fopen("/sys/devices/system/cpu/kernel_max", "r");
	if (!fp) {
		max_cpu_num = 4096;
		return;
	}

	if (fscanf(fp, "%d", &max_cpu_num) < 1)
		die("Failed to read 'kernel_max' from sysfs");
	max_cpu_num++;

	cpunode_map = calloc(max_cpu_num, sizeof(int));
	if (!cpunode_map)
		die("calloc");
	for (i = 0; i < max_cpu_num; i++)
		cpunode_map[i] = -1;
	fclose(fp);
}

static void setup_cpunode_map(void)
{
	struct dirent *dent1, *dent2;
	DIR *dir1, *dir2;
	unsigned int cpu, mem;
	char buf[PATH_MAX];

	init_cpunode_map();

	dir1 = opendir(PATH_SYS_NODE);
	if (!dir1)
		return;

95 96 97
	while ((dent1 = readdir(dir1)) != NULL) {
		if (dent1->d_type != DT_DIR ||
		    sscanf(dent1->d_name, "node%u", &mem) < 1)
98 99 100 101 102 103
			continue;

		snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
		dir2 = opendir(buf);
		if (!dir2)
			continue;
104 105 106
		while ((dent2 = readdir(dir2)) != NULL) {
			if (dent2->d_type != DT_LNK ||
			    sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
107 108 109 110 111 112
				continue;
			cpunode_map[cpu] = mem;
		}
	}
}

113 114
static void insert_alloc_stat(unsigned long call_site, unsigned long ptr,
			      int bytes_req, int bytes_alloc, int cpu)
L
Li Zefan 已提交
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
{
	struct rb_node **node = &root_alloc_stat.rb_node;
	struct rb_node *parent = NULL;
	struct alloc_stat *data = NULL;

	while (*node) {
		parent = *node;
		data = rb_entry(*node, struct alloc_stat, node);

		if (ptr > data->ptr)
			node = &(*node)->rb_right;
		else if (ptr < data->ptr)
			node = &(*node)->rb_left;
		else
			break;
	}

	if (data && data->ptr == ptr) {
		data->hit++;
		data->bytes_req += bytes_req;
W
Wenji Huang 已提交
135
		data->bytes_alloc += bytes_alloc;
L
Li Zefan 已提交
136 137
	} else {
		data = malloc(sizeof(*data));
138 139
		if (!data)
			die("malloc");
L
Li Zefan 已提交
140
		data->ptr = ptr;
141
		data->pingpong = 0;
L
Li Zefan 已提交
142 143 144 145 146 147 148
		data->hit = 1;
		data->bytes_req = bytes_req;
		data->bytes_alloc = bytes_alloc;

		rb_link_node(&data->node, parent, node);
		rb_insert_color(&data->node, &root_alloc_stat);
	}
149 150
	data->call_site = call_site;
	data->alloc_cpu = cpu;
L
Li Zefan 已提交
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
}

static void insert_caller_stat(unsigned long call_site,
			      int bytes_req, int bytes_alloc)
{
	struct rb_node **node = &root_caller_stat.rb_node;
	struct rb_node *parent = NULL;
	struct alloc_stat *data = NULL;

	while (*node) {
		parent = *node;
		data = rb_entry(*node, struct alloc_stat, node);

		if (call_site > data->call_site)
			node = &(*node)->rb_right;
		else if (call_site < data->call_site)
			node = &(*node)->rb_left;
		else
			break;
	}

	if (data && data->call_site == call_site) {
		data->hit++;
		data->bytes_req += bytes_req;
W
Wenji Huang 已提交
175
		data->bytes_alloc += bytes_alloc;
L
Li Zefan 已提交
176 177
	} else {
		data = malloc(sizeof(*data));
178 179
		if (!data)
			die("malloc");
L
Li Zefan 已提交
180
		data->call_site = call_site;
181
		data->pingpong = 0;
L
Li Zefan 已提交
182 183 184 185 186 187 188 189 190
		data->hit = 1;
		data->bytes_req = bytes_req;
		data->bytes_alloc = bytes_alloc;

		rb_link_node(&data->node, parent, node);
		rb_insert_color(&data->node, &root_caller_stat);
	}
}

X
Xiao Guangrong 已提交
191
static void process_alloc_event(void *data,
L
Li Zefan 已提交
192
				struct event *event,
193
				int cpu,
L
Li Zefan 已提交
194 195
				u64 timestamp __used,
				struct thread *thread __used,
196
				int node)
L
Li Zefan 已提交
197 198 199 200 201
{
	unsigned long call_site;
	unsigned long ptr;
	int bytes_req;
	int bytes_alloc;
202
	int node1, node2;
L
Li Zefan 已提交
203

X
Xiao Guangrong 已提交
204 205 206 207
	ptr = raw_field_value(event, "ptr", data);
	call_site = raw_field_value(event, "call_site", data);
	bytes_req = raw_field_value(event, "bytes_req", data);
	bytes_alloc = raw_field_value(event, "bytes_alloc", data);
L
Li Zefan 已提交
208

209
	insert_alloc_stat(call_site, ptr, bytes_req, bytes_alloc, cpu);
L
Li Zefan 已提交
210 211 212 213
	insert_caller_stat(call_site, bytes_req, bytes_alloc);

	total_requested += bytes_req;
	total_allocated += bytes_alloc;
214 215 216

	if (node) {
		node1 = cpunode_map[cpu];
X
Xiao Guangrong 已提交
217
		node2 = raw_field_value(event, "node", data);
218 219 220 221
		if (node1 != node2)
			nr_cross_allocs++;
	}
	nr_allocs++;
L
Li Zefan 已提交
222 223
}

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
static int ptr_cmp(struct alloc_stat *, struct alloc_stat *);
static int callsite_cmp(struct alloc_stat *, struct alloc_stat *);

static struct alloc_stat *search_alloc_stat(unsigned long ptr,
					    unsigned long call_site,
					    struct rb_root *root,
					    sort_fn_t sort_fn)
{
	struct rb_node *node = root->rb_node;
	struct alloc_stat key = { .ptr = ptr, .call_site = call_site };

	while (node) {
		struct alloc_stat *data;
		int cmp;

		data = rb_entry(node, struct alloc_stat, node);

		cmp = sort_fn(&key, data);
		if (cmp < 0)
			node = node->rb_left;
		else if (cmp > 0)
			node = node->rb_right;
		else
			return data;
	}
	return NULL;
}

X
Xiao Guangrong 已提交
252
static void process_free_event(void *data,
253 254
			       struct event *event,
			       int cpu,
L
Li Zefan 已提交
255 256 257
			       u64 timestamp __used,
			       struct thread *thread __used)
{
258 259 260
	unsigned long ptr;
	struct alloc_stat *s_alloc, *s_caller;

X
Xiao Guangrong 已提交
261
	ptr = raw_field_value(event, "ptr", data);
262 263 264 265 266 267 268 269 270 271 272 273 274 275

	s_alloc = search_alloc_stat(ptr, 0, &root_alloc_stat, ptr_cmp);
	if (!s_alloc)
		return;

	if (cpu != s_alloc->alloc_cpu) {
		s_alloc->pingpong++;

		s_caller = search_alloc_stat(0, s_alloc->call_site,
					     &root_caller_stat, callsite_cmp);
		assert(s_caller);
		s_caller->pingpong++;
	}
	s_alloc->alloc_cpu = -1;
L
Li Zefan 已提交
276 277
}

278 279
static void process_raw_event(union perf_event *raw_event __used, void *data,
			      int cpu, u64 timestamp, struct thread *thread)
L
Li Zefan 已提交
280 281 282 283
{
	struct event *event;
	int type;

X
Xiao Guangrong 已提交
284
	type = trace_parse_common_type(data);
L
Li Zefan 已提交
285 286 287 288
	event = trace_find_event(type);

	if (!strcmp(event->name, "kmalloc") ||
	    !strcmp(event->name, "kmem_cache_alloc")) {
X
Xiao Guangrong 已提交
289
		process_alloc_event(data, event, cpu, timestamp, thread, 0);
L
Li Zefan 已提交
290 291 292 293 294
		return;
	}

	if (!strcmp(event->name, "kmalloc_node") ||
	    !strcmp(event->name, "kmem_cache_alloc_node")) {
X
Xiao Guangrong 已提交
295
		process_alloc_event(data, event, cpu, timestamp, thread, 1);
L
Li Zefan 已提交
296 297 298 299 300
		return;
	}

	if (!strcmp(event->name, "kfree") ||
	    !strcmp(event->name, "kmem_cache_free")) {
X
Xiao Guangrong 已提交
301
		process_free_event(data, event, cpu, timestamp, thread);
L
Li Zefan 已提交
302 303 304 305
		return;
	}
}

306 307
static int process_sample_event(union perf_event *event,
				struct perf_sample *sample,
308
				struct perf_evsel *evsel __used,
309
				struct perf_session *session)
L
Li Zefan 已提交
310
{
311
	struct thread *thread = perf_session__findnew(session, event->ip.pid);
L
Li Zefan 已提交
312 313 314 315 316 317 318 319 320

	if (thread == NULL) {
		pr_debug("problem processing %d event, skipping it.\n",
			 event->header.type);
		return -1;
	}

	dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);

321 322
	process_raw_event(event, sample->raw_data, sample->cpu,
			  sample->time, thread);
L
Li Zefan 已提交
323 324 325 326

	return 0;
}

327
static struct perf_event_ops event_ops = {
328
	.sample			= process_sample_event,
329
	.comm			= perf_event__process_comm,
330
	.ordered_samples	= true,
L
Li Zefan 已提交
331 332 333 334 335 336 337 338 339 340
};

static double fragmentation(unsigned long n_req, unsigned long n_alloc)
{
	if (n_alloc == 0)
		return 0.0;
	else
		return 100.0 - (100.0 * n_req / n_alloc);
}

341 342
static void __print_result(struct rb_root *root, struct perf_session *session,
			   int n_lines, int is_caller)
L
Li Zefan 已提交
343 344
{
	struct rb_node *next;
345
	struct machine *machine;
L
Li Zefan 已提交
346

347 348
	printf("%.102s\n", graph_dotted_line);
	printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
349
	printf(" Total_alloc/Per | Total_req/Per   | Hit      | Ping-pong | Frag\n");
350
	printf("%.102s\n", graph_dotted_line);
L
Li Zefan 已提交
351 352 353

	next = rb_first(root);

354 355
	machine = perf_session__find_host_machine(session);
	if (!machine) {
356 357 358
		pr_err("__print_result: couldn't find kernel information\n");
		return;
	}
L
Li Zefan 已提交
359
	while (next && n_lines--) {
360 361 362
		struct alloc_stat *data = rb_entry(next, struct alloc_stat,
						   node);
		struct symbol *sym = NULL;
363
		struct map *map;
364
		char buf[BUFSIZ];
365 366 367 368
		u64 addr;

		if (is_caller) {
			addr = data->call_site;
369
			if (!raw_ip)
370
				sym = machine__find_kernel_function(machine, addr, &map, NULL);
371 372 373 374
		} else
			addr = data->ptr;

		if (sym != NULL)
375
			snprintf(buf, sizeof(buf), "%s+%" PRIx64 "", sym->name,
376
				 addr - map->unmap_ip(map, sym->start));
377
		else
378
			snprintf(buf, sizeof(buf), "%#" PRIx64 "", addr);
379
		printf(" %-34s |", buf);
L
Li Zefan 已提交
380

381
		printf(" %9llu/%-5lu | %9llu/%-5lu | %8lu | %8lu | %6.3f%%\n",
382
		       (unsigned long long)data->bytes_alloc,
L
Li Zefan 已提交
383 384 385 386
		       (unsigned long)data->bytes_alloc / data->hit,
		       (unsigned long long)data->bytes_req,
		       (unsigned long)data->bytes_req / data->hit,
		       (unsigned long)data->hit,
387
		       (unsigned long)data->pingpong,
L
Li Zefan 已提交
388 389 390 391 392 393
		       fragmentation(data->bytes_req, data->bytes_alloc));

		next = rb_next(next);
	}

	if (n_lines == -1)
394
		printf(" ...                                | ...             | ...             | ...    | ...      | ...   \n");
L
Li Zefan 已提交
395

396
	printf("%.102s\n", graph_dotted_line);
L
Li Zefan 已提交
397 398 399 400 401 402 403 404 405 406 407
}

static void print_summary(void)
{
	printf("\nSUMMARY\n=======\n");
	printf("Total bytes requested: %lu\n", total_requested);
	printf("Total bytes allocated: %lu\n", total_allocated);
	printf("Total bytes wasted on internal fragmentation: %lu\n",
	       total_allocated - total_requested);
	printf("Internal fragmentation: %f%%\n",
	       fragmentation(total_requested, total_allocated));
408
	printf("Cross CPU allocations: %lu/%lu\n", nr_cross_allocs, nr_allocs);
L
Li Zefan 已提交
409 410
}

411
static void print_result(struct perf_session *session)
L
Li Zefan 已提交
412 413
{
	if (caller_flag)
414
		__print_result(&root_caller_sorted, session, caller_lines, 1);
L
Li Zefan 已提交
415
	if (alloc_flag)
416
		__print_result(&root_alloc_sorted, session, alloc_lines, 0);
L
Li Zefan 已提交
417 418 419
	print_summary();
}

420 421 422 423 424 425 426 427 428
struct sort_dimension {
	const char		name[20];
	sort_fn_t		cmp;
	struct list_head	list;
};

static LIST_HEAD(caller_sort);
static LIST_HEAD(alloc_sort);

L
Li Zefan 已提交
429
static void sort_insert(struct rb_root *root, struct alloc_stat *data,
430
			struct list_head *sort_list)
L
Li Zefan 已提交
431 432 433
{
	struct rb_node **new = &(root->rb_node);
	struct rb_node *parent = NULL;
434
	struct sort_dimension *sort;
L
Li Zefan 已提交
435 436 437

	while (*new) {
		struct alloc_stat *this;
438
		int cmp = 0;
L
Li Zefan 已提交
439 440 441 442

		this = rb_entry(*new, struct alloc_stat, node);
		parent = *new;

443 444 445 446 447
		list_for_each_entry(sort, sort_list, list) {
			cmp = sort->cmp(data, this);
			if (cmp)
				break;
		}
L
Li Zefan 已提交
448 449 450 451 452 453 454 455 456 457 458 459

		if (cmp > 0)
			new = &((*new)->rb_left);
		else
			new = &((*new)->rb_right);
	}

	rb_link_node(&data->node, parent, new);
	rb_insert_color(&data->node, root);
}

static void __sort_result(struct rb_root *root, struct rb_root *root_sorted,
460
			  struct list_head *sort_list)
L
Li Zefan 已提交
461 462 463 464 465 466 467 468 469 470 471
{
	struct rb_node *node;
	struct alloc_stat *data;

	for (;;) {
		node = rb_first(root);
		if (!node)
			break;

		rb_erase(node, root);
		data = rb_entry(node, struct alloc_stat, node);
472
		sort_insert(root_sorted, data, sort_list);
L
Li Zefan 已提交
473 474 475 476 477
	}
}

static void sort_result(void)
{
478 479
	__sort_result(&root_alloc_stat, &root_alloc_sorted, &alloc_sort);
	__sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
L
Li Zefan 已提交
480 481 482 483
}

static int __cmd_kmem(void)
{
484
	int err = -EINVAL;
485 486
	struct perf_session *session = perf_session__new(input_name, O_RDONLY,
							 0, false, &event_ops);
487 488 489
	if (session == NULL)
		return -ENOMEM;

490 491 492
	if (perf_session__create_kernel_maps(session) < 0)
		goto out_delete;

493 494 495
	if (!perf_session__has_traces(session, "kmem record"))
		goto out_delete;

L
Li Zefan 已提交
496
	setup_pager();
497 498 499
	err = perf_session__process_events(session, &event_ops);
	if (err != 0)
		goto out_delete;
L
Li Zefan 已提交
500
	sort_result();
501 502 503 504
	print_result(session);
out_delete:
	perf_session__delete(session);
	return err;
L
Li Zefan 已提交
505 506 507
}

static const char * const kmem_usage[] = {
508
	"perf kmem [<options>] {record|stat}",
L
Li Zefan 已提交
509 510 511 512 513 514 515 516 517 518 519 520
	NULL
};

static int ptr_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->ptr < r->ptr)
		return -1;
	else if (l->ptr > r->ptr)
		return 1;
	return 0;
}

521 522 523 524 525
static struct sort_dimension ptr_sort_dimension = {
	.name	= "ptr",
	.cmp	= ptr_cmp,
};

L
Li Zefan 已提交
526 527 528 529 530 531 532 533 534
static int callsite_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->call_site < r->call_site)
		return -1;
	else if (l->call_site > r->call_site)
		return 1;
	return 0;
}

535 536 537 538 539
static struct sort_dimension callsite_sort_dimension = {
	.name	= "callsite",
	.cmp	= callsite_cmp,
};

540 541 542 543 544 545 546 547 548
static int hit_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->hit < r->hit)
		return -1;
	else if (l->hit > r->hit)
		return 1;
	return 0;
}

549 550 551 552 553
static struct sort_dimension hit_sort_dimension = {
	.name	= "hit",
	.cmp	= hit_cmp,
};

L
Li Zefan 已提交
554 555 556 557 558 559 560 561 562
static int bytes_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->bytes_alloc < r->bytes_alloc)
		return -1;
	else if (l->bytes_alloc > r->bytes_alloc)
		return 1;
	return 0;
}

563 564 565 566 567
static struct sort_dimension bytes_sort_dimension = {
	.name	= "bytes",
	.cmp	= bytes_cmp,
};

568 569 570 571 572 573 574 575 576 577 578 579 580 581
static int frag_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	double x, y;

	x = fragmentation(l->bytes_req, l->bytes_alloc);
	y = fragmentation(r->bytes_req, r->bytes_alloc);

	if (x < y)
		return -1;
	else if (x > y)
		return 1;
	return 0;
}

582 583 584 585 586
static struct sort_dimension frag_sort_dimension = {
	.name	= "frag",
	.cmp	= frag_cmp,
};

587 588 589 590 591 592 593 594 595 596 597 598 599 600
static int pingpong_cmp(struct alloc_stat *l, struct alloc_stat *r)
{
	if (l->pingpong < r->pingpong)
		return -1;
	else if (l->pingpong > r->pingpong)
		return 1;
	return 0;
}

static struct sort_dimension pingpong_sort_dimension = {
	.name	= "pingpong",
	.cmp	= pingpong_cmp,
};

601 602 603 604 605 606
static struct sort_dimension *avail_sorts[] = {
	&ptr_sort_dimension,
	&callsite_sort_dimension,
	&hit_sort_dimension,
	&bytes_sort_dimension,
	&frag_sort_dimension,
607
	&pingpong_sort_dimension,
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653
};

#define NUM_AVAIL_SORTS	\
	(int)(sizeof(avail_sorts) / sizeof(struct sort_dimension *))

static int sort_dimension__add(const char *tok, struct list_head *list)
{
	struct sort_dimension *sort;
	int i;

	for (i = 0; i < NUM_AVAIL_SORTS; i++) {
		if (!strcmp(avail_sorts[i]->name, tok)) {
			sort = malloc(sizeof(*sort));
			if (!sort)
				die("malloc");
			memcpy(sort, avail_sorts[i], sizeof(*sort));
			list_add_tail(&sort->list, list);
			return 0;
		}
	}

	return -1;
}

static int setup_sorting(struct list_head *sort_list, const char *arg)
{
	char *tok;
	char *str = strdup(arg);

	if (!str)
		die("strdup");

	while (true) {
		tok = strsep(&str, ",");
		if (!tok)
			break;
		if (sort_dimension__add(tok, sort_list) < 0) {
			error("Unknown --sort key: '%s'", tok);
			return -1;
		}
	}

	free(str);
	return 0;
}

L
Li Zefan 已提交
654 655 656 657 658 659 660
static int parse_sort_opt(const struct option *opt __used,
			  const char *arg, int unset __used)
{
	if (!arg)
		return -1;

	if (caller_flag > alloc_flag)
661
		return setup_sorting(&caller_sort, arg);
L
Li Zefan 已提交
662
	else
663
		return setup_sorting(&alloc_sort, arg);
L
Li Zefan 已提交
664 665 666 667

	return 0;
}

668
static int parse_caller_opt(const struct option *opt __used,
669
			  const char *arg __used, int unset __used)
L
Li Zefan 已提交
670
{
671 672 673
	caller_flag = (alloc_flag + 1);
	return 0;
}
L
Li Zefan 已提交
674

675
static int parse_alloc_opt(const struct option *opt __used,
676
			  const char *arg __used, int unset __used)
677 678
{
	alloc_flag = (caller_flag + 1);
L
Li Zefan 已提交
679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
	return 0;
}

static int parse_line_opt(const struct option *opt __used,
			  const char *arg, int unset __used)
{
	int lines;

	if (!arg)
		return -1;

	lines = strtoul(arg, NULL, 10);

	if (caller_flag > alloc_flag)
		caller_lines = lines;
	else
		alloc_lines = lines;

	return 0;
}

static const struct option kmem_options[] = {
	OPT_STRING('i', "input", &input_name, "file",
		   "input file name"),
703 704 705 706 707 708
	OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
			   "show per-callsite statistics",
			   parse_caller_opt),
	OPT_CALLBACK_NOOPT(0, "alloc", NULL, NULL,
			   "show per-allocation statistics",
			   parse_alloc_opt),
709
	OPT_CALLBACK('s', "sort", NULL, "key[,key2...]",
710
		     "sort by keys: ptr, call_site, bytes, hit, pingpong, frag",
L
Li Zefan 已提交
711 712
		     parse_sort_opt),
	OPT_CALLBACK('l', "line", NULL, "num",
713
		     "show n lines",
L
Li Zefan 已提交
714
		     parse_line_opt),
715
	OPT_BOOLEAN(0, "raw-ip", &raw_ip, "show raw ip instead of symbol"),
L
Li Zefan 已提交
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
	OPT_END()
};

static const char *record_args[] = {
	"record",
	"-a",
	"-R",
	"-f",
	"-c", "1",
	"-e", "kmem:kmalloc",
	"-e", "kmem:kmalloc_node",
	"-e", "kmem:kfree",
	"-e", "kmem:kmem_cache_alloc",
	"-e", "kmem:kmem_cache_alloc_node",
	"-e", "kmem:kmem_cache_free",
};

static int __cmd_record(int argc, const char **argv)
{
	unsigned int rec_argc, i, j;
	const char **rec_argv;

	rec_argc = ARRAY_SIZE(record_args) + argc - 1;
	rec_argv = calloc(rec_argc + 1, sizeof(char *));

741 742 743
	if (rec_argv == NULL)
		return -ENOMEM;

L
Li Zefan 已提交
744 745 746 747 748 749 750 751 752 753 754 755 756
	for (i = 0; i < ARRAY_SIZE(record_args); i++)
		rec_argv[i] = strdup(record_args[i]);

	for (j = 1; j < (unsigned int)argc; j++, i++)
		rec_argv[i] = argv[j];

	return cmd_record(i, rec_argv, NULL);
}

int cmd_kmem(int argc, const char **argv, const char *prefix __used)
{
	argc = parse_options(argc, argv, kmem_options, kmem_usage, 0);

757
	if (!argc)
L
Li Zefan 已提交
758 759
		usage_with_options(kmem_usage, kmem_options);

760 761
	symbol__init();

762 763 764 765 766 767 768 769 770
	if (!strncmp(argv[0], "rec", 3)) {
		return __cmd_record(argc, argv);
	} else if (!strcmp(argv[0], "stat")) {
		setup_cpunode_map();

		if (list_empty(&caller_sort))
			setup_sorting(&caller_sort, default_sort_order);
		if (list_empty(&alloc_sort))
			setup_sorting(&alloc_sort, default_sort_order);
L
Li Zefan 已提交
771

772
		return __cmd_kmem();
773 774
	} else
		usage_with_options(kmem_usage, kmem_options);
775

776
	return 0;
L
Li Zefan 已提交
777 778
}