builtin-timechart.c 46.8 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
A
Arjan van de Ven 已提交
2 3 4 5 6 7 8 9 10
/*
 * builtin-timechart.c - make an svg timechart of system activity
 *
 * (C) Copyright 2009 Intel Corporation
 *
 * Authors:
 *     Arjan van de Ven <arjan@linux.intel.com>
 */

11
#include <errno.h>
12
#include <inttypes.h>
13 14
#include <traceevent/event-parse.h>

A
Arjan van de Ven 已提交
15 16 17 18
#include "builtin.h"
#include "util/color.h"
#include <linux/list.h>
#include "util/cache.h"
19
#include "util/evlist.h"
20
#include "util/evsel.h"
21
#include <linux/kernel.h>
A
Arjan van de Ven 已提交
22
#include <linux/rbtree.h>
23
#include <linux/time64.h>
24
#include <linux/zalloc.h>
A
Arjan van de Ven 已提交
25
#include "util/symbol.h"
26
#include "util/thread.h"
A
Arjan van de Ven 已提交
27 28 29 30
#include "util/callchain.h"

#include "perf.h"
#include "util/header.h"
31
#include <subcmd/parse-options.h>
A
Arjan van de Ven 已提交
32
#include "util/parse-events.h"
33
#include "util/event.h"
34
#include "util/session.h"
A
Arjan van de Ven 已提交
35
#include "util/svghelper.h"
36
#include "util/tool.h"
37
#include "util/data.h"
38
#include "util/debug.h"
A
Arjan van de Ven 已提交
39

40 41 42 43
#ifdef LACKS_OPEN_MEMSTREAM_PROTOTYPE
FILE *open_memstream(char **ptr, size_t *sizeloc);
#endif

44 45 46
#define SUPPORT_OLD_POWER_EVENTS 1
#define PWR_EVENT_EXIT -1

47
struct per_pid;
48
struct power_event;
49
struct wake_event;
50

51 52
struct timechart {
	struct perf_tool	tool;
53
	struct per_pid		*all_data;
54
	struct power_event	*power_events;
55
	struct wake_event	*wake_events;
56 57 58 59 60 61 62 63
	int			proc_num;
	unsigned int		numcpus;
	u64			min_freq,	/* Lowest CPU frequency seen */
				max_freq,	/* Highest CPU frequency seen */
				turbo_frequency,
				first_time, last_time;
	bool			power_only,
				tasks_only,
64 65
				with_backtrace,
				topology;
66
	bool			force;
67
	/* IO related settings */
68 69
	bool			io_only,
				skip_eagain;
70
	u64			io_events;
71 72
	u64			min_time,
				merge_dist;
73
};
A
Arjan van de Ven 已提交
74 75 76

struct per_pidcomm;
struct cpu_sample;
77
struct io_sample;
A
Arjan van de Ven 已提交
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97

/*
 * Datastructure layout:
 * We keep an list of "pid"s, matching the kernels notion of a task struct.
 * Each "pid" entry, has a list of "comm"s.
 *	this is because we want to track different programs different, while
 *	exec will reuse the original pid (by design).
 * Each comm has a list of samples that will be used to draw
 * final graph.
 */

struct per_pid {
	struct per_pid *next;

	int		pid;
	int		ppid;

	u64		start_time;
	u64		end_time;
	u64		total_time;
98
	u64		total_bytes;
A
Arjan van de Ven 已提交
99 100 101 102 103 104 105 106 107 108 109 110 111
	int		display;

	struct per_pidcomm *all;
	struct per_pidcomm *current;
};


struct per_pidcomm {
	struct per_pidcomm *next;

	u64		start_time;
	u64		end_time;
	u64		total_time;
112 113
	u64		max_bytes;
	u64		total_bytes;
A
Arjan van de Ven 已提交
114 115 116 117 118 119 120 121 122 123

	int		Y;
	int		display;

	long		state;
	u64		state_since;

	char		*comm;

	struct cpu_sample *samples;
124
	struct io_sample  *io_samples;
A
Arjan van de Ven 已提交
125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
};

struct sample_wrapper {
	struct sample_wrapper *next;

	u64		timestamp;
	unsigned char	data[0];
};

#define TYPE_NONE	0
#define TYPE_RUNNING	1
#define TYPE_WAITING	2
#define TYPE_BLOCKED	3

struct cpu_sample {
	struct cpu_sample *next;

	u64 start_time;
	u64 end_time;
	int type;
	int cpu;
146
	const char *backtrace;
A
Arjan van de Ven 已提交
147 148
};

149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
enum {
	IOTYPE_READ,
	IOTYPE_WRITE,
	IOTYPE_SYNC,
	IOTYPE_TX,
	IOTYPE_RX,
	IOTYPE_POLL,
};

struct io_sample {
	struct io_sample *next;

	u64 start_time;
	u64 end_time;
	u64 bytes;
	int type;
	int fd;
	int err;
	int merges;
};

A
Arjan van de Ven 已提交
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
#define CSTATE 1
#define PSTATE 2

struct power_event {
	struct power_event *next;
	int type;
	int state;
	u64 start_time;
	u64 end_time;
	int cpu;
};

struct wake_event {
	struct wake_event *next;
	int waker;
	int wakee;
	u64 time;
187
	const char *backtrace;
A
Arjan van de Ven 已提交
188 189
};

190
struct process_filter {
191 192 193
	char			*name;
	int			pid;
	struct process_filter	*next;
194 195 196 197 198
};

static struct process_filter *process_filter;


199
static struct per_pid *find_create_pid(struct timechart *tchart, int pid)
A
Arjan van de Ven 已提交
200
{
201
	struct per_pid *cursor = tchart->all_data;
A
Arjan van de Ven 已提交
202 203 204 205 206 207

	while (cursor) {
		if (cursor->pid == pid)
			return cursor;
		cursor = cursor->next;
	}
208
	cursor = zalloc(sizeof(*cursor));
A
Arjan van de Ven 已提交
209 210
	assert(cursor != NULL);
	cursor->pid = pid;
211 212
	cursor->next = tchart->all_data;
	tchart->all_data = cursor;
A
Arjan van de Ven 已提交
213 214 215
	return cursor;
}

216
static void pid_set_comm(struct timechart *tchart, int pid, char *comm)
A
Arjan van de Ven 已提交
217 218 219
{
	struct per_pid *p;
	struct per_pidcomm *c;
220
	p = find_create_pid(tchart, pid);
A
Arjan van de Ven 已提交
221 222 223 224 225 226 227 228 229 230 231 232 233
	c = p->all;
	while (c) {
		if (c->comm && strcmp(c->comm, comm) == 0) {
			p->current = c;
			return;
		}
		if (!c->comm) {
			c->comm = strdup(comm);
			p->current = c;
			return;
		}
		c = c->next;
	}
234
	c = zalloc(sizeof(*c));
A
Arjan van de Ven 已提交
235 236 237 238 239 240 241
	assert(c != NULL);
	c->comm = strdup(comm);
	p->current = c;
	c->next = p->all;
	p->all = c;
}

242
static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
A
Arjan van de Ven 已提交
243 244
{
	struct per_pid *p, *pp;
245 246
	p = find_create_pid(tchart, pid);
	pp = find_create_pid(tchart, ppid);
A
Arjan van de Ven 已提交
247 248
	p->ppid = ppid;
	if (pp->current && pp->current->comm && !p->current)
249
		pid_set_comm(tchart, pid, pp->current->comm);
A
Arjan van de Ven 已提交
250 251

	p->start_time = timestamp;
252
	if (p->current && !p->current->start_time) {
A
Arjan van de Ven 已提交
253 254 255 256 257
		p->current->start_time = timestamp;
		p->current->state_since = timestamp;
	}
}

258
static void pid_exit(struct timechart *tchart, int pid, u64 timestamp)
A
Arjan van de Ven 已提交
259 260
{
	struct per_pid *p;
261
	p = find_create_pid(tchart, pid);
A
Arjan van de Ven 已提交
262 263 264 265 266
	p->end_time = timestamp;
	if (p->current)
		p->current->end_time = timestamp;
}

267 268 269
static void pid_put_sample(struct timechart *tchart, int pid, int type,
			   unsigned int cpu, u64 start, u64 end,
			   const char *backtrace)
A
Arjan van de Ven 已提交
270 271 272 273 274
{
	struct per_pid *p;
	struct per_pidcomm *c;
	struct cpu_sample *sample;

275
	p = find_create_pid(tchart, pid);
A
Arjan van de Ven 已提交
276 277
	c = p->current;
	if (!c) {
278
		c = zalloc(sizeof(*c));
A
Arjan van de Ven 已提交
279 280 281 282 283 284
		assert(c != NULL);
		p->current = c;
		c->next = p->all;
		p->all = c;
	}

285
	sample = zalloc(sizeof(*sample));
A
Arjan van de Ven 已提交
286 287 288 289 290 291
	assert(sample != NULL);
	sample->start_time = start;
	sample->end_time = end;
	sample->type = type;
	sample->next = c->samples;
	sample->cpu = cpu;
292
	sample->backtrace = backtrace;
A
Arjan van de Ven 已提交
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
	c->samples = sample;

	if (sample->type == TYPE_RUNNING && end > start && start > 0) {
		c->total_time += (end-start);
		p->total_time += (end-start);
	}

	if (c->start_time == 0 || c->start_time > start)
		c->start_time = start;
	if (p->start_time == 0 || p->start_time > start)
		p->start_time = start;
}

#define MAX_CPUS 4096

static u64 cpus_cstate_start_times[MAX_CPUS];
static int cpus_cstate_state[MAX_CPUS];
static u64 cpus_pstate_start_times[MAX_CPUS];
static u64 cpus_pstate_state[MAX_CPUS];

313
static int process_comm_event(struct perf_tool *tool,
314
			      union perf_event *event,
315 316
			      struct perf_sample *sample __maybe_unused,
			      struct machine *machine __maybe_unused)
A
Arjan van de Ven 已提交
317
{
318 319
	struct timechart *tchart = container_of(tool, struct timechart, tool);
	pid_set_comm(tchart, event->comm.tid, event->comm.comm);
A
Arjan van de Ven 已提交
320 321
	return 0;
}
322

323
static int process_fork_event(struct perf_tool *tool,
324
			      union perf_event *event,
325 326
			      struct perf_sample *sample __maybe_unused,
			      struct machine *machine __maybe_unused)
A
Arjan van de Ven 已提交
327
{
328 329
	struct timechart *tchart = container_of(tool, struct timechart, tool);
	pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time);
A
Arjan van de Ven 已提交
330 331 332
	return 0;
}

333
static int process_exit_event(struct perf_tool *tool,
334
			      union perf_event *event,
335 336
			      struct perf_sample *sample __maybe_unused,
			      struct machine *machine __maybe_unused)
A
Arjan van de Ven 已提交
337
{
338 339
	struct timechart *tchart = container_of(tool, struct timechart, tool);
	pid_exit(tchart, event->fork.pid, event->fork.time);
A
Arjan van de Ven 已提交
340 341 342
	return 0;
}

343 344 345 346
#ifdef SUPPORT_OLD_POWER_EVENTS
static int use_old_power_events;
#endif

A
Arjan van de Ven 已提交
347 348 349 350 351 352
static void c_state_start(int cpu, u64 timestamp, int state)
{
	cpus_cstate_start_times[cpu] = timestamp;
	cpus_cstate_state[cpu] = state;
}

353
static void c_state_end(struct timechart *tchart, int cpu, u64 timestamp)
A
Arjan van de Ven 已提交
354
{
355 356
	struct power_event *pwr = zalloc(sizeof(*pwr));

A
Arjan van de Ven 已提交
357 358 359 360 361 362 363 364
	if (!pwr)
		return;

	pwr->state = cpus_cstate_state[cpu];
	pwr->start_time = cpus_cstate_start_times[cpu];
	pwr->end_time = timestamp;
	pwr->cpu = cpu;
	pwr->type = CSTATE;
365
	pwr->next = tchart->power_events;
A
Arjan van de Ven 已提交
366

367
	tchart->power_events = pwr;
A
Arjan van de Ven 已提交
368 369
}

370
static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64 new_freq)
A
Arjan van de Ven 已提交
371 372 373 374 375 376
{
	struct power_event *pwr;

	if (new_freq > 8000000) /* detect invalid data */
		return;

377
	pwr = zalloc(sizeof(*pwr));
A
Arjan van de Ven 已提交
378 379 380 381 382 383 384 385
	if (!pwr)
		return;

	pwr->state = cpus_pstate_state[cpu];
	pwr->start_time = cpus_pstate_start_times[cpu];
	pwr->end_time = timestamp;
	pwr->cpu = cpu;
	pwr->type = PSTATE;
386
	pwr->next = tchart->power_events;
A
Arjan van de Ven 已提交
387 388

	if (!pwr->start_time)
389
		pwr->start_time = tchart->first_time;
A
Arjan van de Ven 已提交
390

391
	tchart->power_events = pwr;
A
Arjan van de Ven 已提交
392 393 394 395

	cpus_pstate_state[cpu] = new_freq;
	cpus_pstate_start_times[cpu] = timestamp;

396 397
	if ((u64)new_freq > tchart->max_freq)
		tchart->max_freq = new_freq;
A
Arjan van de Ven 已提交
398

399 400
	if (new_freq < tchart->min_freq || tchart->min_freq == 0)
		tchart->min_freq = new_freq;
A
Arjan van de Ven 已提交
401

402 403
	if (new_freq == tchart->max_freq - 1000)
		tchart->turbo_frequency = tchart->max_freq;
A
Arjan van de Ven 已提交
404 405
}

406 407
static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp,
			 int waker, int wakee, u8 flags, const char *backtrace)
A
Arjan van de Ven 已提交
408 409
{
	struct per_pid *p;
410
	struct wake_event *we = zalloc(sizeof(*we));
A
Arjan van de Ven 已提交
411 412 413 414 415

	if (!we)
		return;

	we->time = timestamp;
416
	we->waker = waker;
417
	we->backtrace = backtrace;
A
Arjan van de Ven 已提交
418

419
	if ((flags & TRACE_FLAG_HARDIRQ) || (flags & TRACE_FLAG_SOFTIRQ))
A
Arjan van de Ven 已提交
420 421
		we->waker = -1;

422
	we->wakee = wakee;
423 424
	we->next = tchart->wake_events;
	tchart->wake_events = we;
425
	p = find_create_pid(tchart, we->wakee);
A
Arjan van de Ven 已提交
426 427 428 429 430 431

	if (p && p->current && p->current->state == TYPE_NONE) {
		p->current->state_since = timestamp;
		p->current->state = TYPE_WAITING;
	}
	if (p && p->current && p->current->state == TYPE_BLOCKED) {
432
		pid_put_sample(tchart, p->pid, p->current->state, cpu,
433
			       p->current->state_since, timestamp, NULL);
A
Arjan van de Ven 已提交
434 435 436 437 438
		p->current->state_since = timestamp;
		p->current->state = TYPE_WAITING;
	}
}

439 440 441
static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp,
			 int prev_pid, int next_pid, u64 prev_state,
			 const char *backtrace)
A
Arjan van de Ven 已提交
442 443 444
{
	struct per_pid *p = NULL, *prev_p;

445
	prev_p = find_create_pid(tchart, prev_pid);
A
Arjan van de Ven 已提交
446

447
	p = find_create_pid(tchart, next_pid);
A
Arjan van de Ven 已提交
448 449

	if (prev_p->current && prev_p->current->state != TYPE_NONE)
450
		pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu,
451 452
			       prev_p->current->state_since, timestamp,
			       backtrace);
A
Arjan van de Ven 已提交
453 454
	if (p && p->current) {
		if (p->current->state != TYPE_NONE)
455
			pid_put_sample(tchart, next_pid, p->current->state, cpu,
456 457
				       p->current->state_since, timestamp,
				       backtrace);
A
Arjan van de Ven 已提交
458

459 460
		p->current->state_since = timestamp;
		p->current->state = TYPE_RUNNING;
A
Arjan van de Ven 已提交
461 462 463 464 465
	}

	if (prev_p->current) {
		prev_p->current->state = TYPE_NONE;
		prev_p->current->state_since = timestamp;
466
		if (prev_state & 2)
A
Arjan van de Ven 已提交
467
			prev_p->current->state = TYPE_BLOCKED;
468
		if (prev_state == 0)
A
Arjan van de Ven 已提交
469 470 471 472
			prev_p->current->state = TYPE_WAITING;
	}
}

473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
static const char *cat_backtrace(union perf_event *event,
				 struct perf_sample *sample,
				 struct machine *machine)
{
	struct addr_location al;
	unsigned int i;
	char *p = NULL;
	size_t p_len;
	u8 cpumode = PERF_RECORD_MISC_USER;
	struct addr_location tal;
	struct ip_callchain *chain = sample->callchain;
	FILE *f = open_memstream(&p, &p_len);

	if (!f) {
		perror("open_memstream error");
		return NULL;
	}

	if (!chain)
		goto exit;

494
	if (machine__resolve(machine, &al, sample) < 0) {
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
		fprintf(stderr, "problem processing %d event, skipping it.\n",
			event->header.type);
		goto exit;
	}

	for (i = 0; i < chain->nr; i++) {
		u64 ip;

		if (callchain_param.order == ORDER_CALLEE)
			ip = chain->ips[i];
		else
			ip = chain->ips[chain->nr - i - 1];

		if (ip >= PERF_CONTEXT_MAX) {
			switch (ip) {
			case PERF_CONTEXT_HV:
				cpumode = PERF_RECORD_MISC_HYPERVISOR;
				break;
			case PERF_CONTEXT_KERNEL:
				cpumode = PERF_RECORD_MISC_KERNEL;
				break;
			case PERF_CONTEXT_USER:
				cpumode = PERF_RECORD_MISC_USER;
				break;
			default:
				pr_debug("invalid callchain context: "
					 "%"PRId64"\n", (s64) ip);

				/*
				 * It seems the callchain is corrupted.
				 * Discard all.
				 */
527
				zfree(&p);
528
				goto exit_put;
529 530 531 532
			}
			continue;
		}

533
		tal.filtered = 0;
534 535
		if (thread__find_symbol(al.thread, cpumode, ip, &tal))
			fprintf(f, "..... %016" PRIx64 " %s\n", ip, tal.sym->name);
536 537 538
		else
			fprintf(f, "..... %016" PRIx64 "\n", ip);
	}
539 540
exit_put:
	addr_location__put(&al);
541 542 543 544 545 546
exit:
	fclose(f);

	return p;
}

547 548
typedef int (*tracepoint_handler)(struct timechart *tchart,
				  struct perf_evsel *evsel,
549 550
				  struct perf_sample *sample,
				  const char *backtrace);
A
Arjan van de Ven 已提交
551

552
static int process_sample_event(struct perf_tool *tool,
553
				union perf_event *event,
554
				struct perf_sample *sample,
555
				struct perf_evsel *evsel,
556
				struct machine *machine)
A
Arjan van de Ven 已提交
557
{
558 559
	struct timechart *tchart = container_of(tool, struct timechart, tool);

560
	if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
561 562 563 564
		if (!tchart->first_time || tchart->first_time > sample->time)
			tchart->first_time = sample->time;
		if (tchart->last_time < sample->time)
			tchart->last_time = sample->time;
A
Arjan van de Ven 已提交
565
	}
566

567 568
	if (evsel->handler != NULL) {
		tracepoint_handler f = evsel->handler;
569 570
		return f(tchart, evsel, sample,
			 cat_backtrace(event, sample, machine));
571 572 573 574 575 576
	}

	return 0;
}

static int
577 578
process_sample_cpu_idle(struct timechart *tchart __maybe_unused,
			struct perf_evsel *evsel,
579 580
			struct perf_sample *sample,
			const char *backtrace __maybe_unused)
581
{
582 583
	u32 state = perf_evsel__intval(evsel, sample, "state");
	u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
584

585
	if (state == (u32)PWR_EVENT_EXIT)
586
		c_state_end(tchart, cpu_id, sample->time);
587
	else
588
		c_state_start(cpu_id, sample->time, state);
589 590 591 592
	return 0;
}

static int
593 594
process_sample_cpu_frequency(struct timechart *tchart,
			     struct perf_evsel *evsel,
595 596
			     struct perf_sample *sample,
			     const char *backtrace __maybe_unused)
597
{
598 599
	u32 state = perf_evsel__intval(evsel, sample, "state");
	u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
600

601
	p_state_change(tchart, cpu_id, sample->time, state);
602 603 604 605
	return 0;
}

static int
606
process_sample_sched_wakeup(struct timechart *tchart,
607
			    struct perf_evsel *evsel,
608 609
			    struct perf_sample *sample,
			    const char *backtrace)
610
{
611 612 613
	u8 flags = perf_evsel__intval(evsel, sample, "common_flags");
	int waker = perf_evsel__intval(evsel, sample, "common_pid");
	int wakee = perf_evsel__intval(evsel, sample, "pid");
614

615
	sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace);
616 617
	return 0;
}
A
Arjan van de Ven 已提交
618

619
static int
620
process_sample_sched_switch(struct timechart *tchart,
621
			    struct perf_evsel *evsel,
622 623
			    struct perf_sample *sample,
			    const char *backtrace)
624
{
625 626 627
	int prev_pid = perf_evsel__intval(evsel, sample, "prev_pid");
	int next_pid = perf_evsel__intval(evsel, sample, "next_pid");
	u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
A
Arjan van de Ven 已提交
628

629 630
	sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid,
		     prev_state, backtrace);
631 632
	return 0;
}
633 634

#ifdef SUPPORT_OLD_POWER_EVENTS
635
static int
636 637
process_sample_power_start(struct timechart *tchart __maybe_unused,
			   struct perf_evsel *evsel,
638 639
			   struct perf_sample *sample,
			   const char *backtrace __maybe_unused)
640
{
641 642
	u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
	u64 value = perf_evsel__intval(evsel, sample, "value");
643

644
	c_state_start(cpu_id, sample->time, value);
645 646 647 648
	return 0;
}

static int
649
process_sample_power_end(struct timechart *tchart,
650
			 struct perf_evsel *evsel __maybe_unused,
651 652
			 struct perf_sample *sample,
			 const char *backtrace __maybe_unused)
653
{
654
	c_state_end(tchart, sample->cpu, sample->time);
655 656 657 658
	return 0;
}

static int
659 660
process_sample_power_frequency(struct timechart *tchart,
			       struct perf_evsel *evsel,
661 662
			       struct perf_sample *sample,
			       const char *backtrace __maybe_unused)
663
{
664 665
	u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
	u64 value = perf_evsel__intval(evsel, sample, "value");
666

667
	p_state_change(tchart, cpu_id, sample->time, value);
A
Arjan van de Ven 已提交
668 669
	return 0;
}
670
#endif /* SUPPORT_OLD_POWER_EVENTS */
A
Arjan van de Ven 已提交
671 672 673 674 675

/*
 * After the last sample we need to wrap up the current C/P state
 * and close out each CPU for these.
 */
676
static void end_sample_processing(struct timechart *tchart)
A
Arjan van de Ven 已提交
677 678 679 680
{
	u64 cpu;
	struct power_event *pwr;

681
	for (cpu = 0; cpu <= tchart->numcpus; cpu++) {
682 683 684
		/* C state */
#if 0
		pwr = zalloc(sizeof(*pwr));
A
Arjan van de Ven 已提交
685 686 687 688 689
		if (!pwr)
			return;

		pwr->state = cpus_cstate_state[cpu];
		pwr->start_time = cpus_cstate_start_times[cpu];
690
		pwr->end_time = tchart->last_time;
A
Arjan van de Ven 已提交
691 692
		pwr->cpu = cpu;
		pwr->type = CSTATE;
693
		pwr->next = tchart->power_events;
A
Arjan van de Ven 已提交
694

695
		tchart->power_events = pwr;
A
Arjan van de Ven 已提交
696 697 698
#endif
		/* P state */

699
		pwr = zalloc(sizeof(*pwr));
A
Arjan van de Ven 已提交
700 701 702 703 704
		if (!pwr)
			return;

		pwr->state = cpus_pstate_state[cpu];
		pwr->start_time = cpus_pstate_start_times[cpu];
705
		pwr->end_time = tchart->last_time;
A
Arjan van de Ven 已提交
706 707
		pwr->cpu = cpu;
		pwr->type = PSTATE;
708
		pwr->next = tchart->power_events;
A
Arjan van de Ven 已提交
709 710

		if (!pwr->start_time)
711
			pwr->start_time = tchart->first_time;
A
Arjan van de Ven 已提交
712
		if (!pwr->state)
713
			pwr->state = tchart->min_freq;
714
		tchart->power_events = pwr;
A
Arjan van de Ven 已提交
715 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 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
static int pid_begin_io_sample(struct timechart *tchart, int pid, int type,
			       u64 start, int fd)
{
	struct per_pid *p = find_create_pid(tchart, pid);
	struct per_pidcomm *c = p->current;
	struct io_sample *sample;
	struct io_sample *prev;

	if (!c) {
		c = zalloc(sizeof(*c));
		if (!c)
			return -ENOMEM;
		p->current = c;
		c->next = p->all;
		p->all = c;
	}

	prev = c->io_samples;

	if (prev && prev->start_time && !prev->end_time) {
		pr_warning("Skip invalid start event: "
			   "previous event already started!\n");

		/* remove previous event that has been started,
		 * we are not sure we will ever get an end for it */
		c->io_samples = prev->next;
		free(prev);
		return 0;
	}

	sample = zalloc(sizeof(*sample));
	if (!sample)
		return -ENOMEM;
	sample->start_time = start;
	sample->type = type;
	sample->fd = fd;
	sample->next = c->io_samples;
	c->io_samples = sample;

	if (c->start_time == 0 || c->start_time > start)
		c->start_time = start;

	return 0;
}

static int pid_end_io_sample(struct timechart *tchart, int pid, int type,
			     u64 end, long ret)
{
	struct per_pid *p = find_create_pid(tchart, pid);
	struct per_pidcomm *c = p->current;
768
	struct io_sample *sample, *prev;
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791

	if (!c) {
		pr_warning("Invalid pidcomm!\n");
		return -1;
	}

	sample = c->io_samples;

	if (!sample) /* skip partially captured events */
		return 0;

	if (sample->end_time) {
		pr_warning("Skip invalid end event: "
			   "previous event already ended!\n");
		return 0;
	}

	if (sample->type != type) {
		pr_warning("Skip invalid end event: invalid event type!\n");
		return 0;
	}

	sample->end_time = end;
792 793 794 795 796 797 798 799 800 801 802 803
	prev = sample->next;

	/* we want to be able to see small and fast transfers, so make them
	 * at least min_time long, but don't overlap them */
	if (sample->end_time - sample->start_time < tchart->min_time)
		sample->end_time = sample->start_time + tchart->min_time;
	if (prev && sample->start_time < prev->end_time) {
		if (prev->err) /* try to make errors more visible */
			sample->start_time = prev->end_time;
		else
			prev->end_time = sample->start_time;
	}
804 805 806 807 808 809 810 811 812 813 814 815 816 817

	if (ret < 0) {
		sample->err = ret;
	} else if (type == IOTYPE_READ || type == IOTYPE_WRITE ||
		   type == IOTYPE_TX || type == IOTYPE_RX) {

		if ((u64)ret > c->max_bytes)
			c->max_bytes = ret;

		c->total_bytes += ret;
		p->total_bytes += ret;
		sample->bytes = ret;
	}

818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
	/* merge two requests to make svg smaller and render-friendly */
	if (prev &&
	    prev->type == sample->type &&
	    prev->err == sample->err &&
	    prev->fd == sample->fd &&
	    prev->end_time + tchart->merge_dist >= sample->start_time) {

		sample->bytes += prev->bytes;
		sample->merges += prev->merges + 1;

		sample->start_time = prev->start_time;
		sample->next = prev->next;
		free(prev);

		if (!sample->err && sample->bytes > c->max_bytes)
			c->max_bytes = sample->bytes;
	}

836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
	tchart->io_events++;

	return 0;
}

static int
process_enter_read(struct timechart *tchart,
		   struct perf_evsel *evsel,
		   struct perf_sample *sample)
{
	long fd = perf_evsel__intval(evsel, sample, "fd");
	return pid_begin_io_sample(tchart, sample->tid, IOTYPE_READ,
				   sample->time, fd);
}

static int
process_exit_read(struct timechart *tchart,
		  struct perf_evsel *evsel,
		  struct perf_sample *sample)
{
	long ret = perf_evsel__intval(evsel, sample, "ret");
	return pid_end_io_sample(tchart, sample->tid, IOTYPE_READ,
				 sample->time, ret);
}

static int
process_enter_write(struct timechart *tchart,
		    struct perf_evsel *evsel,
		    struct perf_sample *sample)
{
	long fd = perf_evsel__intval(evsel, sample, "fd");
	return pid_begin_io_sample(tchart, sample->tid, IOTYPE_WRITE,
				   sample->time, fd);
}

static int
process_exit_write(struct timechart *tchart,
		   struct perf_evsel *evsel,
		   struct perf_sample *sample)
{
	long ret = perf_evsel__intval(evsel, sample, "ret");
	return pid_end_io_sample(tchart, sample->tid, IOTYPE_WRITE,
				 sample->time, ret);
}

static int
process_enter_sync(struct timechart *tchart,
		   struct perf_evsel *evsel,
		   struct perf_sample *sample)
{
	long fd = perf_evsel__intval(evsel, sample, "fd");
	return pid_begin_io_sample(tchart, sample->tid, IOTYPE_SYNC,
				   sample->time, fd);
}

static int
process_exit_sync(struct timechart *tchart,
		  struct perf_evsel *evsel,
		  struct perf_sample *sample)
{
	long ret = perf_evsel__intval(evsel, sample, "ret");
	return pid_end_io_sample(tchart, sample->tid, IOTYPE_SYNC,
				 sample->time, ret);
}

static int
process_enter_tx(struct timechart *tchart,
		 struct perf_evsel *evsel,
		 struct perf_sample *sample)
{
	long fd = perf_evsel__intval(evsel, sample, "fd");
	return pid_begin_io_sample(tchart, sample->tid, IOTYPE_TX,
				   sample->time, fd);
}

static int
process_exit_tx(struct timechart *tchart,
		struct perf_evsel *evsel,
		struct perf_sample *sample)
{
	long ret = perf_evsel__intval(evsel, sample, "ret");
	return pid_end_io_sample(tchart, sample->tid, IOTYPE_TX,
				 sample->time, ret);
}

static int
process_enter_rx(struct timechart *tchart,
		 struct perf_evsel *evsel,
		 struct perf_sample *sample)
{
	long fd = perf_evsel__intval(evsel, sample, "fd");
	return pid_begin_io_sample(tchart, sample->tid, IOTYPE_RX,
				   sample->time, fd);
}

static int
process_exit_rx(struct timechart *tchart,
		struct perf_evsel *evsel,
		struct perf_sample *sample)
{
	long ret = perf_evsel__intval(evsel, sample, "ret");
	return pid_end_io_sample(tchart, sample->tid, IOTYPE_RX,
				 sample->time, ret);
}

static int
process_enter_poll(struct timechart *tchart,
		   struct perf_evsel *evsel,
		   struct perf_sample *sample)
{
	long fd = perf_evsel__intval(evsel, sample, "fd");
	return pid_begin_io_sample(tchart, sample->tid, IOTYPE_POLL,
				   sample->time, fd);
}

static int
process_exit_poll(struct timechart *tchart,
		  struct perf_evsel *evsel,
		  struct perf_sample *sample)
{
	long ret = perf_evsel__intval(evsel, sample, "ret");
	return pid_end_io_sample(tchart, sample->tid, IOTYPE_POLL,
				 sample->time, ret);
}

A
Arjan van de Ven 已提交
961 962 963
/*
 * Sort the pid datastructure
 */
964
static void sort_pids(struct timechart *tchart)
A
Arjan van de Ven 已提交
965 966 967 968 969 970
{
	struct per_pid *new_list, *p, *cursor, *prev;
	/* sort by ppid first, then by pid, lowest to highest */

	new_list = NULL;

971 972 973
	while (tchart->all_data) {
		p = tchart->all_data;
		tchart->all_data = p->next;
A
Arjan van de Ven 已提交
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005
		p->next = NULL;

		if (new_list == NULL) {
			new_list = p;
			p->next = NULL;
			continue;
		}
		prev = NULL;
		cursor = new_list;
		while (cursor) {
			if (cursor->ppid > p->ppid ||
				(cursor->ppid == p->ppid && cursor->pid > p->pid)) {
				/* must insert before */
				if (prev) {
					p->next = prev->next;
					prev->next = p;
					cursor = NULL;
					continue;
				} else {
					p->next = new_list;
					new_list = p;
					cursor = NULL;
					continue;
				}
			}

			prev = cursor;
			cursor = cursor->next;
			if (!cursor)
				prev->next = p;
		}
	}
1006
	tchart->all_data = new_list;
A
Arjan van de Ven 已提交
1007 1008 1009
}


1010
static void draw_c_p_states(struct timechart *tchart)
A
Arjan van de Ven 已提交
1011 1012
{
	struct power_event *pwr;
1013
	pwr = tchart->power_events;
A
Arjan van de Ven 已提交
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023

	/*
	 * two pass drawing so that the P state bars are on top of the C state blocks
	 */
	while (pwr) {
		if (pwr->type == CSTATE)
			svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
		pwr = pwr->next;
	}

1024
	pwr = tchart->power_events;
A
Arjan van de Ven 已提交
1025 1026 1027
	while (pwr) {
		if (pwr->type == PSTATE) {
			if (!pwr->state)
1028
				pwr->state = tchart->min_freq;
A
Arjan van de Ven 已提交
1029 1030 1031 1032 1033 1034
			svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
		}
		pwr = pwr->next;
	}
}

1035
static void draw_wakeups(struct timechart *tchart)
A
Arjan van de Ven 已提交
1036 1037 1038 1039 1040
{
	struct wake_event *we;
	struct per_pid *p;
	struct per_pidcomm *c;

1041
	we = tchart->wake_events;
A
Arjan van de Ven 已提交
1042 1043
	while (we) {
		int from = 0, to = 0;
1044
		char *task_from = NULL, *task_to = NULL;
A
Arjan van de Ven 已提交
1045 1046

		/* locate the column of the waker and wakee */
1047
		p = tchart->all_data;
A
Arjan van de Ven 已提交
1048 1049 1050 1051 1052
		while (p) {
			if (p->pid == we->waker || p->pid == we->wakee) {
				c = p->all;
				while (c) {
					if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
1053
						if (p->pid == we->waker && !from) {
A
Arjan van de Ven 已提交
1054
							from = c->Y;
1055
							task_from = strdup(c->comm);
1056
						}
1057
						if (p->pid == we->wakee && !to) {
A
Arjan van de Ven 已提交
1058
							to = c->Y;
1059
							task_to = strdup(c->comm);
1060
						}
A
Arjan van de Ven 已提交
1061 1062 1063
					}
					c = c->next;
				}
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
				c = p->all;
				while (c) {
					if (p->pid == we->waker && !from) {
						from = c->Y;
						task_from = strdup(c->comm);
					}
					if (p->pid == we->wakee && !to) {
						to = c->Y;
						task_to = strdup(c->comm);
					}
					c = c->next;
				}
A
Arjan van de Ven 已提交
1076 1077 1078 1079
			}
			p = p->next;
		}

1080 1081 1082 1083 1084 1085 1086 1087 1088
		if (!task_from) {
			task_from = malloc(40);
			sprintf(task_from, "[%i]", we->waker);
		}
		if (!task_to) {
			task_to = malloc(40);
			sprintf(task_to, "[%i]", we->wakee);
		}

A
Arjan van de Ven 已提交
1089
		if (we->waker == -1)
1090
			svg_interrupt(we->time, to, we->backtrace);
A
Arjan van de Ven 已提交
1091
		else if (from && to && abs(from - to) == 1)
1092
			svg_wakeline(we->time, from, to, we->backtrace);
A
Arjan van de Ven 已提交
1093
		else
1094 1095
			svg_partial_wakeline(we->time, from, task_from, to,
					     task_to, we->backtrace);
A
Arjan van de Ven 已提交
1096
		we = we->next;
1097 1098 1099

		free(task_from);
		free(task_to);
A
Arjan van de Ven 已提交
1100 1101 1102
	}
}

1103
static void draw_cpu_usage(struct timechart *tchart)
A
Arjan van de Ven 已提交
1104 1105 1106 1107
{
	struct per_pid *p;
	struct per_pidcomm *c;
	struct cpu_sample *sample;
1108
	p = tchart->all_data;
A
Arjan van de Ven 已提交
1109 1110 1111 1112 1113
	while (p) {
		c = p->all;
		while (c) {
			sample = c->samples;
			while (sample) {
1114 1115 1116 1117
				if (sample->type == TYPE_RUNNING) {
					svg_process(sample->cpu,
						    sample->start_time,
						    sample->end_time,
1118
						    p->pid,
1119 1120 1121
						    c->comm,
						    sample->backtrace);
				}
A
Arjan van de Ven 已提交
1122 1123 1124 1125 1126 1127 1128 1129 1130

				sample = sample->next;
			}
			c = c->next;
		}
		p = p->next;
	}
}

1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
static void draw_io_bars(struct timechart *tchart)
{
	const char *suf;
	double bytes;
	char comm[256];
	struct per_pid *p;
	struct per_pidcomm *c;
	struct io_sample *sample;
	int Y = 1;

	p = tchart->all_data;
	while (p) {
		c = p->all;
		while (c) {
			if (!c->display) {
				c->Y = 0;
				c = c->next;
				continue;
			}

			svg_box(Y, c->start_time, c->end_time, "process3");
			sample = c->io_samples;
			for (sample = c->io_samples; sample; sample = sample->next) {
				double h = (double)sample->bytes / c->max_bytes;

1156 1157 1158 1159
				if (tchart->skip_eagain &&
				    sample->err == -EAGAIN)
					continue;

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
				if (sample->err)
					h = 1;

				if (sample->type == IOTYPE_SYNC)
					svg_fbox(Y,
						sample->start_time,
						sample->end_time,
						1,
						sample->err ? "error" : "sync",
						sample->fd,
						sample->err,
						sample->merges);
				else if (sample->type == IOTYPE_POLL)
					svg_fbox(Y,
						sample->start_time,
						sample->end_time,
						1,
						sample->err ? "error" : "poll",
						sample->fd,
						sample->err,
						sample->merges);
				else if (sample->type == IOTYPE_READ)
					svg_ubox(Y,
						sample->start_time,
						sample->end_time,
						h,
						sample->err ? "error" : "disk",
						sample->fd,
						sample->err,
						sample->merges);
				else if (sample->type == IOTYPE_WRITE)
					svg_lbox(Y,
						sample->start_time,
						sample->end_time,
						h,
						sample->err ? "error" : "disk",
						sample->fd,
						sample->err,
						sample->merges);
				else if (sample->type == IOTYPE_RX)
					svg_ubox(Y,
						sample->start_time,
						sample->end_time,
						h,
						sample->err ? "error" : "net",
						sample->fd,
						sample->err,
						sample->merges);
				else if (sample->type == IOTYPE_TX)
					svg_lbox(Y,
						sample->start_time,
						sample->end_time,
						h,
						sample->err ? "error" : "net",
						sample->fd,
						sample->err,
						sample->merges);
			}

			suf = "";
			bytes = c->total_bytes;
			if (bytes > 1024) {
				bytes = bytes / 1024;
				suf = "K";
			}
			if (bytes > 1024) {
				bytes = bytes / 1024;
				suf = "M";
			}
			if (bytes > 1024) {
				bytes = bytes / 1024;
				suf = "G";
			}


			sprintf(comm, "%s:%i (%3.1f %sbytes)", c->comm ?: "", p->pid, bytes, suf);
			svg_text(Y, c->start_time, comm);

			c->Y = Y;
			Y++;
			c = c->next;
		}
		p = p->next;
	}
}

1246
static void draw_process_bars(struct timechart *tchart)
A
Arjan van de Ven 已提交
1247 1248 1249 1250 1251 1252
{
	struct per_pid *p;
	struct per_pidcomm *c;
	struct cpu_sample *sample;
	int Y = 0;

1253
	Y = 2 * tchart->numcpus + 2;
A
Arjan van de Ven 已提交
1254

1255
	p = tchart->all_data;
A
Arjan van de Ven 已提交
1256 1257 1258 1259 1260 1261 1262 1263 1264
	while (p) {
		c = p->all;
		while (c) {
			if (!c->display) {
				c->Y = 0;
				c = c->next;
				continue;
			}

1265
			svg_box(Y, c->start_time, c->end_time, "process");
A
Arjan van de Ven 已提交
1266 1267 1268
			sample = c->samples;
			while (sample) {
				if (sample->type == TYPE_RUNNING)
1269 1270 1271 1272
					svg_running(Y, sample->cpu,
						    sample->start_time,
						    sample->end_time,
						    sample->backtrace);
A
Arjan van de Ven 已提交
1273
				if (sample->type == TYPE_BLOCKED)
1274 1275 1276 1277
					svg_blocked(Y, sample->cpu,
						    sample->start_time,
						    sample->end_time,
						    sample->backtrace);
A
Arjan van de Ven 已提交
1278
				if (sample->type == TYPE_WAITING)
1279 1280 1281 1282
					svg_waiting(Y, sample->cpu,
						    sample->start_time,
						    sample->end_time,
						    sample->backtrace);
A
Arjan van de Ven 已提交
1283 1284 1285 1286 1287 1288
				sample = sample->next;
			}

			if (c->comm) {
				char comm[256];
				if (c->total_time > 5000000000) /* 5 seconds */
1289
					sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / (double)NSEC_PER_SEC);
A
Arjan van de Ven 已提交
1290
				else
1291
					sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / (double)NSEC_PER_MSEC);
A
Arjan van de Ven 已提交
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302

				svg_text(Y, c->start_time, comm);
			}
			c->Y = Y;
			Y++;
			c = c->next;
		}
		p = p->next;
	}
}

1303 1304
static void add_process_filter(const char *string)
{
1305 1306
	int pid = strtoull(string, NULL, 10);
	struct process_filter *filt = malloc(sizeof(*filt));
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334

	if (!filt)
		return;

	filt->name = strdup(string);
	filt->pid  = pid;
	filt->next = process_filter;

	process_filter = filt;
}

static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
{
	struct process_filter *filt;
	if (!process_filter)
		return 1;

	filt = process_filter;
	while (filt) {
		if (filt->pid && p->pid == filt->pid)
			return 1;
		if (strcmp(filt->name, c->comm) == 0)
			return 1;
		filt = filt->next;
	}
	return 0;
}

1335
static int determine_display_tasks_filtered(struct timechart *tchart)
1336 1337 1338 1339 1340
{
	struct per_pid *p;
	struct per_pidcomm *c;
	int count = 0;

1341
	p = tchart->all_data;
1342 1343 1344
	while (p) {
		p->display = 0;
		if (p->start_time == 1)
1345
			p->start_time = tchart->first_time;
1346 1347 1348

		/* no exit marker, task kept running to the end */
		if (p->end_time == 0)
1349
			p->end_time = tchart->last_time;
1350 1351 1352 1353 1354 1355 1356

		c = p->all;

		while (c) {
			c->display = 0;

			if (c->start_time == 1)
1357
				c->start_time = tchart->first_time;
1358 1359 1360 1361 1362 1363 1364 1365

			if (passes_filter(p, c)) {
				c->display = 1;
				p->display = 1;
				count++;
			}

			if (c->end_time == 0)
1366
				c->end_time = tchart->last_time;
1367 1368 1369 1370 1371 1372 1373 1374

			c = c->next;
		}
		p = p->next;
	}
	return count;
}

1375
static int determine_display_tasks(struct timechart *tchart, u64 threshold)
A
Arjan van de Ven 已提交
1376 1377 1378 1379 1380
{
	struct per_pid *p;
	struct per_pidcomm *c;
	int count = 0;

1381
	p = tchart->all_data;
A
Arjan van de Ven 已提交
1382 1383 1384
	while (p) {
		p->display = 0;
		if (p->start_time == 1)
1385
			p->start_time = tchart->first_time;
A
Arjan van de Ven 已提交
1386 1387 1388

		/* no exit marker, task kept running to the end */
		if (p->end_time == 0)
1389
			p->end_time = tchart->last_time;
1390
		if (p->total_time >= threshold)
A
Arjan van de Ven 已提交
1391 1392 1393 1394 1395 1396 1397 1398
			p->display = 1;

		c = p->all;

		while (c) {
			c->display = 0;

			if (c->start_time == 1)
1399
				c->start_time = tchart->first_time;
A
Arjan van de Ven 已提交
1400

1401
			if (c->total_time >= threshold) {
A
Arjan van de Ven 已提交
1402 1403 1404 1405 1406
				c->display = 1;
				count++;
			}

			if (c->end_time == 0)
1407
				c->end_time = tchart->last_time;
A
Arjan van de Ven 已提交
1408 1409 1410 1411 1412 1413 1414 1415

			c = c->next;
		}
		p = p->next;
	}
	return count;
}

1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
static int determine_display_io_tasks(struct timechart *timechart, u64 threshold)
{
	struct per_pid *p;
	struct per_pidcomm *c;
	int count = 0;

	p = timechart->all_data;
	while (p) {
		/* no exit marker, task kept running to the end */
		if (p->end_time == 0)
			p->end_time = timechart->last_time;

		c = p->all;

		while (c) {
			c->display = 0;

			if (c->total_bytes >= threshold) {
				c->display = 1;
				count++;
			}
A
Arjan van de Ven 已提交
1437

1438 1439 1440 1441 1442 1443 1444 1445 1446
			if (c->end_time == 0)
				c->end_time = timechart->last_time;

			c = c->next;
		}
		p = p->next;
	}
	return count;
}
A
Arjan van de Ven 已提交
1447

1448
#define BYTES_THRESH (1 * 1024 * 1024)
A
Arjan van de Ven 已提交
1449 1450
#define TIME_THRESH 10000000

1451
static void write_svg_file(struct timechart *tchart, const char *filename)
A
Arjan van de Ven 已提交
1452 1453 1454
{
	u64 i;
	int count;
1455
	int thresh = tchart->io_events ? BYTES_THRESH : TIME_THRESH;
A
Arjan van de Ven 已提交
1456

1457 1458
	if (tchart->power_only)
		tchart->proc_num = 0;
A
Arjan van de Ven 已提交
1459

1460 1461 1462
	/* We'd like to show at least proc_num tasks;
	 * be less picky if we have fewer */
	do {
1463 1464 1465 1466 1467 1468
		if (process_filter)
			count = determine_display_tasks_filtered(tchart);
		else if (tchart->io_events)
			count = determine_display_io_tasks(tchart, thresh);
		else
			count = determine_display_tasks(tchart, thresh);
1469
		thresh /= 10;
1470
	} while (!process_filter && thresh && count < tchart->proc_num);
A
Arjan van de Ven 已提交
1471

1472 1473 1474
	if (!tchart->proc_num)
		count = 0;

1475 1476
	if (tchart->io_events) {
		open_svg(filename, 0, count, tchart->first_time, tchart->last_time);
A
Arjan van de Ven 已提交
1477

1478 1479
		svg_time_grid(0.5);
		svg_io_legenda();
A
Arjan van de Ven 已提交
1480

1481 1482 1483
		draw_io_bars(tchart);
	} else {
		open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
A
Arjan van de Ven 已提交
1484

1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
		svg_time_grid(0);

		svg_legenda();

		for (i = 0; i < tchart->numcpus; i++)
			svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);

		draw_cpu_usage(tchart);
		if (tchart->proc_num)
			draw_process_bars(tchart);
		if (!tchart->tasks_only)
			draw_c_p_states(tchart);
		if (tchart->proc_num)
			draw_wakeups(tchart);
	}
A
Arjan van de Ven 已提交
1500 1501 1502 1503

	svg_close();
}

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515
static int process_header(struct perf_file_section *section __maybe_unused,
			  struct perf_header *ph,
			  int feat,
			  int fd __maybe_unused,
			  void *data)
{
	struct timechart *tchart = data;

	switch (feat) {
	case HEADER_NRCPUS:
		tchart->numcpus = ph->env.nr_cpus_avail;
		break;
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527

	case HEADER_CPU_TOPOLOGY:
		if (!tchart->topology)
			break;

		if (svg_build_topology_map(ph->env.sibling_cores,
					   ph->env.nr_sibling_cores,
					   ph->env.sibling_threads,
					   ph->env.nr_sibling_threads))
			fprintf(stderr, "problem building topology\n");
		break;

1528 1529 1530 1531 1532 1533 1534
	default:
		break;
	}

	return 0;
}

1535
static int __cmd_timechart(struct timechart *tchart, const char *output_name)
1536
{
1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
	const struct perf_evsel_str_handler power_tracepoints[] = {
		{ "power:cpu_idle",		process_sample_cpu_idle },
		{ "power:cpu_frequency",	process_sample_cpu_frequency },
		{ "sched:sched_wakeup",		process_sample_sched_wakeup },
		{ "sched:sched_switch",		process_sample_sched_switch },
#ifdef SUPPORT_OLD_POWER_EVENTS
		{ "power:power_start",		process_sample_power_start },
		{ "power:power_end",		process_sample_power_end },
		{ "power:power_frequency",	process_sample_power_frequency },
#endif
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596

		{ "syscalls:sys_enter_read",		process_enter_read },
		{ "syscalls:sys_enter_pread64",		process_enter_read },
		{ "syscalls:sys_enter_readv",		process_enter_read },
		{ "syscalls:sys_enter_preadv",		process_enter_read },
		{ "syscalls:sys_enter_write",		process_enter_write },
		{ "syscalls:sys_enter_pwrite64",	process_enter_write },
		{ "syscalls:sys_enter_writev",		process_enter_write },
		{ "syscalls:sys_enter_pwritev",		process_enter_write },
		{ "syscalls:sys_enter_sync",		process_enter_sync },
		{ "syscalls:sys_enter_sync_file_range",	process_enter_sync },
		{ "syscalls:sys_enter_fsync",		process_enter_sync },
		{ "syscalls:sys_enter_msync",		process_enter_sync },
		{ "syscalls:sys_enter_recvfrom",	process_enter_rx },
		{ "syscalls:sys_enter_recvmmsg",	process_enter_rx },
		{ "syscalls:sys_enter_recvmsg",		process_enter_rx },
		{ "syscalls:sys_enter_sendto",		process_enter_tx },
		{ "syscalls:sys_enter_sendmsg",		process_enter_tx },
		{ "syscalls:sys_enter_sendmmsg",	process_enter_tx },
		{ "syscalls:sys_enter_epoll_pwait",	process_enter_poll },
		{ "syscalls:sys_enter_epoll_wait",	process_enter_poll },
		{ "syscalls:sys_enter_poll",		process_enter_poll },
		{ "syscalls:sys_enter_ppoll",		process_enter_poll },
		{ "syscalls:sys_enter_pselect6",	process_enter_poll },
		{ "syscalls:sys_enter_select",		process_enter_poll },

		{ "syscalls:sys_exit_read",		process_exit_read },
		{ "syscalls:sys_exit_pread64",		process_exit_read },
		{ "syscalls:sys_exit_readv",		process_exit_read },
		{ "syscalls:sys_exit_preadv",		process_exit_read },
		{ "syscalls:sys_exit_write",		process_exit_write },
		{ "syscalls:sys_exit_pwrite64",		process_exit_write },
		{ "syscalls:sys_exit_writev",		process_exit_write },
		{ "syscalls:sys_exit_pwritev",		process_exit_write },
		{ "syscalls:sys_exit_sync",		process_exit_sync },
		{ "syscalls:sys_exit_sync_file_range",	process_exit_sync },
		{ "syscalls:sys_exit_fsync",		process_exit_sync },
		{ "syscalls:sys_exit_msync",		process_exit_sync },
		{ "syscalls:sys_exit_recvfrom",		process_exit_rx },
		{ "syscalls:sys_exit_recvmmsg",		process_exit_rx },
		{ "syscalls:sys_exit_recvmsg",		process_exit_rx },
		{ "syscalls:sys_exit_sendto",		process_exit_tx },
		{ "syscalls:sys_exit_sendmsg",		process_exit_tx },
		{ "syscalls:sys_exit_sendmmsg",		process_exit_tx },
		{ "syscalls:sys_exit_epoll_pwait",	process_exit_poll },
		{ "syscalls:sys_exit_epoll_wait",	process_exit_poll },
		{ "syscalls:sys_exit_poll",		process_exit_poll },
		{ "syscalls:sys_exit_ppoll",		process_exit_poll },
		{ "syscalls:sys_exit_pselect6",		process_exit_poll },
		{ "syscalls:sys_exit_select",		process_exit_poll },
1597
	};
1598
	struct perf_data data = {
J
Jiri Olsa 已提交
1599 1600 1601
		.path  = input_name,
		.mode  = PERF_DATA_MODE_READ,
		.force = tchart->force,
1602 1603
	};

1604
	struct perf_session *session = perf_session__new(&data, false,
1605
							 &tchart->tool);
1606
	int ret = -EINVAL;
A
Arjan van de Ven 已提交
1607

1608
	if (session == NULL)
1609
		return -1;
1610

1611
	symbol__init(&session->header.env);
1612

1613
	(void)perf_header__process_sections(&session->header,
1614
					    perf_data__fd(session->data),
1615 1616 1617
					    tchart,
					    process_header);

1618 1619 1620
	if (!perf_session__has_traces(session, "timechart record"))
		goto out_delete;

1621 1622 1623 1624 1625 1626
	if (perf_session__set_tracepoints_handlers(session,
						   power_tracepoints)) {
		pr_err("Initializing session tracepoint handlers failed\n");
		goto out_delete;
	}

1627
	ret = perf_session__process_events(session);
1628
	if (ret)
1629
		goto out_delete;
A
Arjan van de Ven 已提交
1630

1631
	end_sample_processing(tchart);
A
Arjan van de Ven 已提交
1632

1633
	sort_pids(tchart);
A
Arjan van de Ven 已提交
1634

1635
	write_svg_file(tchart, output_name);
A
Arjan van de Ven 已提交
1636

1637
	pr_info("Written %2.1f seconds of trace to %s.\n",
1638
		(tchart->last_time - tchart->first_time) / (double)NSEC_PER_SEC, output_name);
1639 1640 1641
out_delete:
	perf_session__delete(session);
	return ret;
A
Arjan van de Ven 已提交
1642 1643
}

1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728
static int timechart__io_record(int argc, const char **argv)
{
	unsigned int rec_argc, i;
	const char **rec_argv;
	const char **p;
	char *filter = NULL;

	const char * const common_args[] = {
		"record", "-a", "-R", "-c", "1",
	};
	unsigned int common_args_nr = ARRAY_SIZE(common_args);

	const char * const disk_events[] = {
		"syscalls:sys_enter_read",
		"syscalls:sys_enter_pread64",
		"syscalls:sys_enter_readv",
		"syscalls:sys_enter_preadv",
		"syscalls:sys_enter_write",
		"syscalls:sys_enter_pwrite64",
		"syscalls:sys_enter_writev",
		"syscalls:sys_enter_pwritev",
		"syscalls:sys_enter_sync",
		"syscalls:sys_enter_sync_file_range",
		"syscalls:sys_enter_fsync",
		"syscalls:sys_enter_msync",

		"syscalls:sys_exit_read",
		"syscalls:sys_exit_pread64",
		"syscalls:sys_exit_readv",
		"syscalls:sys_exit_preadv",
		"syscalls:sys_exit_write",
		"syscalls:sys_exit_pwrite64",
		"syscalls:sys_exit_writev",
		"syscalls:sys_exit_pwritev",
		"syscalls:sys_exit_sync",
		"syscalls:sys_exit_sync_file_range",
		"syscalls:sys_exit_fsync",
		"syscalls:sys_exit_msync",
	};
	unsigned int disk_events_nr = ARRAY_SIZE(disk_events);

	const char * const net_events[] = {
		"syscalls:sys_enter_recvfrom",
		"syscalls:sys_enter_recvmmsg",
		"syscalls:sys_enter_recvmsg",
		"syscalls:sys_enter_sendto",
		"syscalls:sys_enter_sendmsg",
		"syscalls:sys_enter_sendmmsg",

		"syscalls:sys_exit_recvfrom",
		"syscalls:sys_exit_recvmmsg",
		"syscalls:sys_exit_recvmsg",
		"syscalls:sys_exit_sendto",
		"syscalls:sys_exit_sendmsg",
		"syscalls:sys_exit_sendmmsg",
	};
	unsigned int net_events_nr = ARRAY_SIZE(net_events);

	const char * const poll_events[] = {
		"syscalls:sys_enter_epoll_pwait",
		"syscalls:sys_enter_epoll_wait",
		"syscalls:sys_enter_poll",
		"syscalls:sys_enter_ppoll",
		"syscalls:sys_enter_pselect6",
		"syscalls:sys_enter_select",

		"syscalls:sys_exit_epoll_pwait",
		"syscalls:sys_exit_epoll_wait",
		"syscalls:sys_exit_poll",
		"syscalls:sys_exit_ppoll",
		"syscalls:sys_exit_pselect6",
		"syscalls:sys_exit_select",
	};
	unsigned int poll_events_nr = ARRAY_SIZE(poll_events);

	rec_argc = common_args_nr +
		disk_events_nr * 4 +
		net_events_nr * 4 +
		poll_events_nr * 4 +
		argc;
	rec_argv = calloc(rec_argc + 1, sizeof(char *));

	if (rec_argv == NULL)
		return -ENOMEM;

1729 1730
	if (asprintf(&filter, "common_pid != %d", getpid()) < 0) {
		free(rec_argv);
1731
		return -ENOMEM;
1732
	}
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774

	p = rec_argv;
	for (i = 0; i < common_args_nr; i++)
		*p++ = strdup(common_args[i]);

	for (i = 0; i < disk_events_nr; i++) {
		if (!is_valid_tracepoint(disk_events[i])) {
			rec_argc -= 4;
			continue;
		}

		*p++ = "-e";
		*p++ = strdup(disk_events[i]);
		*p++ = "--filter";
		*p++ = filter;
	}
	for (i = 0; i < net_events_nr; i++) {
		if (!is_valid_tracepoint(net_events[i])) {
			rec_argc -= 4;
			continue;
		}

		*p++ = "-e";
		*p++ = strdup(net_events[i]);
		*p++ = "--filter";
		*p++ = filter;
	}
	for (i = 0; i < poll_events_nr; i++) {
		if (!is_valid_tracepoint(poll_events[i])) {
			rec_argc -= 4;
			continue;
		}

		*p++ = "-e";
		*p++ = strdup(poll_events[i]);
		*p++ = "--filter";
		*p++ = filter;
	}

	for (i = 0; i < (unsigned int)argc; i++)
		*p++ = argv[i];

1775
	return cmd_record(rec_argc, rec_argv);
1776 1777 1778
}


1779
static int timechart__record(struct timechart *tchart, int argc, const char **argv)
1780
{
1781 1782 1783 1784 1785 1786
	unsigned int rec_argc, i, j;
	const char **rec_argv;
	const char **p;
	unsigned int record_elems;

	const char * const common_args[] = {
1787
		"record", "-a", "-R", "-c", "1",
1788 1789 1790
	};
	unsigned int common_args_nr = ARRAY_SIZE(common_args);

1791 1792 1793 1794 1795
	const char * const backtrace_args[] = {
		"-g",
	};
	unsigned int backtrace_args_no = ARRAY_SIZE(backtrace_args);

1796 1797 1798 1799 1800 1801 1802 1803
	const char * const power_args[] = {
		"-e", "power:cpu_frequency",
		"-e", "power:cpu_idle",
	};
	unsigned int power_args_nr = ARRAY_SIZE(power_args);

	const char * const old_power_args[] = {
#ifdef SUPPORT_OLD_POWER_EVENTS
1804 1805 1806 1807
		"-e", "power:power_start",
		"-e", "power:power_end",
		"-e", "power:power_frequency",
#endif
1808 1809 1810 1811
	};
	unsigned int old_power_args_nr = ARRAY_SIZE(old_power_args);

	const char * const tasks_args[] = {
1812 1813 1814
		"-e", "sched:sched_wakeup",
		"-e", "sched:sched_switch",
	};
1815
	unsigned int tasks_args_nr = ARRAY_SIZE(tasks_args);
1816 1817 1818 1819 1820

#ifdef SUPPORT_OLD_POWER_EVENTS
	if (!is_valid_tracepoint("power:cpu_idle") &&
	    is_valid_tracepoint("power:power_start")) {
		use_old_power_events = 1;
1821 1822 1823
		power_args_nr = 0;
	} else {
		old_power_args_nr = 0;
1824 1825
	}
#endif
1826

1827
	if (tchart->power_only)
1828 1829
		tasks_args_nr = 0;

1830
	if (tchart->tasks_only) {
1831 1832 1833 1834
		power_args_nr = 0;
		old_power_args_nr = 0;
	}

1835
	if (!tchart->with_backtrace)
1836 1837
		backtrace_args_no = 0;

1838
	record_elems = common_args_nr + tasks_args_nr +
1839
		power_args_nr + old_power_args_nr + backtrace_args_no;
1840 1841

	rec_argc = record_elems + argc;
1842 1843
	rec_argv = calloc(rec_argc + 1, sizeof(char *));

1844 1845 1846
	if (rec_argv == NULL)
		return -ENOMEM;

1847 1848 1849 1850
	p = rec_argv;
	for (i = 0; i < common_args_nr; i++)
		*p++ = strdup(common_args[i]);

1851 1852 1853
	for (i = 0; i < backtrace_args_no; i++)
		*p++ = strdup(backtrace_args[i]);

1854 1855 1856 1857 1858
	for (i = 0; i < tasks_args_nr; i++)
		*p++ = strdup(tasks_args[i]);

	for (i = 0; i < power_args_nr; i++)
		*p++ = strdup(power_args[i]);
1859

1860 1861
	for (i = 0; i < old_power_args_nr; i++)
		*p++ = strdup(old_power_args[i]);
1862

1863
	for (j = 0; j < (unsigned int)argc; j++)
1864 1865
		*p++ = argv[j];

1866
	return cmd_record(rec_argc, rec_argv);
1867 1868
}

1869
static int
1870 1871
parse_process(const struct option *opt __maybe_unused, const char *arg,
	      int __maybe_unused unset)
1872 1873 1874 1875 1876 1877
{
	if (arg)
		add_process_filter(arg);
	return 0;
}

1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
static int
parse_highlight(const struct option *opt __maybe_unused, const char *arg,
		int __maybe_unused unset)
{
	unsigned long duration = strtoul(arg, NULL, 0);

	if (svg_highlight || svg_highlight_name)
		return -1;

	if (duration)
		svg_highlight = duration;
	else
		svg_highlight_name = strdup(arg);

	return 0;
}

1895 1896 1897 1898 1899 1900 1901 1902 1903
static int
parse_time(const struct option *opt, const char *arg, int __maybe_unused unset)
{
	char unit = 'n';
	u64 *value = opt->value;

	if (sscanf(arg, "%" PRIu64 "%cs", value, &unit) > 0) {
		switch (unit) {
		case 'm':
1904
			*value *= NSEC_PER_MSEC;
1905 1906
			break;
		case 'u':
1907
			*value *= NSEC_PER_USEC;
1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
			break;
		case 'n':
			break;
		default:
			return -1;
		}
	}

	return 0;
}

1919
int cmd_timechart(int argc, const char **argv)
1920
{
1921 1922 1923 1924 1925 1926
	struct timechart tchart = {
		.tool = {
			.comm		 = process_comm_event,
			.fork		 = process_fork_event,
			.exit		 = process_exit_event,
			.sample		 = process_sample_event,
1927
			.ordered_events	 = true,
1928 1929
		},
		.proc_num = 15,
1930
		.min_time = NSEC_PER_MSEC,
1931
		.merge_dist = 1000,
1932
	};
1933
	const char *output_name = "output.svg";
1934 1935 1936 1937 1938
	const struct option timechart_common_options[] = {
	OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
	OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only, "output processes data only"),
	OPT_END()
	};
1939
	const struct option timechart_options[] = {
1940 1941 1942
	OPT_STRING('i', "input", &input_name, "file", "input file name"),
	OPT_STRING('o', "output", &output_name, "file", "output file name"),
	OPT_INTEGER('w', "width", &svg_page_width, "page width"),
1943 1944 1945
	OPT_CALLBACK(0, "highlight", NULL, "duration or task name",
		      "highlight tasks. Pass duration in ns or process name.",
		       parse_highlight),
1946 1947 1948
	OPT_CALLBACK('p', "process", NULL, "process",
		      "process selector. Pass a pid or process name.",
		       parse_process),
1949 1950 1951
	OPT_CALLBACK(0, "symfs", NULL, "directory",
		     "Look for files with symbols relative to this directory",
		     symbol__config_symfs),
1952
	OPT_INTEGER('n', "proc-num", &tchart.proc_num,
1953
		    "min. number of tasks to print"),
1954 1955
	OPT_BOOLEAN('t', "topology", &tchart.topology,
		    "sort CPUs according to topology"),
1956 1957 1958 1959 1960 1961 1962 1963
	OPT_BOOLEAN(0, "io-skip-eagain", &tchart.skip_eagain,
		    "skip EAGAIN errors"),
	OPT_CALLBACK(0, "io-min-time", &tchart.min_time, "time",
		     "all IO faster than min-time will visually appear longer",
		     parse_time),
	OPT_CALLBACK(0, "io-merge-dist", &tchart.merge_dist, "time",
		     "merge events that are merge-dist us apart",
		     parse_time),
1964
	OPT_BOOLEAN('f', "force", &tchart.force, "don't complain, do it"),
1965
	OPT_PARENT(timechart_common_options),
1966
	};
1967 1968
	const char * const timechart_subcommands[] = { "record", NULL };
	const char *timechart_usage[] = {
1969 1970 1971
		"perf timechart [<options>] {record}",
		NULL
	};
1972
	const struct option timechart_record_options[] = {
1973 1974
	OPT_BOOLEAN('I', "io-only", &tchart.io_only,
		    "record only IO data"),
1975
	OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
1976
	OPT_PARENT(timechart_common_options),
1977
	};
1978
	const char * const timechart_record_usage[] = {
1979 1980 1981
		"perf timechart record [<options>]",
		NULL
	};
1982 1983
	argc = parse_options_subcommand(argc, argv, timechart_options, timechart_subcommands,
			timechart_usage, PARSE_OPT_STOP_AT_NON_OPTION);
A
Arjan van de Ven 已提交
1984

1985
	if (tchart.power_only && tchart.tasks_only) {
1986 1987 1988 1989
		pr_err("-P and -T options cannot be used at the same time.\n");
		return -1;
	}

1990
	if (argc && !strncmp(argv[0], "rec", 3)) {
1991 1992
		argc = parse_options(argc, argv, timechart_record_options,
				     timechart_record_usage,
1993 1994
				     PARSE_OPT_STOP_AT_NON_OPTION);

1995
		if (tchart.power_only && tchart.tasks_only) {
1996 1997 1998 1999
			pr_err("-P and -T options cannot be used at the same time.\n");
			return -1;
		}

2000 2001 2002 2003
		if (tchart.io_only)
			return timechart__io_record(argc, argv);
		else
			return timechart__record(&tchart, argc, argv);
2004 2005
	} else if (argc)
		usage_with_options(timechart_usage, timechart_options);
A
Arjan van de Ven 已提交
2006 2007 2008

	setup_pager();

2009
	return __cmd_timechart(&tchart, output_name);
A
Arjan van de Ven 已提交
2010
}