blob: 74db2568b867b7996726674edd20539a7820dcc9 [file] [log] [blame]
Arjan van de Ven10274982009-09-12 07:53:05 +02001/*
2 * builtin-timechart.c - make an svg timechart of system activity
3 *
4 * (C) Copyright 2009 Intel Corporation
5 *
6 * Authors:
7 * Arjan van de Ven <arjan@linux.intel.com>
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; version 2
12 * of the License.
13 */
14
Jiri Olsac85cffa2013-07-11 17:28:29 +020015#include <traceevent/event-parse.h>
16
Arjan van de Ven10274982009-09-12 07:53:05 +020017#include "builtin.h"
18
19#include "util/util.h"
20
21#include "util/color.h"
22#include <linux/list.h>
23#include "util/cache.h"
Jiri Olsa59366782013-07-11 17:28:30 +020024#include "util/evlist.h"
Arnaldo Carvalho de Meloe3f42602011-11-16 17:02:54 -020025#include "util/evsel.h"
Arjan van de Ven10274982009-09-12 07:53:05 +020026#include <linux/rbtree.h>
27#include "util/symbol.h"
Arjan van de Ven10274982009-09-12 07:53:05 +020028#include "util/callchain.h"
29#include "util/strlist.h"
30
31#include "perf.h"
32#include "util/header.h"
33#include "util/parse-options.h"
34#include "util/parse-events.h"
Li Zefan5cbd0802009-12-01 14:05:16 +080035#include "util/event.h"
Arnaldo Carvalho de Melo301a0b02009-12-13 19:50:25 -020036#include "util/session.h"
Arjan van de Ven10274982009-09-12 07:53:05 +020037#include "util/svghelper.h"
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -020038#include "util/tool.h"
Jiri Olsaf5fc1412013-10-15 16:27:32 +020039#include "util/data.h"
Arjan van de Ven10274982009-09-12 07:53:05 +020040
Thomas Renninger20c457b2011-01-03 17:50:45 +010041#define SUPPORT_OLD_POWER_EVENTS 1
42#define PWR_EVENT_EXIT -1
43
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -030044struct per_pid;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -030045struct power_event;
Arnaldo Carvalho de Melo436b0da2013-11-28 13:26:33 -030046struct wake_event;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -030047
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -030048struct timechart {
49 struct perf_tool tool;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -030050 struct per_pid *all_data;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -030051 struct power_event *power_events;
Arnaldo Carvalho de Melo436b0da2013-11-28 13:26:33 -030052 struct wake_event *wake_events;
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -030053 int proc_num;
54 unsigned int numcpus;
55 u64 min_freq, /* Lowest CPU frequency seen */
56 max_freq, /* Highest CPU frequency seen */
57 turbo_frequency,
58 first_time, last_time;
59 bool power_only,
60 tasks_only,
Stanislav Fomichevc5079992013-12-02 18:37:36 +040061 with_backtrace,
62 topology;
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -030063};
Arjan van de Ven10274982009-09-12 07:53:05 +020064
Arjan van de Ven10274982009-09-12 07:53:05 +020065struct per_pidcomm;
Arjan van de Ven10274982009-09-12 07:53:05 +020066struct cpu_sample;
Arjan van de Ven10274982009-09-12 07:53:05 +020067
68/*
69 * Datastructure layout:
70 * We keep an list of "pid"s, matching the kernels notion of a task struct.
71 * Each "pid" entry, has a list of "comm"s.
72 * this is because we want to track different programs different, while
73 * exec will reuse the original pid (by design).
74 * Each comm has a list of samples that will be used to draw
75 * final graph.
76 */
77
78struct per_pid {
79 struct per_pid *next;
80
81 int pid;
82 int ppid;
83
84 u64 start_time;
85 u64 end_time;
86 u64 total_time;
87 int display;
88
89 struct per_pidcomm *all;
90 struct per_pidcomm *current;
Arjan van de Ven10274982009-09-12 07:53:05 +020091};
92
93
94struct per_pidcomm {
95 struct per_pidcomm *next;
96
97 u64 start_time;
98 u64 end_time;
99 u64 total_time;
100
101 int Y;
102 int display;
103
104 long state;
105 u64 state_since;
106
107 char *comm;
108
109 struct cpu_sample *samples;
110};
111
112struct sample_wrapper {
113 struct sample_wrapper *next;
114
115 u64 timestamp;
116 unsigned char data[0];
117};
118
119#define TYPE_NONE 0
120#define TYPE_RUNNING 1
121#define TYPE_WAITING 2
122#define TYPE_BLOCKED 3
123
124struct cpu_sample {
125 struct cpu_sample *next;
126
127 u64 start_time;
128 u64 end_time;
129 int type;
130 int cpu;
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400131 const char *backtrace;
Arjan van de Ven10274982009-09-12 07:53:05 +0200132};
133
Arjan van de Ven10274982009-09-12 07:53:05 +0200134#define CSTATE 1
135#define PSTATE 2
136
137struct power_event {
138 struct power_event *next;
139 int type;
140 int state;
141 u64 start_time;
142 u64 end_time;
143 int cpu;
144};
145
146struct wake_event {
147 struct wake_event *next;
148 int waker;
149 int wakee;
150 u64 time;
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400151 const char *backtrace;
Arjan van de Ven10274982009-09-12 07:53:05 +0200152};
153
Arjan van de Venbbe29872009-10-20 07:09:39 +0900154struct process_filter {
Li Zefan5cbd0802009-12-01 14:05:16 +0800155 char *name;
156 int pid;
157 struct process_filter *next;
Arjan van de Venbbe29872009-10-20 07:09:39 +0900158};
159
160static struct process_filter *process_filter;
161
162
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300163static struct per_pid *find_create_pid(struct timechart *tchart, int pid)
Arjan van de Ven10274982009-09-12 07:53:05 +0200164{
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300165 struct per_pid *cursor = tchart->all_data;
Arjan van de Ven10274982009-09-12 07:53:05 +0200166
167 while (cursor) {
168 if (cursor->pid == pid)
169 return cursor;
170 cursor = cursor->next;
171 }
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300172 cursor = zalloc(sizeof(*cursor));
Arjan van de Ven10274982009-09-12 07:53:05 +0200173 assert(cursor != NULL);
Arjan van de Ven10274982009-09-12 07:53:05 +0200174 cursor->pid = pid;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300175 cursor->next = tchart->all_data;
176 tchart->all_data = cursor;
Arjan van de Ven10274982009-09-12 07:53:05 +0200177 return cursor;
178}
179
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300180static void pid_set_comm(struct timechart *tchart, int pid, char *comm)
Arjan van de Ven10274982009-09-12 07:53:05 +0200181{
182 struct per_pid *p;
183 struct per_pidcomm *c;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300184 p = find_create_pid(tchart, pid);
Arjan van de Ven10274982009-09-12 07:53:05 +0200185 c = p->all;
186 while (c) {
187 if (c->comm && strcmp(c->comm, comm) == 0) {
188 p->current = c;
189 return;
190 }
191 if (!c->comm) {
192 c->comm = strdup(comm);
193 p->current = c;
194 return;
195 }
196 c = c->next;
197 }
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300198 c = zalloc(sizeof(*c));
Arjan van de Ven10274982009-09-12 07:53:05 +0200199 assert(c != NULL);
Arjan van de Ven10274982009-09-12 07:53:05 +0200200 c->comm = strdup(comm);
201 p->current = c;
202 c->next = p->all;
203 p->all = c;
204}
205
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300206static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
Arjan van de Ven10274982009-09-12 07:53:05 +0200207{
208 struct per_pid *p, *pp;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300209 p = find_create_pid(tchart, pid);
210 pp = find_create_pid(tchart, ppid);
Arjan van de Ven10274982009-09-12 07:53:05 +0200211 p->ppid = ppid;
212 if (pp->current && pp->current->comm && !p->current)
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300213 pid_set_comm(tchart, pid, pp->current->comm);
Arjan van de Ven10274982009-09-12 07:53:05 +0200214
215 p->start_time = timestamp;
216 if (p->current) {
217 p->current->start_time = timestamp;
218 p->current->state_since = timestamp;
219 }
220}
221
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300222static void pid_exit(struct timechart *tchart, int pid, u64 timestamp)
Arjan van de Ven10274982009-09-12 07:53:05 +0200223{
224 struct per_pid *p;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300225 p = find_create_pid(tchart, pid);
Arjan van de Ven10274982009-09-12 07:53:05 +0200226 p->end_time = timestamp;
227 if (p->current)
228 p->current->end_time = timestamp;
229}
230
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300231static void pid_put_sample(struct timechart *tchart, int pid, int type,
232 unsigned int cpu, u64 start, u64 end,
233 const char *backtrace)
Arjan van de Ven10274982009-09-12 07:53:05 +0200234{
235 struct per_pid *p;
236 struct per_pidcomm *c;
237 struct cpu_sample *sample;
238
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300239 p = find_create_pid(tchart, pid);
Arjan van de Ven10274982009-09-12 07:53:05 +0200240 c = p->current;
241 if (!c) {
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300242 c = zalloc(sizeof(*c));
Arjan van de Ven10274982009-09-12 07:53:05 +0200243 assert(c != NULL);
Arjan van de Ven10274982009-09-12 07:53:05 +0200244 p->current = c;
245 c->next = p->all;
246 p->all = c;
247 }
248
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300249 sample = zalloc(sizeof(*sample));
Arjan van de Ven10274982009-09-12 07:53:05 +0200250 assert(sample != NULL);
Arjan van de Ven10274982009-09-12 07:53:05 +0200251 sample->start_time = start;
252 sample->end_time = end;
253 sample->type = type;
254 sample->next = c->samples;
255 sample->cpu = cpu;
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400256 sample->backtrace = backtrace;
Arjan van de Ven10274982009-09-12 07:53:05 +0200257 c->samples = sample;
258
259 if (sample->type == TYPE_RUNNING && end > start && start > 0) {
260 c->total_time += (end-start);
261 p->total_time += (end-start);
262 }
263
264 if (c->start_time == 0 || c->start_time > start)
265 c->start_time = start;
266 if (p->start_time == 0 || p->start_time > start)
267 p->start_time = start;
Arjan van de Ven10274982009-09-12 07:53:05 +0200268}
269
270#define MAX_CPUS 4096
271
272static u64 cpus_cstate_start_times[MAX_CPUS];
273static int cpus_cstate_state[MAX_CPUS];
274static u64 cpus_pstate_start_times[MAX_CPUS];
275static u64 cpus_pstate_state[MAX_CPUS];
276
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300277static int process_comm_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200278 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300279 struct perf_sample *sample __maybe_unused,
280 struct machine *machine __maybe_unused)
Arjan van de Ven10274982009-09-12 07:53:05 +0200281{
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300282 struct timechart *tchart = container_of(tool, struct timechart, tool);
283 pid_set_comm(tchart, event->comm.tid, event->comm.comm);
Arjan van de Ven10274982009-09-12 07:53:05 +0200284 return 0;
285}
Arnaldo Carvalho de Melod8f66242009-12-13 19:50:24 -0200286
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300287static int process_fork_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200288 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300289 struct perf_sample *sample __maybe_unused,
290 struct machine *machine __maybe_unused)
Arjan van de Ven10274982009-09-12 07:53:05 +0200291{
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300292 struct timechart *tchart = container_of(tool, struct timechart, tool);
293 pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time);
Arjan van de Ven10274982009-09-12 07:53:05 +0200294 return 0;
295}
296
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300297static int process_exit_event(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -0200298 union perf_event *event,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300299 struct perf_sample *sample __maybe_unused,
300 struct machine *machine __maybe_unused)
Arjan van de Ven10274982009-09-12 07:53:05 +0200301{
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300302 struct timechart *tchart = container_of(tool, struct timechart, tool);
303 pid_exit(tchart, event->fork.pid, event->fork.time);
Arjan van de Ven10274982009-09-12 07:53:05 +0200304 return 0;
305}
306
Thomas Renninger20c457b2011-01-03 17:50:45 +0100307#ifdef SUPPORT_OLD_POWER_EVENTS
308static int use_old_power_events;
Thomas Renninger20c457b2011-01-03 17:50:45 +0100309#endif
310
Arjan van de Ven10274982009-09-12 07:53:05 +0200311static void c_state_start(int cpu, u64 timestamp, int state)
312{
313 cpus_cstate_start_times[cpu] = timestamp;
314 cpus_cstate_state[cpu] = state;
315}
316
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300317static void c_state_end(struct timechart *tchart, int cpu, u64 timestamp)
Arjan van de Ven10274982009-09-12 07:53:05 +0200318{
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300319 struct power_event *pwr = zalloc(sizeof(*pwr));
320
Arjan van de Ven10274982009-09-12 07:53:05 +0200321 if (!pwr)
322 return;
Arjan van de Ven10274982009-09-12 07:53:05 +0200323
324 pwr->state = cpus_cstate_state[cpu];
325 pwr->start_time = cpus_cstate_start_times[cpu];
326 pwr->end_time = timestamp;
327 pwr->cpu = cpu;
328 pwr->type = CSTATE;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300329 pwr->next = tchart->power_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200330
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300331 tchart->power_events = pwr;
Arjan van de Ven10274982009-09-12 07:53:05 +0200332}
333
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300334static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64 new_freq)
Arjan van de Ven10274982009-09-12 07:53:05 +0200335{
336 struct power_event *pwr;
Arjan van de Ven10274982009-09-12 07:53:05 +0200337
338 if (new_freq > 8000000) /* detect invalid data */
339 return;
340
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300341 pwr = zalloc(sizeof(*pwr));
Arjan van de Ven10274982009-09-12 07:53:05 +0200342 if (!pwr)
343 return;
Arjan van de Ven10274982009-09-12 07:53:05 +0200344
345 pwr->state = cpus_pstate_state[cpu];
346 pwr->start_time = cpus_pstate_start_times[cpu];
347 pwr->end_time = timestamp;
348 pwr->cpu = cpu;
349 pwr->type = PSTATE;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300350 pwr->next = tchart->power_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200351
352 if (!pwr->start_time)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300353 pwr->start_time = tchart->first_time;
Arjan van de Ven10274982009-09-12 07:53:05 +0200354
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300355 tchart->power_events = pwr;
Arjan van de Ven10274982009-09-12 07:53:05 +0200356
357 cpus_pstate_state[cpu] = new_freq;
358 cpus_pstate_start_times[cpu] = timestamp;
359
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300360 if ((u64)new_freq > tchart->max_freq)
361 tchart->max_freq = new_freq;
Arjan van de Ven10274982009-09-12 07:53:05 +0200362
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300363 if (new_freq < tchart->min_freq || tchart->min_freq == 0)
364 tchart->min_freq = new_freq;
Arjan van de Ven10274982009-09-12 07:53:05 +0200365
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300366 if (new_freq == tchart->max_freq - 1000)
367 tchart->turbo_frequency = tchart->max_freq;
Arjan van de Ven10274982009-09-12 07:53:05 +0200368}
369
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300370static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp,
371 int waker, int wakee, u8 flags, const char *backtrace)
Arjan van de Ven10274982009-09-12 07:53:05 +0200372{
Arjan van de Ven10274982009-09-12 07:53:05 +0200373 struct per_pid *p;
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300374 struct wake_event *we = zalloc(sizeof(*we));
Arjan van de Ven10274982009-09-12 07:53:05 +0200375
Arjan van de Ven10274982009-09-12 07:53:05 +0200376 if (!we)
377 return;
378
Arjan van de Ven10274982009-09-12 07:53:05 +0200379 we->time = timestamp;
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400380 we->waker = waker;
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400381 we->backtrace = backtrace;
Arjan van de Ven10274982009-09-12 07:53:05 +0200382
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400383 if ((flags & TRACE_FLAG_HARDIRQ) || (flags & TRACE_FLAG_SOFTIRQ))
Arjan van de Ven10274982009-09-12 07:53:05 +0200384 we->waker = -1;
385
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400386 we->wakee = wakee;
Arnaldo Carvalho de Melo436b0da2013-11-28 13:26:33 -0300387 we->next = tchart->wake_events;
388 tchart->wake_events = we;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300389 p = find_create_pid(tchart, we->wakee);
Arjan van de Ven10274982009-09-12 07:53:05 +0200390
391 if (p && p->current && p->current->state == TYPE_NONE) {
392 p->current->state_since = timestamp;
393 p->current->state = TYPE_WAITING;
394 }
395 if (p && p->current && p->current->state == TYPE_BLOCKED) {
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300396 pid_put_sample(tchart, p->pid, p->current->state, cpu,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400397 p->current->state_since, timestamp, NULL);
Arjan van de Ven10274982009-09-12 07:53:05 +0200398 p->current->state_since = timestamp;
399 p->current->state = TYPE_WAITING;
400 }
401}
402
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300403static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp,
404 int prev_pid, int next_pid, u64 prev_state,
405 const char *backtrace)
Arjan van de Ven10274982009-09-12 07:53:05 +0200406{
407 struct per_pid *p = NULL, *prev_p;
Arjan van de Ven10274982009-09-12 07:53:05 +0200408
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300409 prev_p = find_create_pid(tchart, prev_pid);
Arjan van de Ven10274982009-09-12 07:53:05 +0200410
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300411 p = find_create_pid(tchart, next_pid);
Arjan van de Ven10274982009-09-12 07:53:05 +0200412
413 if (prev_p->current && prev_p->current->state != TYPE_NONE)
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300414 pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400415 prev_p->current->state_since, timestamp,
416 backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200417 if (p && p->current) {
418 if (p->current->state != TYPE_NONE)
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300419 pid_put_sample(tchart, next_pid, p->current->state, cpu,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400420 p->current->state_since, timestamp,
421 backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200422
Julia Lawall33e26a12010-08-05 22:27:51 +0200423 p->current->state_since = timestamp;
424 p->current->state = TYPE_RUNNING;
Arjan van de Ven10274982009-09-12 07:53:05 +0200425 }
426
427 if (prev_p->current) {
428 prev_p->current->state = TYPE_NONE;
429 prev_p->current->state_since = timestamp;
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400430 if (prev_state & 2)
Arjan van de Ven10274982009-09-12 07:53:05 +0200431 prev_p->current->state = TYPE_BLOCKED;
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400432 if (prev_state == 0)
Arjan van de Ven10274982009-09-12 07:53:05 +0200433 prev_p->current->state = TYPE_WAITING;
434 }
435}
436
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400437static const char *cat_backtrace(union perf_event *event,
438 struct perf_sample *sample,
439 struct machine *machine)
440{
441 struct addr_location al;
442 unsigned int i;
443 char *p = NULL;
444 size_t p_len;
445 u8 cpumode = PERF_RECORD_MISC_USER;
446 struct addr_location tal;
447 struct ip_callchain *chain = sample->callchain;
448 FILE *f = open_memstream(&p, &p_len);
449
450 if (!f) {
451 perror("open_memstream error");
452 return NULL;
453 }
454
455 if (!chain)
456 goto exit;
457
458 if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
459 fprintf(stderr, "problem processing %d event, skipping it.\n",
460 event->header.type);
461 goto exit;
462 }
463
464 for (i = 0; i < chain->nr; i++) {
465 u64 ip;
466
467 if (callchain_param.order == ORDER_CALLEE)
468 ip = chain->ips[i];
469 else
470 ip = chain->ips[chain->nr - i - 1];
471
472 if (ip >= PERF_CONTEXT_MAX) {
473 switch (ip) {
474 case PERF_CONTEXT_HV:
475 cpumode = PERF_RECORD_MISC_HYPERVISOR;
476 break;
477 case PERF_CONTEXT_KERNEL:
478 cpumode = PERF_RECORD_MISC_KERNEL;
479 break;
480 case PERF_CONTEXT_USER:
481 cpumode = PERF_RECORD_MISC_USER;
482 break;
483 default:
484 pr_debug("invalid callchain context: "
485 "%"PRId64"\n", (s64) ip);
486
487 /*
488 * It seems the callchain is corrupted.
489 * Discard all.
490 */
Arnaldo Carvalho de Melo04662522013-12-26 17:41:15 -0300491 zfree(&p);
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400492 goto exit;
493 }
494 continue;
495 }
496
Namhyung Kimb3cef7f2014-03-17 16:59:21 -0300497 tal.filtered = 0;
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400498 thread__find_addr_location(al.thread, machine, cpumode,
499 MAP__FUNCTION, ip, &tal);
500
501 if (tal.sym)
502 fprintf(f, "..... %016" PRIx64 " %s\n", ip,
503 tal.sym->name);
504 else
505 fprintf(f, "..... %016" PRIx64 "\n", ip);
506 }
507
508exit:
509 fclose(f);
510
511 return p;
512}
513
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300514typedef int (*tracepoint_handler)(struct timechart *tchart,
515 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400516 struct perf_sample *sample,
517 const char *backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200518
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300519static int process_sample_event(struct perf_tool *tool,
Arnaldo Carvalho de Melo972ec652013-11-27 16:32:56 -0300520 union perf_event *event,
Arnaldo Carvalho de Melo8d50e5b2011-01-29 13:02:00 -0200521 struct perf_sample *sample,
Arnaldo Carvalho de Meloe3f42602011-11-16 17:02:54 -0200522 struct perf_evsel *evsel,
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300523 struct machine *machine)
Arjan van de Ven10274982009-09-12 07:53:05 +0200524{
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300525 struct timechart *tchart = container_of(tool, struct timechart, tool);
526
Arnaldo Carvalho de Meloe3f42602011-11-16 17:02:54 -0200527 if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300528 if (!tchart->first_time || tchart->first_time > sample->time)
529 tchart->first_time = sample->time;
530 if (tchart->last_time < sample->time)
531 tchart->last_time = sample->time;
Arjan van de Ven10274982009-09-12 07:53:05 +0200532 }
Arjan van de Ven10274982009-09-12 07:53:05 +0200533
Arnaldo Carvalho de Melo744a9712013-11-06 10:17:38 -0300534 if (evsel->handler != NULL) {
535 tracepoint_handler f = evsel->handler;
Stanislav Fomichev58b9a182013-12-02 18:37:35 +0400536 return f(tchart, evsel, sample,
537 cat_backtrace(event, sample, machine));
Arjan van de Ven10274982009-09-12 07:53:05 +0200538 }
Jiri Olsa59366782013-07-11 17:28:30 +0200539
Arjan van de Ven10274982009-09-12 07:53:05 +0200540 return 0;
541}
542
Jiri Olsa59366782013-07-11 17:28:30 +0200543static int
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300544process_sample_cpu_idle(struct timechart *tchart __maybe_unused,
545 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400546 struct perf_sample *sample,
547 const char *backtrace __maybe_unused)
Jiri Olsa59366782013-07-11 17:28:30 +0200548{
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400549 u32 state = perf_evsel__intval(evsel, sample, "state");
550 u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
Jiri Olsa59366782013-07-11 17:28:30 +0200551
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400552 if (state == (u32)PWR_EVENT_EXIT)
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300553 c_state_end(tchart, cpu_id, sample->time);
Jiri Olsa59366782013-07-11 17:28:30 +0200554 else
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400555 c_state_start(cpu_id, sample->time, state);
Jiri Olsa59366782013-07-11 17:28:30 +0200556 return 0;
557}
558
559static int
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300560process_sample_cpu_frequency(struct timechart *tchart,
561 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400562 struct perf_sample *sample,
563 const char *backtrace __maybe_unused)
Jiri Olsa59366782013-07-11 17:28:30 +0200564{
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400565 u32 state = perf_evsel__intval(evsel, sample, "state");
566 u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
Jiri Olsa59366782013-07-11 17:28:30 +0200567
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300568 p_state_change(tchart, cpu_id, sample->time, state);
Jiri Olsa59366782013-07-11 17:28:30 +0200569 return 0;
570}
571
572static int
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300573process_sample_sched_wakeup(struct timechart *tchart,
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300574 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400575 struct perf_sample *sample,
576 const char *backtrace)
Jiri Olsa59366782013-07-11 17:28:30 +0200577{
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400578 u8 flags = perf_evsel__intval(evsel, sample, "common_flags");
579 int waker = perf_evsel__intval(evsel, sample, "common_pid");
580 int wakee = perf_evsel__intval(evsel, sample, "pid");
Jiri Olsa59366782013-07-11 17:28:30 +0200581
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300582 sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace);
Jiri Olsa59366782013-07-11 17:28:30 +0200583 return 0;
584}
585
586static int
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300587process_sample_sched_switch(struct timechart *tchart,
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300588 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400589 struct perf_sample *sample,
590 const char *backtrace)
Jiri Olsa59366782013-07-11 17:28:30 +0200591{
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400592 int prev_pid = perf_evsel__intval(evsel, sample, "prev_pid");
593 int next_pid = perf_evsel__intval(evsel, sample, "next_pid");
594 u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
Jiri Olsa59366782013-07-11 17:28:30 +0200595
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300596 sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid,
597 prev_state, backtrace);
Jiri Olsa59366782013-07-11 17:28:30 +0200598 return 0;
599}
600
601#ifdef SUPPORT_OLD_POWER_EVENTS
602static int
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300603process_sample_power_start(struct timechart *tchart __maybe_unused,
604 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400605 struct perf_sample *sample,
606 const char *backtrace __maybe_unused)
Jiri Olsa59366782013-07-11 17:28:30 +0200607{
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400608 u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
609 u64 value = perf_evsel__intval(evsel, sample, "value");
Jiri Olsa59366782013-07-11 17:28:30 +0200610
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400611 c_state_start(cpu_id, sample->time, value);
Jiri Olsa59366782013-07-11 17:28:30 +0200612 return 0;
613}
614
615static int
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300616process_sample_power_end(struct timechart *tchart,
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300617 struct perf_evsel *evsel __maybe_unused,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400618 struct perf_sample *sample,
619 const char *backtrace __maybe_unused)
Jiri Olsa59366782013-07-11 17:28:30 +0200620{
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300621 c_state_end(tchart, sample->cpu, sample->time);
Jiri Olsa59366782013-07-11 17:28:30 +0200622 return 0;
623}
624
625static int
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300626process_sample_power_frequency(struct timechart *tchart,
627 struct perf_evsel *evsel,
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400628 struct perf_sample *sample,
629 const char *backtrace __maybe_unused)
Jiri Olsa59366782013-07-11 17:28:30 +0200630{
Stanislav Fomichev3ed0d212013-11-27 14:45:00 +0400631 u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
632 u64 value = perf_evsel__intval(evsel, sample, "value");
Jiri Olsa59366782013-07-11 17:28:30 +0200633
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300634 p_state_change(tchart, cpu_id, sample->time, value);
Jiri Olsa59366782013-07-11 17:28:30 +0200635 return 0;
636}
637#endif /* SUPPORT_OLD_POWER_EVENTS */
638
Arjan van de Ven10274982009-09-12 07:53:05 +0200639/*
640 * After the last sample we need to wrap up the current C/P state
641 * and close out each CPU for these.
642 */
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300643static void end_sample_processing(struct timechart *tchart)
Arjan van de Ven10274982009-09-12 07:53:05 +0200644{
645 u64 cpu;
646 struct power_event *pwr;
647
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300648 for (cpu = 0; cpu <= tchart->numcpus; cpu++) {
Arjan van de Ven10274982009-09-12 07:53:05 +0200649 /* C state */
650#if 0
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300651 pwr = zalloc(sizeof(*pwr));
652 if (!pwr)
653 return;
654
Arjan van de Ven10274982009-09-12 07:53:05 +0200655 pwr->state = cpus_cstate_state[cpu];
656 pwr->start_time = cpus_cstate_start_times[cpu];
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300657 pwr->end_time = tchart->last_time;
Arjan van de Ven10274982009-09-12 07:53:05 +0200658 pwr->cpu = cpu;
659 pwr->type = CSTATE;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300660 pwr->next = tchart->power_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200661
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300662 tchart->power_events = pwr;
Arjan van de Ven10274982009-09-12 07:53:05 +0200663#endif
664 /* P state */
665
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300666 pwr = zalloc(sizeof(*pwr));
Arjan van de Ven10274982009-09-12 07:53:05 +0200667 if (!pwr)
668 return;
Arjan van de Ven10274982009-09-12 07:53:05 +0200669
670 pwr->state = cpus_pstate_state[cpu];
671 pwr->start_time = cpus_pstate_start_times[cpu];
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300672 pwr->end_time = tchart->last_time;
Arjan van de Ven10274982009-09-12 07:53:05 +0200673 pwr->cpu = cpu;
674 pwr->type = PSTATE;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300675 pwr->next = tchart->power_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200676
677 if (!pwr->start_time)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300678 pwr->start_time = tchart->first_time;
Arjan van de Ven10274982009-09-12 07:53:05 +0200679 if (!pwr->state)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300680 pwr->state = tchart->min_freq;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300681 tchart->power_events = pwr;
Arjan van de Ven10274982009-09-12 07:53:05 +0200682 }
683}
684
Arjan van de Ven10274982009-09-12 07:53:05 +0200685/*
686 * Sort the pid datastructure
687 */
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300688static void sort_pids(struct timechart *tchart)
Arjan van de Ven10274982009-09-12 07:53:05 +0200689{
690 struct per_pid *new_list, *p, *cursor, *prev;
691 /* sort by ppid first, then by pid, lowest to highest */
692
693 new_list = NULL;
694
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300695 while (tchart->all_data) {
696 p = tchart->all_data;
697 tchart->all_data = p->next;
Arjan van de Ven10274982009-09-12 07:53:05 +0200698 p->next = NULL;
699
700 if (new_list == NULL) {
701 new_list = p;
702 p->next = NULL;
703 continue;
704 }
705 prev = NULL;
706 cursor = new_list;
707 while (cursor) {
708 if (cursor->ppid > p->ppid ||
709 (cursor->ppid == p->ppid && cursor->pid > p->pid)) {
710 /* must insert before */
711 if (prev) {
712 p->next = prev->next;
713 prev->next = p;
714 cursor = NULL;
715 continue;
716 } else {
717 p->next = new_list;
718 new_list = p;
719 cursor = NULL;
720 continue;
721 }
722 }
723
724 prev = cursor;
725 cursor = cursor->next;
726 if (!cursor)
727 prev->next = p;
728 }
729 }
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300730 tchart->all_data = new_list;
Arjan van de Ven10274982009-09-12 07:53:05 +0200731}
732
733
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300734static void draw_c_p_states(struct timechart *tchart)
Arjan van de Ven10274982009-09-12 07:53:05 +0200735{
736 struct power_event *pwr;
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300737 pwr = tchart->power_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200738
739 /*
740 * two pass drawing so that the P state bars are on top of the C state blocks
741 */
742 while (pwr) {
743 if (pwr->type == CSTATE)
744 svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
745 pwr = pwr->next;
746 }
747
Arnaldo Carvalho de Melo66cc3ad2013-11-28 13:23:05 -0300748 pwr = tchart->power_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200749 while (pwr) {
750 if (pwr->type == PSTATE) {
751 if (!pwr->state)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300752 pwr->state = tchart->min_freq;
Arjan van de Ven10274982009-09-12 07:53:05 +0200753 svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
754 }
755 pwr = pwr->next;
756 }
757}
758
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300759static void draw_wakeups(struct timechart *tchart)
Arjan van de Ven10274982009-09-12 07:53:05 +0200760{
761 struct wake_event *we;
762 struct per_pid *p;
763 struct per_pidcomm *c;
764
Arnaldo Carvalho de Melo436b0da2013-11-28 13:26:33 -0300765 we = tchart->wake_events;
Arjan van de Ven10274982009-09-12 07:53:05 +0200766 while (we) {
767 int from = 0, to = 0;
Arjan van de Ven4f1202c2009-09-20 18:13:28 +0200768 char *task_from = NULL, *task_to = NULL;
Arjan van de Ven10274982009-09-12 07:53:05 +0200769
770 /* locate the column of the waker and wakee */
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300771 p = tchart->all_data;
Arjan van de Ven10274982009-09-12 07:53:05 +0200772 while (p) {
773 if (p->pid == we->waker || p->pid == we->wakee) {
774 c = p->all;
775 while (c) {
776 if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
Arjan van de Venbbe29872009-10-20 07:09:39 +0900777 if (p->pid == we->waker && !from) {
Arjan van de Ven10274982009-09-12 07:53:05 +0200778 from = c->Y;
Arjan van de Ven3bc2a392009-10-20 06:46:49 +0900779 task_from = strdup(c->comm);
Arjan van de Ven4f1202c2009-09-20 18:13:28 +0200780 }
Arjan van de Venbbe29872009-10-20 07:09:39 +0900781 if (p->pid == we->wakee && !to) {
Arjan van de Ven10274982009-09-12 07:53:05 +0200782 to = c->Y;
Arjan van de Ven3bc2a392009-10-20 06:46:49 +0900783 task_to = strdup(c->comm);
Arjan van de Ven4f1202c2009-09-20 18:13:28 +0200784 }
Arjan van de Ven10274982009-09-12 07:53:05 +0200785 }
786 c = c->next;
787 }
Arjan van de Ven3bc2a392009-10-20 06:46:49 +0900788 c = p->all;
789 while (c) {
790 if (p->pid == we->waker && !from) {
791 from = c->Y;
792 task_from = strdup(c->comm);
793 }
794 if (p->pid == we->wakee && !to) {
795 to = c->Y;
796 task_to = strdup(c->comm);
797 }
798 c = c->next;
799 }
Arjan van de Ven10274982009-09-12 07:53:05 +0200800 }
801 p = p->next;
802 }
803
Arjan van de Ven3bc2a392009-10-20 06:46:49 +0900804 if (!task_from) {
805 task_from = malloc(40);
806 sprintf(task_from, "[%i]", we->waker);
807 }
808 if (!task_to) {
809 task_to = malloc(40);
810 sprintf(task_to, "[%i]", we->wakee);
811 }
812
Arjan van de Ven10274982009-09-12 07:53:05 +0200813 if (we->waker == -1)
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400814 svg_interrupt(we->time, to, we->backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200815 else if (from && to && abs(from - to) == 1)
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400816 svg_wakeline(we->time, from, to, we->backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200817 else
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400818 svg_partial_wakeline(we->time, from, task_from, to,
819 task_to, we->backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200820 we = we->next;
Arjan van de Ven3bc2a392009-10-20 06:46:49 +0900821
822 free(task_from);
823 free(task_to);
Arjan van de Ven10274982009-09-12 07:53:05 +0200824 }
825}
826
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300827static void draw_cpu_usage(struct timechart *tchart)
Arjan van de Ven10274982009-09-12 07:53:05 +0200828{
829 struct per_pid *p;
830 struct per_pidcomm *c;
831 struct cpu_sample *sample;
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300832 p = tchart->all_data;
Arjan van de Ven10274982009-09-12 07:53:05 +0200833 while (p) {
834 c = p->all;
835 while (c) {
836 sample = c->samples;
837 while (sample) {
Stanislav Fomichev8b6dcca2013-12-02 18:37:33 +0400838 if (sample->type == TYPE_RUNNING) {
839 svg_process(sample->cpu,
840 sample->start_time,
841 sample->end_time,
Stanislav Fomichevde996222013-12-02 18:37:34 +0400842 p->pid,
Stanislav Fomichev8b6dcca2013-12-02 18:37:33 +0400843 c->comm,
844 sample->backtrace);
845 }
Arjan van de Ven10274982009-09-12 07:53:05 +0200846
847 sample = sample->next;
848 }
849 c = c->next;
850 }
851 p = p->next;
852 }
853}
854
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300855static void draw_process_bars(struct timechart *tchart)
Arjan van de Ven10274982009-09-12 07:53:05 +0200856{
857 struct per_pid *p;
858 struct per_pidcomm *c;
859 struct cpu_sample *sample;
860 int Y = 0;
861
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300862 Y = 2 * tchart->numcpus + 2;
Arjan van de Ven10274982009-09-12 07:53:05 +0200863
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300864 p = tchart->all_data;
Arjan van de Ven10274982009-09-12 07:53:05 +0200865 while (p) {
866 c = p->all;
867 while (c) {
868 if (!c->display) {
869 c->Y = 0;
870 c = c->next;
871 continue;
872 }
873
Arjan van de Vena92fe7b2009-09-20 18:13:53 +0200874 svg_box(Y, c->start_time, c->end_time, "process");
Arjan van de Ven10274982009-09-12 07:53:05 +0200875 sample = c->samples;
876 while (sample) {
877 if (sample->type == TYPE_RUNNING)
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400878 svg_running(Y, sample->cpu,
879 sample->start_time,
880 sample->end_time,
881 sample->backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200882 if (sample->type == TYPE_BLOCKED)
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400883 svg_blocked(Y, sample->cpu,
884 sample->start_time,
885 sample->end_time,
886 sample->backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200887 if (sample->type == TYPE_WAITING)
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +0400888 svg_waiting(Y, sample->cpu,
889 sample->start_time,
890 sample->end_time,
891 sample->backtrace);
Arjan van de Ven10274982009-09-12 07:53:05 +0200892 sample = sample->next;
893 }
894
895 if (c->comm) {
896 char comm[256];
897 if (c->total_time > 5000000000) /* 5 seconds */
898 sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0);
899 else
900 sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0);
901
902 svg_text(Y, c->start_time, comm);
903 }
904 c->Y = Y;
905 Y++;
906 c = c->next;
907 }
908 p = p->next;
909 }
910}
911
Arjan van de Venbbe29872009-10-20 07:09:39 +0900912static void add_process_filter(const char *string)
913{
Arnaldo Carvalho de Meloe0dcd6f2012-09-24 11:16:40 -0300914 int pid = strtoull(string, NULL, 10);
915 struct process_filter *filt = malloc(sizeof(*filt));
Arjan van de Venbbe29872009-10-20 07:09:39 +0900916
Arjan van de Venbbe29872009-10-20 07:09:39 +0900917 if (!filt)
918 return;
919
920 filt->name = strdup(string);
921 filt->pid = pid;
922 filt->next = process_filter;
923
924 process_filter = filt;
925}
926
927static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
928{
929 struct process_filter *filt;
930 if (!process_filter)
931 return 1;
932
933 filt = process_filter;
934 while (filt) {
935 if (filt->pid && p->pid == filt->pid)
936 return 1;
937 if (strcmp(filt->name, c->comm) == 0)
938 return 1;
939 filt = filt->next;
940 }
941 return 0;
942}
943
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300944static int determine_display_tasks_filtered(struct timechart *tchart)
Arjan van de Venbbe29872009-10-20 07:09:39 +0900945{
946 struct per_pid *p;
947 struct per_pidcomm *c;
948 int count = 0;
949
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300950 p = tchart->all_data;
Arjan van de Venbbe29872009-10-20 07:09:39 +0900951 while (p) {
952 p->display = 0;
953 if (p->start_time == 1)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300954 p->start_time = tchart->first_time;
Arjan van de Venbbe29872009-10-20 07:09:39 +0900955
956 /* no exit marker, task kept running to the end */
957 if (p->end_time == 0)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300958 p->end_time = tchart->last_time;
Arjan van de Venbbe29872009-10-20 07:09:39 +0900959
960 c = p->all;
961
962 while (c) {
963 c->display = 0;
964
965 if (c->start_time == 1)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300966 c->start_time = tchart->first_time;
Arjan van de Venbbe29872009-10-20 07:09:39 +0900967
968 if (passes_filter(p, c)) {
969 c->display = 1;
970 p->display = 1;
971 count++;
972 }
973
974 if (c->end_time == 0)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300975 c->end_time = tchart->last_time;
Arjan van de Venbbe29872009-10-20 07:09:39 +0900976
977 c = c->next;
978 }
979 p = p->next;
980 }
981 return count;
982}
983
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300984static int determine_display_tasks(struct timechart *tchart, u64 threshold)
Arjan van de Ven10274982009-09-12 07:53:05 +0200985{
986 struct per_pid *p;
987 struct per_pidcomm *c;
988 int count = 0;
989
Arjan van de Venbbe29872009-10-20 07:09:39 +0900990 if (process_filter)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300991 return determine_display_tasks_filtered(tchart);
Arjan van de Venbbe29872009-10-20 07:09:39 +0900992
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -0300993 p = tchart->all_data;
Arjan van de Ven10274982009-09-12 07:53:05 +0200994 while (p) {
995 p->display = 0;
996 if (p->start_time == 1)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -0300997 p->start_time = tchart->first_time;
Arjan van de Ven10274982009-09-12 07:53:05 +0200998
999 /* no exit marker, task kept running to the end */
1000 if (p->end_time == 0)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001001 p->end_time = tchart->last_time;
Stanislav Fomichev753c5052013-11-01 20:25:47 +04001002 if (p->total_time >= threshold)
Arjan van de Ven10274982009-09-12 07:53:05 +02001003 p->display = 1;
1004
1005 c = p->all;
1006
1007 while (c) {
1008 c->display = 0;
1009
1010 if (c->start_time == 1)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001011 c->start_time = tchart->first_time;
Arjan van de Ven10274982009-09-12 07:53:05 +02001012
Stanislav Fomichev753c5052013-11-01 20:25:47 +04001013 if (c->total_time >= threshold) {
Arjan van de Ven10274982009-09-12 07:53:05 +02001014 c->display = 1;
1015 count++;
1016 }
1017
1018 if (c->end_time == 0)
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001019 c->end_time = tchart->last_time;
Arjan van de Ven10274982009-09-12 07:53:05 +02001020
1021 c = c->next;
1022 }
1023 p = p->next;
1024 }
1025 return count;
1026}
1027
1028
1029
1030#define TIME_THRESH 10000000
1031
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001032static void write_svg_file(struct timechart *tchart, const char *filename)
Arjan van de Ven10274982009-09-12 07:53:05 +02001033{
1034 u64 i;
1035 int count;
Stanislav Fomichev0a8eb272013-11-01 20:25:45 +04001036 int thresh = TIME_THRESH;
Arjan van de Ven10274982009-09-12 07:53:05 +02001037
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001038 if (tchart->power_only)
1039 tchart->proc_num = 0;
Arjan van de Ven10274982009-09-12 07:53:05 +02001040
Stanislav Fomichev0a8eb272013-11-01 20:25:45 +04001041 /* We'd like to show at least proc_num tasks;
1042 * be less picky if we have fewer */
1043 do {
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001044 count = determine_display_tasks(tchart, thresh);
Stanislav Fomichev0a8eb272013-11-01 20:25:45 +04001045 thresh /= 10;
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001046 } while (!process_filter && thresh && count < tchart->proc_num);
Arjan van de Ven10274982009-09-12 07:53:05 +02001047
Stanislav Fomichev3415d8b2014-01-20 15:39:38 +04001048 if (!tchart->proc_num)
1049 count = 0;
1050
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001051 open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
Arjan van de Ven10274982009-09-12 07:53:05 +02001052
Arjan van de Ven5094b652009-09-20 18:14:16 +02001053 svg_time_grid();
Arjan van de Ven10274982009-09-12 07:53:05 +02001054 svg_legenda();
1055
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001056 for (i = 0; i < tchart->numcpus; i++)
1057 svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
Arjan van de Ven10274982009-09-12 07:53:05 +02001058
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -03001059 draw_cpu_usage(tchart);
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001060 if (tchart->proc_num)
1061 draw_process_bars(tchart);
1062 if (!tchart->tasks_only)
1063 draw_c_p_states(tchart);
1064 if (tchart->proc_num)
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -03001065 draw_wakeups(tchart);
Arjan van de Ven10274982009-09-12 07:53:05 +02001066
1067 svg_close();
1068}
1069
Stanislav Fomichev58b9a182013-12-02 18:37:35 +04001070static int process_header(struct perf_file_section *section __maybe_unused,
1071 struct perf_header *ph,
1072 int feat,
1073 int fd __maybe_unused,
1074 void *data)
1075{
1076 struct timechart *tchart = data;
1077
1078 switch (feat) {
1079 case HEADER_NRCPUS:
1080 tchart->numcpus = ph->env.nr_cpus_avail;
1081 break;
Stanislav Fomichevc5079992013-12-02 18:37:36 +04001082
1083 case HEADER_CPU_TOPOLOGY:
1084 if (!tchart->topology)
1085 break;
1086
1087 if (svg_build_topology_map(ph->env.sibling_cores,
1088 ph->env.nr_sibling_cores,
1089 ph->env.sibling_threads,
1090 ph->env.nr_sibling_threads))
1091 fprintf(stderr, "problem building topology\n");
1092 break;
1093
Stanislav Fomichev58b9a182013-12-02 18:37:35 +04001094 default:
1095 break;
1096 }
1097
1098 return 0;
1099}
1100
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001101static int __cmd_timechart(struct timechart *tchart, const char *output_name)
Arjan van de Ven10274982009-09-12 07:53:05 +02001102{
Jiri Olsa59366782013-07-11 17:28:30 +02001103 const struct perf_evsel_str_handler power_tracepoints[] = {
1104 { "power:cpu_idle", process_sample_cpu_idle },
1105 { "power:cpu_frequency", process_sample_cpu_frequency },
1106 { "sched:sched_wakeup", process_sample_sched_wakeup },
1107 { "sched:sched_switch", process_sample_sched_switch },
1108#ifdef SUPPORT_OLD_POWER_EVENTS
1109 { "power:power_start", process_sample_power_start },
1110 { "power:power_end", process_sample_power_end },
1111 { "power:power_frequency", process_sample_power_frequency },
1112#endif
1113 };
Jiri Olsaf5fc1412013-10-15 16:27:32 +02001114 struct perf_data_file file = {
1115 .path = input_name,
1116 .mode = PERF_DATA_MODE_READ,
1117 };
1118
1119 struct perf_session *session = perf_session__new(&file, false,
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001120 &tchart->tool);
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -02001121 int ret = -EINVAL;
Arjan van de Ven10274982009-09-12 07:53:05 +02001122
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02001123 if (session == NULL)
1124 return -ENOMEM;
1125
Stanislav Fomichev58b9a182013-12-02 18:37:35 +04001126 (void)perf_header__process_sections(&session->header,
1127 perf_data_file__fd(session->file),
1128 tchart,
1129 process_header);
1130
Arnaldo Carvalho de Melod549c7692009-12-27 21:37:02 -02001131 if (!perf_session__has_traces(session, "timechart record"))
1132 goto out_delete;
1133
Jiri Olsa59366782013-07-11 17:28:30 +02001134 if (perf_session__set_tracepoints_handlers(session,
1135 power_tracepoints)) {
1136 pr_err("Initializing session tracepoint handlers failed\n");
1137 goto out_delete;
1138 }
1139
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001140 ret = perf_session__process_events(session, &tchart->tool);
Li Zefan5cbd0802009-12-01 14:05:16 +08001141 if (ret)
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02001142 goto out_delete;
Arjan van de Ven10274982009-09-12 07:53:05 +02001143
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001144 end_sample_processing(tchart);
Arjan van de Ven10274982009-09-12 07:53:05 +02001145
Arnaldo Carvalho de Melo5e22f6d2013-11-28 11:50:41 -03001146 sort_pids(tchart);
Arjan van de Ven10274982009-09-12 07:53:05 +02001147
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001148 write_svg_file(tchart, output_name);
Arjan van de Ven10274982009-09-12 07:53:05 +02001149
Arnaldo Carvalho de Melo6beba7a2009-10-21 17:34:06 -02001150 pr_info("Written %2.1f seconds of trace to %s.\n",
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001151 (tchart->last_time - tchart->first_time) / 1000000000.0, output_name);
Arnaldo Carvalho de Melo94c744b2009-12-11 21:24:02 -02001152out_delete:
1153 perf_session__delete(session);
1154 return ret;
Arjan van de Ven10274982009-09-12 07:53:05 +02001155}
1156
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001157static int timechart__record(struct timechart *tchart, int argc, const char **argv)
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001158{
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001159 unsigned int rec_argc, i, j;
1160 const char **rec_argv;
1161 const char **p;
1162 unsigned int record_elems;
1163
1164 const char * const common_args[] = {
Jiri Olsa4a4d3712013-06-05 13:37:21 +02001165 "record", "-a", "-R", "-c", "1",
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001166 };
1167 unsigned int common_args_nr = ARRAY_SIZE(common_args);
1168
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +04001169 const char * const backtrace_args[] = {
1170 "-g",
1171 };
1172 unsigned int backtrace_args_no = ARRAY_SIZE(backtrace_args);
1173
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001174 const char * const power_args[] = {
1175 "-e", "power:cpu_frequency",
1176 "-e", "power:cpu_idle",
1177 };
1178 unsigned int power_args_nr = ARRAY_SIZE(power_args);
1179
1180 const char * const old_power_args[] = {
1181#ifdef SUPPORT_OLD_POWER_EVENTS
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001182 "-e", "power:power_start",
1183 "-e", "power:power_end",
1184 "-e", "power:power_frequency",
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001185#endif
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001186 };
1187 unsigned int old_power_args_nr = ARRAY_SIZE(old_power_args);
1188
1189 const char * const tasks_args[] = {
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001190 "-e", "sched:sched_wakeup",
1191 "-e", "sched:sched_switch",
1192 };
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001193 unsigned int tasks_args_nr = ARRAY_SIZE(tasks_args);
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001194
Thomas Renninger20c457b2011-01-03 17:50:45 +01001195#ifdef SUPPORT_OLD_POWER_EVENTS
1196 if (!is_valid_tracepoint("power:cpu_idle") &&
1197 is_valid_tracepoint("power:power_start")) {
1198 use_old_power_events = 1;
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001199 power_args_nr = 0;
1200 } else {
1201 old_power_args_nr = 0;
Thomas Renninger20c457b2011-01-03 17:50:45 +01001202 }
1203#endif
1204
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001205 if (tchart->power_only)
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001206 tasks_args_nr = 0;
1207
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001208 if (tchart->tasks_only) {
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001209 power_args_nr = 0;
1210 old_power_args_nr = 0;
1211 }
1212
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001213 if (!tchart->with_backtrace)
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +04001214 backtrace_args_no = 0;
1215
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001216 record_elems = common_args_nr + tasks_args_nr +
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +04001217 power_args_nr + old_power_args_nr + backtrace_args_no;
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001218
1219 rec_argc = record_elems + argc;
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001220 rec_argv = calloc(rec_argc + 1, sizeof(char *));
1221
Chris Samuelce47dc52010-11-13 13:35:06 +11001222 if (rec_argv == NULL)
1223 return -ENOMEM;
1224
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001225 p = rec_argv;
1226 for (i = 0; i < common_args_nr; i++)
1227 *p++ = strdup(common_args[i]);
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001228
Stanislav Fomichev6f8d67f2013-11-01 20:25:51 +04001229 for (i = 0; i < backtrace_args_no; i++)
1230 *p++ = strdup(backtrace_args[i]);
1231
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001232 for (i = 0; i < tasks_args_nr; i++)
1233 *p++ = strdup(tasks_args[i]);
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001234
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001235 for (i = 0; i < power_args_nr; i++)
1236 *p++ = strdup(power_args[i]);
1237
1238 for (i = 0; i < old_power_args_nr; i++)
1239 *p++ = strdup(old_power_args[i]);
1240
Ramkumar Ramachandra263f89b2014-03-16 12:06:05 -04001241 for (j = 0; j < (unsigned int)argc; j++)
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001242 *p++ = argv[j];
1243
1244 return cmd_record(rec_argc, rec_argv, NULL);
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001245}
1246
Arjan van de Venbbe29872009-10-20 07:09:39 +09001247static int
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001248parse_process(const struct option *opt __maybe_unused, const char *arg,
1249 int __maybe_unused unset)
Arjan van de Venbbe29872009-10-20 07:09:39 +09001250{
1251 if (arg)
1252 add_process_filter(arg);
1253 return 0;
1254}
1255
Stanislav Fomicheve57a2df2013-12-17 19:53:49 +04001256static int
1257parse_highlight(const struct option *opt __maybe_unused, const char *arg,
1258 int __maybe_unused unset)
1259{
1260 unsigned long duration = strtoul(arg, NULL, 0);
1261
1262 if (svg_highlight || svg_highlight_name)
1263 return -1;
1264
1265 if (duration)
1266 svg_highlight = duration;
1267 else
1268 svg_highlight_name = strdup(arg);
1269
1270 return 0;
1271}
1272
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001273int cmd_timechart(int argc, const char **argv,
1274 const char *prefix __maybe_unused)
1275{
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001276 struct timechart tchart = {
1277 .tool = {
1278 .comm = process_comm_event,
1279 .fork = process_fork_event,
1280 .exit = process_exit_event,
1281 .sample = process_sample_event,
1282 .ordered_samples = true,
1283 },
1284 .proc_num = 15,
1285 };
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001286 const char *output_name = "output.svg";
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001287 const struct option timechart_options[] = {
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001288 OPT_STRING('i', "input", &input_name, "file", "input file name"),
1289 OPT_STRING('o', "output", &output_name, "file", "output file name"),
1290 OPT_INTEGER('w', "width", &svg_page_width, "page width"),
Stanislav Fomicheve57a2df2013-12-17 19:53:49 +04001291 OPT_CALLBACK(0, "highlight", NULL, "duration or task name",
1292 "highlight tasks. Pass duration in ns or process name.",
1293 parse_highlight),
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001294 OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
1295 OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
Stanislav Fomichevc87097d2013-11-01 20:25:48 +04001296 "output processes data only"),
Arjan van de Venbbe29872009-10-20 07:09:39 +09001297 OPT_CALLBACK('p', "process", NULL, "process",
1298 "process selector. Pass a pid or process name.",
1299 parse_process),
David Ahernec5761e2010-12-09 13:27:07 -07001300 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1301 "Look for files with symbols relative to this directory"),
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001302 OPT_INTEGER('n', "proc-num", &tchart.proc_num,
Stanislav Fomichev54874e32013-11-01 20:25:46 +04001303 "min. number of tasks to print"),
Stanislav Fomichevc5079992013-12-02 18:37:36 +04001304 OPT_BOOLEAN('t', "topology", &tchart.topology,
1305 "sort CPUs according to topology"),
Arjan van de Ven10274982009-09-12 07:53:05 +02001306 OPT_END()
Arnaldo Carvalho de Melo73bdc712012-10-01 15:20:58 -03001307 };
1308 const char * const timechart_usage[] = {
1309 "perf timechart [<options>] {record}",
1310 NULL
1311 };
Arjan van de Ven10274982009-09-12 07:53:05 +02001312
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001313 const struct option record_options[] = {
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001314 OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
1315 OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001316 "output processes data only"),
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001317 OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001318 OPT_END()
1319 };
1320 const char * const record_usage[] = {
1321 "perf timechart record [<options>]",
1322 NULL
1323 };
1324 argc = parse_options(argc, argv, timechart_options, timechart_usage,
Arjan van de Ven3c09eeb2009-09-19 13:34:42 +02001325 PARSE_OPT_STOP_AT_NON_OPTION);
Arjan van de Ven10274982009-09-12 07:53:05 +02001326
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001327 if (tchart.power_only && tchart.tasks_only) {
Stanislav Fomichevc87097d2013-11-01 20:25:48 +04001328 pr_err("-P and -T options cannot be used at the same time.\n");
1329 return -1;
1330 }
1331
Arnaldo Carvalho de Melo655000e2009-12-15 20:04:40 -02001332 symbol__init();
1333
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001334 if (argc && !strncmp(argv[0], "rec", 3)) {
1335 argc = parse_options(argc, argv, record_options, record_usage,
1336 PARSE_OPT_STOP_AT_NON_OPTION);
1337
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001338 if (tchart.power_only && tchart.tasks_only) {
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001339 pr_err("-P and -T options cannot be used at the same time.\n");
1340 return -1;
1341 }
1342
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001343 return timechart__record(&tchart, argc, argv);
Stanislav Fomichev367b3152013-11-01 20:25:50 +04001344 } else if (argc)
1345 usage_with_options(timechart_usage, timechart_options);
Arjan van de Ven10274982009-09-12 07:53:05 +02001346
1347 setup_pager();
1348
Arnaldo Carvalho de Melo985b12e2013-11-28 11:25:19 -03001349 return __cmd_timechart(&tchart, output_name);
Arjan van de Ven10274982009-09-12 07:53:05 +02001350}