]>
Commit | Line | Data |
---|---|---|
10274989 AV |
1 | /* |
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 | ||
c85cffa5 JO |
15 | #include <traceevent/event-parse.h> |
16 | ||
10274989 AV |
17 | #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" | |
5936678e | 24 | #include "util/evlist.h" |
e3f42609 | 25 | #include "util/evsel.h" |
10274989 AV |
26 | #include <linux/rbtree.h> |
27 | #include "util/symbol.h" | |
10274989 AV |
28 | #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" | |
5cbd0805 | 35 | #include "util/event.h" |
301a0b02 | 36 | #include "util/session.h" |
10274989 | 37 | #include "util/svghelper.h" |
45694aa7 | 38 | #include "util/tool.h" |
f5fc1412 | 39 | #include "util/data.h" |
84f5d36f | 40 | #include "util/debug.h" |
10274989 | 41 | |
20c457b8 TR |
42 | #define SUPPORT_OLD_POWER_EVENTS 1 |
43 | #define PWR_EVENT_EXIT -1 | |
44 | ||
5e22f6d2 | 45 | struct per_pid; |
66cc3ada | 46 | struct power_event; |
436b0da0 | 47 | struct wake_event; |
5e22f6d2 | 48 | |
985b12e6 ACM |
49 | struct timechart { |
50 | struct perf_tool tool; | |
5e22f6d2 | 51 | struct per_pid *all_data; |
66cc3ada | 52 | struct power_event *power_events; |
436b0da0 | 53 | struct wake_event *wake_events; |
985b12e6 ACM |
54 | int proc_num; |
55 | unsigned int numcpus; | |
56 | u64 min_freq, /* Lowest CPU frequency seen */ | |
57 | max_freq, /* Highest CPU frequency seen */ | |
58 | turbo_frequency, | |
59 | first_time, last_time; | |
60 | bool power_only, | |
61 | tasks_only, | |
c5079997 SF |
62 | with_backtrace, |
63 | topology; | |
b97b59b9 SF |
64 | /* IO related settings */ |
65 | u64 io_events; | |
d243144a SF |
66 | bool io_only, |
67 | skip_eagain; | |
68 | u64 min_time, | |
69 | merge_dist; | |
985b12e6 | 70 | }; |
10274989 | 71 | |
10274989 | 72 | struct per_pidcomm; |
10274989 | 73 | struct cpu_sample; |
b97b59b9 | 74 | struct io_sample; |
10274989 AV |
75 | |
76 | /* | |
77 | * Datastructure layout: | |
78 | * We keep an list of "pid"s, matching the kernels notion of a task struct. | |
79 | * Each "pid" entry, has a list of "comm"s. | |
80 | * this is because we want to track different programs different, while | |
81 | * exec will reuse the original pid (by design). | |
82 | * Each comm has a list of samples that will be used to draw | |
83 | * final graph. | |
84 | */ | |
85 | ||
86 | struct per_pid { | |
87 | struct per_pid *next; | |
88 | ||
89 | int pid; | |
90 | int ppid; | |
91 | ||
92 | u64 start_time; | |
93 | u64 end_time; | |
94 | u64 total_time; | |
b97b59b9 | 95 | u64 total_bytes; |
10274989 AV |
96 | int display; |
97 | ||
98 | struct per_pidcomm *all; | |
99 | struct per_pidcomm *current; | |
10274989 AV |
100 | }; |
101 | ||
102 | ||
103 | struct per_pidcomm { | |
104 | struct per_pidcomm *next; | |
105 | ||
106 | u64 start_time; | |
107 | u64 end_time; | |
108 | u64 total_time; | |
b97b59b9 SF |
109 | u64 max_bytes; |
110 | u64 total_bytes; | |
10274989 AV |
111 | |
112 | int Y; | |
113 | int display; | |
114 | ||
115 | long state; | |
116 | u64 state_since; | |
117 | ||
118 | char *comm; | |
119 | ||
120 | struct cpu_sample *samples; | |
b97b59b9 | 121 | struct io_sample *io_samples; |
10274989 AV |
122 | }; |
123 | ||
124 | struct sample_wrapper { | |
125 | struct sample_wrapper *next; | |
126 | ||
127 | u64 timestamp; | |
128 | unsigned char data[0]; | |
129 | }; | |
130 | ||
131 | #define TYPE_NONE 0 | |
132 | #define TYPE_RUNNING 1 | |
133 | #define TYPE_WAITING 2 | |
134 | #define TYPE_BLOCKED 3 | |
135 | ||
136 | struct cpu_sample { | |
137 | struct cpu_sample *next; | |
138 | ||
139 | u64 start_time; | |
140 | u64 end_time; | |
141 | int type; | |
142 | int cpu; | |
6f8d67fa | 143 | const char *backtrace; |
10274989 AV |
144 | }; |
145 | ||
b97b59b9 SF |
146 | enum { |
147 | IOTYPE_READ, | |
148 | IOTYPE_WRITE, | |
149 | IOTYPE_SYNC, | |
150 | IOTYPE_TX, | |
151 | IOTYPE_RX, | |
152 | IOTYPE_POLL, | |
153 | }; | |
154 | ||
155 | struct io_sample { | |
156 | struct io_sample *next; | |
157 | ||
158 | u64 start_time; | |
159 | u64 end_time; | |
160 | u64 bytes; | |
161 | int type; | |
162 | int fd; | |
163 | int err; | |
164 | int merges; | |
165 | }; | |
166 | ||
10274989 AV |
167 | #define CSTATE 1 |
168 | #define PSTATE 2 | |
169 | ||
170 | struct power_event { | |
171 | struct power_event *next; | |
172 | int type; | |
173 | int state; | |
174 | u64 start_time; | |
175 | u64 end_time; | |
176 | int cpu; | |
177 | }; | |
178 | ||
179 | struct wake_event { | |
180 | struct wake_event *next; | |
181 | int waker; | |
182 | int wakee; | |
183 | u64 time; | |
6f8d67fa | 184 | const char *backtrace; |
10274989 AV |
185 | }; |
186 | ||
bbe2987b | 187 | struct process_filter { |
5cbd0805 LZ |
188 | char *name; |
189 | int pid; | |
190 | struct process_filter *next; | |
bbe2987b AV |
191 | }; |
192 | ||
193 | static struct process_filter *process_filter; | |
194 | ||
195 | ||
5e22f6d2 | 196 | static struct per_pid *find_create_pid(struct timechart *tchart, int pid) |
10274989 | 197 | { |
5e22f6d2 | 198 | struct per_pid *cursor = tchart->all_data; |
10274989 AV |
199 | |
200 | while (cursor) { | |
201 | if (cursor->pid == pid) | |
202 | return cursor; | |
203 | cursor = cursor->next; | |
204 | } | |
e0dcd6fb | 205 | cursor = zalloc(sizeof(*cursor)); |
10274989 | 206 | assert(cursor != NULL); |
10274989 | 207 | cursor->pid = pid; |
5e22f6d2 ACM |
208 | cursor->next = tchart->all_data; |
209 | tchart->all_data = cursor; | |
10274989 AV |
210 | return cursor; |
211 | } | |
212 | ||
5e22f6d2 | 213 | static void pid_set_comm(struct timechart *tchart, int pid, char *comm) |
10274989 AV |
214 | { |
215 | struct per_pid *p; | |
216 | struct per_pidcomm *c; | |
5e22f6d2 | 217 | p = find_create_pid(tchart, pid); |
10274989 AV |
218 | c = p->all; |
219 | while (c) { | |
220 | if (c->comm && strcmp(c->comm, comm) == 0) { | |
221 | p->current = c; | |
222 | return; | |
223 | } | |
224 | if (!c->comm) { | |
225 | c->comm = strdup(comm); | |
226 | p->current = c; | |
227 | return; | |
228 | } | |
229 | c = c->next; | |
230 | } | |
e0dcd6fb | 231 | c = zalloc(sizeof(*c)); |
10274989 | 232 | assert(c != NULL); |
10274989 AV |
233 | c->comm = strdup(comm); |
234 | p->current = c; | |
235 | c->next = p->all; | |
236 | p->all = c; | |
237 | } | |
238 | ||
5e22f6d2 | 239 | static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp) |
10274989 AV |
240 | { |
241 | struct per_pid *p, *pp; | |
5e22f6d2 ACM |
242 | p = find_create_pid(tchart, pid); |
243 | pp = find_create_pid(tchart, ppid); | |
10274989 AV |
244 | p->ppid = ppid; |
245 | if (pp->current && pp->current->comm && !p->current) | |
5e22f6d2 | 246 | pid_set_comm(tchart, pid, pp->current->comm); |
10274989 AV |
247 | |
248 | p->start_time = timestamp; | |
962e310a | 249 | if (p->current && !p->current->start_time) { |
10274989 AV |
250 | p->current->start_time = timestamp; |
251 | p->current->state_since = timestamp; | |
252 | } | |
253 | } | |
254 | ||
5e22f6d2 | 255 | static void pid_exit(struct timechart *tchart, int pid, u64 timestamp) |
10274989 AV |
256 | { |
257 | struct per_pid *p; | |
5e22f6d2 | 258 | p = find_create_pid(tchart, pid); |
10274989 AV |
259 | p->end_time = timestamp; |
260 | if (p->current) | |
261 | p->current->end_time = timestamp; | |
262 | } | |
263 | ||
5e22f6d2 ACM |
264 | static void pid_put_sample(struct timechart *tchart, int pid, int type, |
265 | unsigned int cpu, u64 start, u64 end, | |
266 | const char *backtrace) | |
10274989 AV |
267 | { |
268 | struct per_pid *p; | |
269 | struct per_pidcomm *c; | |
270 | struct cpu_sample *sample; | |
271 | ||
5e22f6d2 | 272 | p = find_create_pid(tchart, pid); |
10274989 AV |
273 | c = p->current; |
274 | if (!c) { | |
e0dcd6fb | 275 | c = zalloc(sizeof(*c)); |
10274989 | 276 | assert(c != NULL); |
10274989 AV |
277 | p->current = c; |
278 | c->next = p->all; | |
279 | p->all = c; | |
280 | } | |
281 | ||
e0dcd6fb | 282 | sample = zalloc(sizeof(*sample)); |
10274989 | 283 | assert(sample != NULL); |
10274989 AV |
284 | sample->start_time = start; |
285 | sample->end_time = end; | |
286 | sample->type = type; | |
287 | sample->next = c->samples; | |
288 | sample->cpu = cpu; | |
6f8d67fa | 289 | sample->backtrace = backtrace; |
10274989 AV |
290 | c->samples = sample; |
291 | ||
292 | if (sample->type == TYPE_RUNNING && end > start && start > 0) { | |
293 | c->total_time += (end-start); | |
294 | p->total_time += (end-start); | |
295 | } | |
296 | ||
297 | if (c->start_time == 0 || c->start_time > start) | |
298 | c->start_time = start; | |
299 | if (p->start_time == 0 || p->start_time > start) | |
300 | p->start_time = start; | |
10274989 AV |
301 | } |
302 | ||
303 | #define MAX_CPUS 4096 | |
304 | ||
305 | static u64 cpus_cstate_start_times[MAX_CPUS]; | |
306 | static int cpus_cstate_state[MAX_CPUS]; | |
307 | static u64 cpus_pstate_start_times[MAX_CPUS]; | |
308 | static u64 cpus_pstate_state[MAX_CPUS]; | |
309 | ||
5e22f6d2 | 310 | static int process_comm_event(struct perf_tool *tool, |
d20deb64 | 311 | union perf_event *event, |
1d037ca1 IT |
312 | struct perf_sample *sample __maybe_unused, |
313 | struct machine *machine __maybe_unused) | |
10274989 | 314 | { |
5e22f6d2 ACM |
315 | struct timechart *tchart = container_of(tool, struct timechart, tool); |
316 | pid_set_comm(tchart, event->comm.tid, event->comm.comm); | |
10274989 AV |
317 | return 0; |
318 | } | |
d8f66248 | 319 | |
5e22f6d2 | 320 | static int process_fork_event(struct perf_tool *tool, |
d20deb64 | 321 | union perf_event *event, |
1d037ca1 IT |
322 | struct perf_sample *sample __maybe_unused, |
323 | struct machine *machine __maybe_unused) | |
10274989 | 324 | { |
5e22f6d2 ACM |
325 | struct timechart *tchart = container_of(tool, struct timechart, tool); |
326 | pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time); | |
10274989 AV |
327 | return 0; |
328 | } | |
329 | ||
5e22f6d2 | 330 | static int process_exit_event(struct perf_tool *tool, |
d20deb64 | 331 | union perf_event *event, |
1d037ca1 IT |
332 | struct perf_sample *sample __maybe_unused, |
333 | struct machine *machine __maybe_unused) | |
10274989 | 334 | { |
5e22f6d2 ACM |
335 | struct timechart *tchart = container_of(tool, struct timechart, tool); |
336 | pid_exit(tchart, event->fork.pid, event->fork.time); | |
10274989 AV |
337 | return 0; |
338 | } | |
339 | ||
20c457b8 TR |
340 | #ifdef SUPPORT_OLD_POWER_EVENTS |
341 | static int use_old_power_events; | |
20c457b8 TR |
342 | #endif |
343 | ||
10274989 AV |
344 | static void c_state_start(int cpu, u64 timestamp, int state) |
345 | { | |
346 | cpus_cstate_start_times[cpu] = timestamp; | |
347 | cpus_cstate_state[cpu] = state; | |
348 | } | |
349 | ||
66cc3ada | 350 | static void c_state_end(struct timechart *tchart, int cpu, u64 timestamp) |
10274989 | 351 | { |
e0dcd6fb ACM |
352 | struct power_event *pwr = zalloc(sizeof(*pwr)); |
353 | ||
10274989 AV |
354 | if (!pwr) |
355 | return; | |
10274989 AV |
356 | |
357 | pwr->state = cpus_cstate_state[cpu]; | |
358 | pwr->start_time = cpus_cstate_start_times[cpu]; | |
359 | pwr->end_time = timestamp; | |
360 | pwr->cpu = cpu; | |
361 | pwr->type = CSTATE; | |
66cc3ada | 362 | pwr->next = tchart->power_events; |
10274989 | 363 | |
66cc3ada | 364 | tchart->power_events = pwr; |
10274989 AV |
365 | } |
366 | ||
985b12e6 | 367 | static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64 new_freq) |
10274989 AV |
368 | { |
369 | struct power_event *pwr; | |
10274989 AV |
370 | |
371 | if (new_freq > 8000000) /* detect invalid data */ | |
372 | return; | |
373 | ||
e0dcd6fb | 374 | pwr = zalloc(sizeof(*pwr)); |
10274989 AV |
375 | if (!pwr) |
376 | return; | |
10274989 AV |
377 | |
378 | pwr->state = cpus_pstate_state[cpu]; | |
379 | pwr->start_time = cpus_pstate_start_times[cpu]; | |
380 | pwr->end_time = timestamp; | |
381 | pwr->cpu = cpu; | |
382 | pwr->type = PSTATE; | |
66cc3ada | 383 | pwr->next = tchart->power_events; |
10274989 AV |
384 | |
385 | if (!pwr->start_time) | |
985b12e6 | 386 | pwr->start_time = tchart->first_time; |
10274989 | 387 | |
66cc3ada | 388 | tchart->power_events = pwr; |
10274989 AV |
389 | |
390 | cpus_pstate_state[cpu] = new_freq; | |
391 | cpus_pstate_start_times[cpu] = timestamp; | |
392 | ||
985b12e6 ACM |
393 | if ((u64)new_freq > tchart->max_freq) |
394 | tchart->max_freq = new_freq; | |
10274989 | 395 | |
985b12e6 ACM |
396 | if (new_freq < tchart->min_freq || tchart->min_freq == 0) |
397 | tchart->min_freq = new_freq; | |
10274989 | 398 | |
985b12e6 ACM |
399 | if (new_freq == tchart->max_freq - 1000) |
400 | tchart->turbo_frequency = tchart->max_freq; | |
10274989 AV |
401 | } |
402 | ||
5e22f6d2 ACM |
403 | static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp, |
404 | int waker, int wakee, u8 flags, const char *backtrace) | |
10274989 | 405 | { |
10274989 | 406 | struct per_pid *p; |
e0dcd6fb | 407 | struct wake_event *we = zalloc(sizeof(*we)); |
10274989 | 408 | |
10274989 AV |
409 | if (!we) |
410 | return; | |
411 | ||
10274989 | 412 | we->time = timestamp; |
3ed0d21e | 413 | we->waker = waker; |
6f8d67fa | 414 | we->backtrace = backtrace; |
10274989 | 415 | |
3ed0d21e | 416 | if ((flags & TRACE_FLAG_HARDIRQ) || (flags & TRACE_FLAG_SOFTIRQ)) |
10274989 AV |
417 | we->waker = -1; |
418 | ||
3ed0d21e | 419 | we->wakee = wakee; |
436b0da0 ACM |
420 | we->next = tchart->wake_events; |
421 | tchart->wake_events = we; | |
5e22f6d2 | 422 | p = find_create_pid(tchart, we->wakee); |
10274989 AV |
423 | |
424 | if (p && p->current && p->current->state == TYPE_NONE) { | |
425 | p->current->state_since = timestamp; | |
426 | p->current->state = TYPE_WAITING; | |
427 | } | |
428 | if (p && p->current && p->current->state == TYPE_BLOCKED) { | |
5e22f6d2 | 429 | pid_put_sample(tchart, p->pid, p->current->state, cpu, |
6f8d67fa | 430 | p->current->state_since, timestamp, NULL); |
10274989 AV |
431 | p->current->state_since = timestamp; |
432 | p->current->state = TYPE_WAITING; | |
433 | } | |
434 | } | |
435 | ||
5e22f6d2 ACM |
436 | static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp, |
437 | int prev_pid, int next_pid, u64 prev_state, | |
438 | const char *backtrace) | |
10274989 AV |
439 | { |
440 | struct per_pid *p = NULL, *prev_p; | |
10274989 | 441 | |
5e22f6d2 | 442 | prev_p = find_create_pid(tchart, prev_pid); |
10274989 | 443 | |
5e22f6d2 | 444 | p = find_create_pid(tchart, next_pid); |
10274989 AV |
445 | |
446 | if (prev_p->current && prev_p->current->state != TYPE_NONE) | |
5e22f6d2 | 447 | pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu, |
6f8d67fa SF |
448 | prev_p->current->state_since, timestamp, |
449 | backtrace); | |
10274989 AV |
450 | if (p && p->current) { |
451 | if (p->current->state != TYPE_NONE) | |
5e22f6d2 | 452 | pid_put_sample(tchart, next_pid, p->current->state, cpu, |
6f8d67fa SF |
453 | p->current->state_since, timestamp, |
454 | backtrace); | |
10274989 | 455 | |
33e26a1b JL |
456 | p->current->state_since = timestamp; |
457 | p->current->state = TYPE_RUNNING; | |
10274989 AV |
458 | } |
459 | ||
460 | if (prev_p->current) { | |
461 | prev_p->current->state = TYPE_NONE; | |
462 | prev_p->current->state_since = timestamp; | |
3ed0d21e | 463 | if (prev_state & 2) |
10274989 | 464 | prev_p->current->state = TYPE_BLOCKED; |
3ed0d21e | 465 | if (prev_state == 0) |
10274989 AV |
466 | prev_p->current->state = TYPE_WAITING; |
467 | } | |
468 | } | |
469 | ||
6f8d67fa SF |
470 | static const char *cat_backtrace(union perf_event *event, |
471 | struct perf_sample *sample, | |
472 | struct machine *machine) | |
473 | { | |
474 | struct addr_location al; | |
475 | unsigned int i; | |
476 | char *p = NULL; | |
477 | size_t p_len; | |
478 | u8 cpumode = PERF_RECORD_MISC_USER; | |
479 | struct addr_location tal; | |
480 | struct ip_callchain *chain = sample->callchain; | |
481 | FILE *f = open_memstream(&p, &p_len); | |
482 | ||
483 | if (!f) { | |
484 | perror("open_memstream error"); | |
485 | return NULL; | |
486 | } | |
487 | ||
488 | if (!chain) | |
489 | goto exit; | |
490 | ||
491 | if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) { | |
492 | fprintf(stderr, "problem processing %d event, skipping it.\n", | |
493 | event->header.type); | |
494 | goto exit; | |
495 | } | |
496 | ||
497 | for (i = 0; i < chain->nr; i++) { | |
498 | u64 ip; | |
499 | ||
500 | if (callchain_param.order == ORDER_CALLEE) | |
501 | ip = chain->ips[i]; | |
502 | else | |
503 | ip = chain->ips[chain->nr - i - 1]; | |
504 | ||
505 | if (ip >= PERF_CONTEXT_MAX) { | |
506 | switch (ip) { | |
507 | case PERF_CONTEXT_HV: | |
508 | cpumode = PERF_RECORD_MISC_HYPERVISOR; | |
509 | break; | |
510 | case PERF_CONTEXT_KERNEL: | |
511 | cpumode = PERF_RECORD_MISC_KERNEL; | |
512 | break; | |
513 | case PERF_CONTEXT_USER: | |
514 | cpumode = PERF_RECORD_MISC_USER; | |
515 | break; | |
516 | default: | |
517 | pr_debug("invalid callchain context: " | |
518 | "%"PRId64"\n", (s64) ip); | |
519 | ||
520 | /* | |
521 | * It seems the callchain is corrupted. | |
522 | * Discard all. | |
523 | */ | |
04662523 | 524 | zfree(&p); |
6f8d67fa SF |
525 | goto exit; |
526 | } | |
527 | continue; | |
528 | } | |
529 | ||
b3cef7f6 | 530 | tal.filtered = 0; |
bb871a9c | 531 | thread__find_addr_location(al.thread, cpumode, |
6f8d67fa SF |
532 | MAP__FUNCTION, ip, &tal); |
533 | ||
534 | if (tal.sym) | |
535 | fprintf(f, "..... %016" PRIx64 " %s\n", ip, | |
536 | tal.sym->name); | |
537 | else | |
538 | fprintf(f, "..... %016" PRIx64 "\n", ip); | |
539 | } | |
540 | ||
541 | exit: | |
542 | fclose(f); | |
543 | ||
544 | return p; | |
545 | } | |
546 | ||
985b12e6 ACM |
547 | typedef int (*tracepoint_handler)(struct timechart *tchart, |
548 | struct perf_evsel *evsel, | |
6f8d67fa SF |
549 | struct perf_sample *sample, |
550 | const char *backtrace); | |
10274989 | 551 | |
985b12e6 | 552 | static int process_sample_event(struct perf_tool *tool, |
972ec653 | 553 | union perf_event *event, |
8d50e5b4 | 554 | struct perf_sample *sample, |
e3f42609 | 555 | struct perf_evsel *evsel, |
985b12e6 | 556 | struct machine *machine) |
10274989 | 557 | { |
985b12e6 ACM |
558 | struct timechart *tchart = container_of(tool, struct timechart, tool); |
559 | ||
e3f42609 | 560 | if (evsel->attr.sample_type & PERF_SAMPLE_TIME) { |
985b12e6 ACM |
561 | if (!tchart->first_time || tchart->first_time > sample->time) |
562 | tchart->first_time = sample->time; | |
563 | if (tchart->last_time < sample->time) | |
564 | tchart->last_time = sample->time; | |
10274989 | 565 | } |
180f95e2 | 566 | |
744a9719 ACM |
567 | if (evsel->handler != NULL) { |
568 | tracepoint_handler f = evsel->handler; | |
58b9a18e SF |
569 | return f(tchart, evsel, sample, |
570 | cat_backtrace(event, sample, machine)); | |
5936678e JO |
571 | } |
572 | ||
573 | return 0; | |
574 | } | |
575 | ||
576 | static int | |
985b12e6 ACM |
577 | process_sample_cpu_idle(struct timechart *tchart __maybe_unused, |
578 | struct perf_evsel *evsel, | |
6f8d67fa SF |
579 | struct perf_sample *sample, |
580 | const char *backtrace __maybe_unused) | |
5936678e | 581 | { |
3ed0d21e SF |
582 | u32 state = perf_evsel__intval(evsel, sample, "state"); |
583 | u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id"); | |
5936678e | 584 | |
3ed0d21e | 585 | if (state == (u32)PWR_EVENT_EXIT) |
66cc3ada | 586 | c_state_end(tchart, cpu_id, sample->time); |
5936678e | 587 | else |
3ed0d21e | 588 | c_state_start(cpu_id, sample->time, state); |
5936678e JO |
589 | return 0; |
590 | } | |
591 | ||
592 | static int | |
985b12e6 ACM |
593 | process_sample_cpu_frequency(struct timechart *tchart, |
594 | struct perf_evsel *evsel, | |
6f8d67fa SF |
595 | struct perf_sample *sample, |
596 | const char *backtrace __maybe_unused) | |
5936678e | 597 | { |
3ed0d21e SF |
598 | u32 state = perf_evsel__intval(evsel, sample, "state"); |
599 | u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id"); | |
5936678e | 600 | |
985b12e6 | 601 | p_state_change(tchart, cpu_id, sample->time, state); |
5936678e JO |
602 | return 0; |
603 | } | |
604 | ||
605 | static int | |
5e22f6d2 | 606 | process_sample_sched_wakeup(struct timechart *tchart, |
985b12e6 | 607 | struct perf_evsel *evsel, |
6f8d67fa SF |
608 | struct perf_sample *sample, |
609 | const char *backtrace) | |
5936678e | 610 | { |
3ed0d21e SF |
611 | u8 flags = perf_evsel__intval(evsel, sample, "common_flags"); |
612 | int waker = perf_evsel__intval(evsel, sample, "common_pid"); | |
613 | int wakee = perf_evsel__intval(evsel, sample, "pid"); | |
5936678e | 614 | |
5e22f6d2 | 615 | sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace); |
5936678e JO |
616 | return 0; |
617 | } | |
10274989 | 618 | |
5936678e | 619 | static int |
5e22f6d2 | 620 | process_sample_sched_switch(struct timechart *tchart, |
985b12e6 | 621 | struct perf_evsel *evsel, |
6f8d67fa SF |
622 | struct perf_sample *sample, |
623 | const char *backtrace) | |
5936678e | 624 | { |
3ed0d21e SF |
625 | int prev_pid = perf_evsel__intval(evsel, sample, "prev_pid"); |
626 | int next_pid = perf_evsel__intval(evsel, sample, "next_pid"); | |
627 | u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state"); | |
10274989 | 628 | |
5e22f6d2 ACM |
629 | sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid, |
630 | prev_state, backtrace); | |
5936678e JO |
631 | return 0; |
632 | } | |
20c457b8 TR |
633 | |
634 | #ifdef SUPPORT_OLD_POWER_EVENTS | |
5936678e | 635 | static int |
985b12e6 ACM |
636 | process_sample_power_start(struct timechart *tchart __maybe_unused, |
637 | struct perf_evsel *evsel, | |
6f8d67fa SF |
638 | struct perf_sample *sample, |
639 | const char *backtrace __maybe_unused) | |
5936678e | 640 | { |
3ed0d21e SF |
641 | u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id"); |
642 | u64 value = perf_evsel__intval(evsel, sample, "value"); | |
5936678e | 643 | |
3ed0d21e | 644 | c_state_start(cpu_id, sample->time, value); |
5936678e JO |
645 | return 0; |
646 | } | |
647 | ||
648 | static int | |
66cc3ada | 649 | process_sample_power_end(struct timechart *tchart, |
985b12e6 | 650 | struct perf_evsel *evsel __maybe_unused, |
6f8d67fa SF |
651 | struct perf_sample *sample, |
652 | const char *backtrace __maybe_unused) | |
5936678e | 653 | { |
66cc3ada | 654 | c_state_end(tchart, sample->cpu, sample->time); |
5936678e JO |
655 | return 0; |
656 | } | |
657 | ||
658 | static int | |
985b12e6 ACM |
659 | process_sample_power_frequency(struct timechart *tchart, |
660 | struct perf_evsel *evsel, | |
6f8d67fa SF |
661 | struct perf_sample *sample, |
662 | const char *backtrace __maybe_unused) | |
5936678e | 663 | { |
3ed0d21e SF |
664 | u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id"); |
665 | u64 value = perf_evsel__intval(evsel, sample, "value"); | |
5936678e | 666 | |
985b12e6 | 667 | p_state_change(tchart, cpu_id, sample->time, value); |
10274989 AV |
668 | return 0; |
669 | } | |
5936678e | 670 | #endif /* SUPPORT_OLD_POWER_EVENTS */ |
10274989 AV |
671 | |
672 | /* | |
673 | * After the last sample we need to wrap up the current C/P state | |
674 | * and close out each CPU for these. | |
675 | */ | |
985b12e6 | 676 | static void end_sample_processing(struct timechart *tchart) |
10274989 AV |
677 | { |
678 | u64 cpu; | |
679 | struct power_event *pwr; | |
680 | ||
985b12e6 | 681 | for (cpu = 0; cpu <= tchart->numcpus; cpu++) { |
e0dcd6fb ACM |
682 | /* C state */ |
683 | #if 0 | |
684 | pwr = zalloc(sizeof(*pwr)); | |
10274989 AV |
685 | if (!pwr) |
686 | return; | |
10274989 | 687 | |
10274989 AV |
688 | pwr->state = cpus_cstate_state[cpu]; |
689 | pwr->start_time = cpus_cstate_start_times[cpu]; | |
985b12e6 | 690 | pwr->end_time = tchart->last_time; |
10274989 AV |
691 | pwr->cpu = cpu; |
692 | pwr->type = CSTATE; | |
66cc3ada | 693 | pwr->next = tchart->power_events; |
10274989 | 694 | |
66cc3ada | 695 | tchart->power_events = pwr; |
10274989 AV |
696 | #endif |
697 | /* P state */ | |
698 | ||
e0dcd6fb | 699 | pwr = zalloc(sizeof(*pwr)); |
10274989 AV |
700 | if (!pwr) |
701 | return; | |
10274989 AV |
702 | |
703 | pwr->state = cpus_pstate_state[cpu]; | |
704 | pwr->start_time = cpus_pstate_start_times[cpu]; | |
985b12e6 | 705 | pwr->end_time = tchart->last_time; |
10274989 AV |
706 | pwr->cpu = cpu; |
707 | pwr->type = PSTATE; | |
66cc3ada | 708 | pwr->next = tchart->power_events; |
10274989 AV |
709 | |
710 | if (!pwr->start_time) | |
985b12e6 | 711 | pwr->start_time = tchart->first_time; |
10274989 | 712 | if (!pwr->state) |
985b12e6 | 713 | pwr->state = tchart->min_freq; |
66cc3ada | 714 | tchart->power_events = pwr; |
10274989 AV |
715 | } |
716 | } | |
717 | ||
b97b59b9 SF |
718 | static int pid_begin_io_sample(struct timechart *tchart, int pid, int type, |
719 | u64 start, int fd) | |
720 | { | |
721 | struct per_pid *p = find_create_pid(tchart, pid); | |
722 | struct per_pidcomm *c = p->current; | |
723 | struct io_sample *sample; | |
724 | struct io_sample *prev; | |
725 | ||
726 | if (!c) { | |
727 | c = zalloc(sizeof(*c)); | |
728 | if (!c) | |
729 | return -ENOMEM; | |
730 | p->current = c; | |
731 | c->next = p->all; | |
732 | p->all = c; | |
733 | } | |
734 | ||
735 | prev = c->io_samples; | |
736 | ||
737 | if (prev && prev->start_time && !prev->end_time) { | |
738 | pr_warning("Skip invalid start event: " | |
739 | "previous event already started!\n"); | |
740 | ||
741 | /* remove previous event that has been started, | |
742 | * we are not sure we will ever get an end for it */ | |
743 | c->io_samples = prev->next; | |
744 | free(prev); | |
745 | return 0; | |
746 | } | |
747 | ||
748 | sample = zalloc(sizeof(*sample)); | |
749 | if (!sample) | |
750 | return -ENOMEM; | |
751 | sample->start_time = start; | |
752 | sample->type = type; | |
753 | sample->fd = fd; | |
754 | sample->next = c->io_samples; | |
755 | c->io_samples = sample; | |
756 | ||
757 | if (c->start_time == 0 || c->start_time > start) | |
758 | c->start_time = start; | |
759 | ||
760 | return 0; | |
761 | } | |
762 | ||
763 | static int pid_end_io_sample(struct timechart *tchart, int pid, int type, | |
764 | u64 end, long ret) | |
765 | { | |
766 | struct per_pid *p = find_create_pid(tchart, pid); | |
767 | struct per_pidcomm *c = p->current; | |
d243144a | 768 | struct io_sample *sample, *prev; |
b97b59b9 SF |
769 | |
770 | if (!c) { | |
771 | pr_warning("Invalid pidcomm!\n"); | |
772 | return -1; | |
773 | } | |
774 | ||
775 | sample = c->io_samples; | |
776 | ||
777 | if (!sample) /* skip partially captured events */ | |
778 | return 0; | |
779 | ||
780 | if (sample->end_time) { | |
781 | pr_warning("Skip invalid end event: " | |
782 | "previous event already ended!\n"); | |
783 | return 0; | |
784 | } | |
785 | ||
786 | if (sample->type != type) { | |
787 | pr_warning("Skip invalid end event: invalid event type!\n"); | |
788 | return 0; | |
789 | } | |
790 | ||
791 | sample->end_time = end; | |
d243144a SF |
792 | prev = sample->next; |
793 | ||
794 | /* we want to be able to see small and fast transfers, so make them | |
795 | * at least min_time long, but don't overlap them */ | |
796 | if (sample->end_time - sample->start_time < tchart->min_time) | |
797 | sample->end_time = sample->start_time + tchart->min_time; | |
798 | if (prev && sample->start_time < prev->end_time) { | |
799 | if (prev->err) /* try to make errors more visible */ | |
800 | sample->start_time = prev->end_time; | |
801 | else | |
802 | prev->end_time = sample->start_time; | |
803 | } | |
b97b59b9 SF |
804 | |
805 | if (ret < 0) { | |
806 | sample->err = ret; | |
807 | } else if (type == IOTYPE_READ || type == IOTYPE_WRITE || | |
808 | type == IOTYPE_TX || type == IOTYPE_RX) { | |
809 | ||
810 | if ((u64)ret > c->max_bytes) | |
811 | c->max_bytes = ret; | |
812 | ||
813 | c->total_bytes += ret; | |
814 | p->total_bytes += ret; | |
815 | sample->bytes = ret; | |
816 | } | |
817 | ||
d243144a SF |
818 | /* merge two requests to make svg smaller and render-friendly */ |
819 | if (prev && | |
820 | prev->type == sample->type && | |
821 | prev->err == sample->err && | |
822 | prev->fd == sample->fd && | |
823 | prev->end_time + tchart->merge_dist >= sample->start_time) { | |
824 | ||
825 | sample->bytes += prev->bytes; | |
826 | sample->merges += prev->merges + 1; | |
827 | ||
828 | sample->start_time = prev->start_time; | |
829 | sample->next = prev->next; | |
830 | free(prev); | |
831 | ||
832 | if (!sample->err && sample->bytes > c->max_bytes) | |
833 | c->max_bytes = sample->bytes; | |
834 | } | |
835 | ||
b97b59b9 SF |
836 | tchart->io_events++; |
837 | ||
838 | return 0; | |
839 | } | |
840 | ||
841 | static int | |
842 | process_enter_read(struct timechart *tchart, | |
843 | struct perf_evsel *evsel, | |
844 | struct perf_sample *sample) | |
845 | { | |
846 | long fd = perf_evsel__intval(evsel, sample, "fd"); | |
847 | return pid_begin_io_sample(tchart, sample->tid, IOTYPE_READ, | |
848 | sample->time, fd); | |
849 | } | |
850 | ||
851 | static int | |
852 | process_exit_read(struct timechart *tchart, | |
853 | struct perf_evsel *evsel, | |
854 | struct perf_sample *sample) | |
855 | { | |
856 | long ret = perf_evsel__intval(evsel, sample, "ret"); | |
857 | return pid_end_io_sample(tchart, sample->tid, IOTYPE_READ, | |
858 | sample->time, ret); | |
859 | } | |
860 | ||
861 | static int | |
862 | process_enter_write(struct timechart *tchart, | |
863 | struct perf_evsel *evsel, | |
864 | struct perf_sample *sample) | |
865 | { | |
866 | long fd = perf_evsel__intval(evsel, sample, "fd"); | |
867 | return pid_begin_io_sample(tchart, sample->tid, IOTYPE_WRITE, | |
868 | sample->time, fd); | |
869 | } | |
870 | ||
871 | static int | |
872 | process_exit_write(struct timechart *tchart, | |
873 | struct perf_evsel *evsel, | |
874 | struct perf_sample *sample) | |
875 | { | |
876 | long ret = perf_evsel__intval(evsel, sample, "ret"); | |
877 | return pid_end_io_sample(tchart, sample->tid, IOTYPE_WRITE, | |
878 | sample->time, ret); | |
879 | } | |
880 | ||
881 | static int | |
882 | process_enter_sync(struct timechart *tchart, | |
883 | struct perf_evsel *evsel, | |
884 | struct perf_sample *sample) | |
885 | { | |
886 | long fd = perf_evsel__intval(evsel, sample, "fd"); | |
887 | return pid_begin_io_sample(tchart, sample->tid, IOTYPE_SYNC, | |
888 | sample->time, fd); | |
889 | } | |
890 | ||
891 | static int | |
892 | process_exit_sync(struct timechart *tchart, | |
893 | struct perf_evsel *evsel, | |
894 | struct perf_sample *sample) | |
895 | { | |
896 | long ret = perf_evsel__intval(evsel, sample, "ret"); | |
897 | return pid_end_io_sample(tchart, sample->tid, IOTYPE_SYNC, | |
898 | sample->time, ret); | |
899 | } | |
900 | ||
901 | static int | |
902 | process_enter_tx(struct timechart *tchart, | |
903 | struct perf_evsel *evsel, | |
904 | struct perf_sample *sample) | |
905 | { | |
906 | long fd = perf_evsel__intval(evsel, sample, "fd"); | |
907 | return pid_begin_io_sample(tchart, sample->tid, IOTYPE_TX, | |
908 | sample->time, fd); | |
909 | } | |
910 | ||
911 | static int | |
912 | process_exit_tx(struct timechart *tchart, | |
913 | struct perf_evsel *evsel, | |
914 | struct perf_sample *sample) | |
915 | { | |
916 | long ret = perf_evsel__intval(evsel, sample, "ret"); | |
917 | return pid_end_io_sample(tchart, sample->tid, IOTYPE_TX, | |
918 | sample->time, ret); | |
919 | } | |
920 | ||
921 | static int | |
922 | process_enter_rx(struct timechart *tchart, | |
923 | struct perf_evsel *evsel, | |
924 | struct perf_sample *sample) | |
925 | { | |
926 | long fd = perf_evsel__intval(evsel, sample, "fd"); | |
927 | return pid_begin_io_sample(tchart, sample->tid, IOTYPE_RX, | |
928 | sample->time, fd); | |
929 | } | |
930 | ||
931 | static int | |
932 | process_exit_rx(struct timechart *tchart, | |
933 | struct perf_evsel *evsel, | |
934 | struct perf_sample *sample) | |
935 | { | |
936 | long ret = perf_evsel__intval(evsel, sample, "ret"); | |
937 | return pid_end_io_sample(tchart, sample->tid, IOTYPE_RX, | |
938 | sample->time, ret); | |
939 | } | |
940 | ||
941 | static int | |
942 | process_enter_poll(struct timechart *tchart, | |
943 | struct perf_evsel *evsel, | |
944 | struct perf_sample *sample) | |
945 | { | |
946 | long fd = perf_evsel__intval(evsel, sample, "fd"); | |
947 | return pid_begin_io_sample(tchart, sample->tid, IOTYPE_POLL, | |
948 | sample->time, fd); | |
949 | } | |
950 | ||
951 | static int | |
952 | process_exit_poll(struct timechart *tchart, | |
953 | struct perf_evsel *evsel, | |
954 | struct perf_sample *sample) | |
955 | { | |
956 | long ret = perf_evsel__intval(evsel, sample, "ret"); | |
957 | return pid_end_io_sample(tchart, sample->tid, IOTYPE_POLL, | |
958 | sample->time, ret); | |
959 | } | |
960 | ||
10274989 AV |
961 | /* |
962 | * Sort the pid datastructure | |
963 | */ | |
5e22f6d2 | 964 | static void sort_pids(struct timechart *tchart) |
10274989 AV |
965 | { |
966 | struct per_pid *new_list, *p, *cursor, *prev; | |
967 | /* sort by ppid first, then by pid, lowest to highest */ | |
968 | ||
969 | new_list = NULL; | |
970 | ||
5e22f6d2 ACM |
971 | while (tchart->all_data) { |
972 | p = tchart->all_data; | |
973 | tchart->all_data = p->next; | |
10274989 AV |
974 | p->next = NULL; |
975 | ||
976 | if (new_list == NULL) { | |
977 | new_list = p; | |
978 | p->next = NULL; | |
979 | continue; | |
980 | } | |
981 | prev = NULL; | |
982 | cursor = new_list; | |
983 | while (cursor) { | |
984 | if (cursor->ppid > p->ppid || | |
985 | (cursor->ppid == p->ppid && cursor->pid > p->pid)) { | |
986 | /* must insert before */ | |
987 | if (prev) { | |
988 | p->next = prev->next; | |
989 | prev->next = p; | |
990 | cursor = NULL; | |
991 | continue; | |
992 | } else { | |
993 | p->next = new_list; | |
994 | new_list = p; | |
995 | cursor = NULL; | |
996 | continue; | |
997 | } | |
998 | } | |
999 | ||
1000 | prev = cursor; | |
1001 | cursor = cursor->next; | |
1002 | if (!cursor) | |
1003 | prev->next = p; | |
1004 | } | |
1005 | } | |
5e22f6d2 | 1006 | tchart->all_data = new_list; |
10274989 AV |
1007 | } |
1008 | ||
1009 | ||
985b12e6 | 1010 | static void draw_c_p_states(struct timechart *tchart) |
10274989 AV |
1011 | { |
1012 | struct power_event *pwr; | |
66cc3ada | 1013 | pwr = tchart->power_events; |
10274989 AV |
1014 | |
1015 | /* | |
1016 | * two pass drawing so that the P state bars are on top of the C state blocks | |
1017 | */ | |
1018 | while (pwr) { | |
1019 | if (pwr->type == CSTATE) | |
1020 | svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state); | |
1021 | pwr = pwr->next; | |
1022 | } | |
1023 | ||
66cc3ada | 1024 | pwr = tchart->power_events; |
10274989 AV |
1025 | while (pwr) { |
1026 | if (pwr->type == PSTATE) { | |
1027 | if (!pwr->state) | |
985b12e6 | 1028 | pwr->state = tchart->min_freq; |
10274989 AV |
1029 | svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state); |
1030 | } | |
1031 | pwr = pwr->next; | |
1032 | } | |
1033 | } | |
1034 | ||
5e22f6d2 | 1035 | static void draw_wakeups(struct timechart *tchart) |
10274989 AV |
1036 | { |
1037 | struct wake_event *we; | |
1038 | struct per_pid *p; | |
1039 | struct per_pidcomm *c; | |
1040 | ||
436b0da0 | 1041 | we = tchart->wake_events; |
10274989 AV |
1042 | while (we) { |
1043 | int from = 0, to = 0; | |
4f1202c8 | 1044 | char *task_from = NULL, *task_to = NULL; |
10274989 AV |
1045 | |
1046 | /* locate the column of the waker and wakee */ | |
5e22f6d2 | 1047 | p = tchart->all_data; |
10274989 AV |
1048 | while (p) { |
1049 | if (p->pid == we->waker || p->pid == we->wakee) { | |
1050 | c = p->all; | |
1051 | while (c) { | |
1052 | if (c->Y && c->start_time <= we->time && c->end_time >= we->time) { | |
bbe2987b | 1053 | if (p->pid == we->waker && !from) { |
10274989 | 1054 | from = c->Y; |
3bc2a39c | 1055 | task_from = strdup(c->comm); |
4f1202c8 | 1056 | } |
bbe2987b | 1057 | if (p->pid == we->wakee && !to) { |
10274989 | 1058 | to = c->Y; |
3bc2a39c | 1059 | task_to = strdup(c->comm); |
4f1202c8 | 1060 | } |
10274989 AV |
1061 | } |
1062 | c = c->next; | |
1063 | } | |
3bc2a39c AV |
1064 | c = p->all; |
1065 | while (c) { | |
1066 | if (p->pid == we->waker && !from) { | |
1067 | from = c->Y; | |
1068 | task_from = strdup(c->comm); | |
1069 | } | |
1070 | if (p->pid == we->wakee && !to) { | |
1071 | to = c->Y; | |
1072 | task_to = strdup(c->comm); | |
1073 | } | |
1074 | c = c->next; | |
1075 | } | |
10274989 AV |
1076 | } |
1077 | p = p->next; | |
1078 | } | |
1079 | ||
3bc2a39c AV |
1080 | if (!task_from) { |
1081 | task_from = malloc(40); | |
1082 | sprintf(task_from, "[%i]", we->waker); | |
1083 | } | |
1084 | if (!task_to) { | |
1085 | task_to = malloc(40); | |
1086 | sprintf(task_to, "[%i]", we->wakee); | |
1087 | } | |
1088 | ||
10274989 | 1089 | if (we->waker == -1) |
6f8d67fa | 1090 | svg_interrupt(we->time, to, we->backtrace); |
10274989 | 1091 | else if (from && to && abs(from - to) == 1) |
6f8d67fa | 1092 | svg_wakeline(we->time, from, to, we->backtrace); |
10274989 | 1093 | else |
6f8d67fa SF |
1094 | svg_partial_wakeline(we->time, from, task_from, to, |
1095 | task_to, we->backtrace); | |
10274989 | 1096 | we = we->next; |
3bc2a39c AV |
1097 | |
1098 | free(task_from); | |
1099 | free(task_to); | |
10274989 AV |
1100 | } |
1101 | } | |
1102 | ||
5e22f6d2 | 1103 | static void draw_cpu_usage(struct timechart *tchart) |
10274989 AV |
1104 | { |
1105 | struct per_pid *p; | |
1106 | struct per_pidcomm *c; | |
1107 | struct cpu_sample *sample; | |
5e22f6d2 | 1108 | p = tchart->all_data; |
10274989 AV |
1109 | while (p) { |
1110 | c = p->all; | |
1111 | while (c) { | |
1112 | sample = c->samples; | |
1113 | while (sample) { | |
8b6dcca0 SF |
1114 | if (sample->type == TYPE_RUNNING) { |
1115 | svg_process(sample->cpu, | |
1116 | sample->start_time, | |
1117 | sample->end_time, | |
de996228 | 1118 | p->pid, |
8b6dcca0 SF |
1119 | c->comm, |
1120 | sample->backtrace); | |
1121 | } | |
10274989 AV |
1122 | |
1123 | sample = sample->next; | |
1124 | } | |
1125 | c = c->next; | |
1126 | } | |
1127 | p = p->next; | |
1128 | } | |
1129 | } | |
1130 | ||
b97b59b9 SF |
1131 | static void draw_io_bars(struct timechart *tchart) |
1132 | { | |
1133 | const char *suf; | |
1134 | double bytes; | |
1135 | char comm[256]; | |
1136 | struct per_pid *p; | |
1137 | struct per_pidcomm *c; | |
1138 | struct io_sample *sample; | |
1139 | int Y = 1; | |
1140 | ||
1141 | p = tchart->all_data; | |
1142 | while (p) { | |
1143 | c = p->all; | |
1144 | while (c) { | |
1145 | if (!c->display) { | |
1146 | c->Y = 0; | |
1147 | c = c->next; | |
1148 | continue; | |
1149 | } | |
1150 | ||
1151 | svg_box(Y, c->start_time, c->end_time, "process3"); | |
1152 | sample = c->io_samples; | |
1153 | for (sample = c->io_samples; sample; sample = sample->next) { | |
1154 | double h = (double)sample->bytes / c->max_bytes; | |
1155 | ||
d243144a SF |
1156 | if (tchart->skip_eagain && |
1157 | sample->err == -EAGAIN) | |
1158 | continue; | |
1159 | ||
b97b59b9 SF |
1160 | if (sample->err) |
1161 | h = 1; | |
1162 | ||
1163 | if (sample->type == IOTYPE_SYNC) | |
1164 | svg_fbox(Y, | |
1165 | sample->start_time, | |
1166 | sample->end_time, | |
1167 | 1, | |
1168 | sample->err ? "error" : "sync", | |
1169 | sample->fd, | |
1170 | sample->err, | |
1171 | sample->merges); | |
1172 | else if (sample->type == IOTYPE_POLL) | |
1173 | svg_fbox(Y, | |
1174 | sample->start_time, | |
1175 | sample->end_time, | |
1176 | 1, | |
1177 | sample->err ? "error" : "poll", | |
1178 | sample->fd, | |
1179 | sample->err, | |
1180 | sample->merges); | |
1181 | else if (sample->type == IOTYPE_READ) | |
1182 | svg_ubox(Y, | |
1183 | sample->start_time, | |
1184 | sample->end_time, | |
1185 | h, | |
1186 | sample->err ? "error" : "disk", | |
1187 | sample->fd, | |
1188 | sample->err, | |
1189 | sample->merges); | |
1190 | else if (sample->type == IOTYPE_WRITE) | |
1191 | svg_lbox(Y, | |
1192 | sample->start_time, | |
1193 | sample->end_time, | |
1194 | h, | |
1195 | sample->err ? "error" : "disk", | |
1196 | sample->fd, | |
1197 | sample->err, | |
1198 | sample->merges); | |
1199 | else if (sample->type == IOTYPE_RX) | |
1200 | svg_ubox(Y, | |
1201 | sample->start_time, | |
1202 | sample->end_time, | |
1203 | h, | |
1204 | sample->err ? "error" : "net", | |
1205 | sample->fd, | |
1206 | sample->err, | |
1207 | sample->merges); | |
1208 | else if (sample->type == IOTYPE_TX) | |
1209 | svg_lbox(Y, | |
1210 | sample->start_time, | |
1211 | sample->end_time, | |
1212 | h, | |
1213 | sample->err ? "error" : "net", | |
1214 | sample->fd, | |
1215 | sample->err, | |
1216 | sample->merges); | |
1217 | } | |
1218 | ||
1219 | suf = ""; | |
1220 | bytes = c->total_bytes; | |
1221 | if (bytes > 1024) { | |
1222 | bytes = bytes / 1024; | |
1223 | suf = "K"; | |
1224 | } | |
1225 | if (bytes > 1024) { | |
1226 | bytes = bytes / 1024; | |
1227 | suf = "M"; | |
1228 | } | |
1229 | if (bytes > 1024) { | |
1230 | bytes = bytes / 1024; | |
1231 | suf = "G"; | |
1232 | } | |
1233 | ||
1234 | ||
1235 | sprintf(comm, "%s:%i (%3.1f %sbytes)", c->comm ?: "", p->pid, bytes, suf); | |
1236 | svg_text(Y, c->start_time, comm); | |
1237 | ||
1238 | c->Y = Y; | |
1239 | Y++; | |
1240 | c = c->next; | |
1241 | } | |
1242 | p = p->next; | |
1243 | } | |
1244 | } | |
1245 | ||
985b12e6 | 1246 | static void draw_process_bars(struct timechart *tchart) |
10274989 AV |
1247 | { |
1248 | struct per_pid *p; | |
1249 | struct per_pidcomm *c; | |
1250 | struct cpu_sample *sample; | |
1251 | int Y = 0; | |
1252 | ||
985b12e6 | 1253 | Y = 2 * tchart->numcpus + 2; |
10274989 | 1254 | |
5e22f6d2 | 1255 | p = tchart->all_data; |
10274989 AV |
1256 | while (p) { |
1257 | c = p->all; | |
1258 | while (c) { | |
1259 | if (!c->display) { | |
1260 | c->Y = 0; | |
1261 | c = c->next; | |
1262 | continue; | |
1263 | } | |
1264 | ||
a92fe7b3 | 1265 | svg_box(Y, c->start_time, c->end_time, "process"); |
10274989 AV |
1266 | sample = c->samples; |
1267 | while (sample) { | |
1268 | if (sample->type == TYPE_RUNNING) | |
6f8d67fa SF |
1269 | svg_running(Y, sample->cpu, |
1270 | sample->start_time, | |
1271 | sample->end_time, | |
1272 | sample->backtrace); | |
10274989 | 1273 | if (sample->type == TYPE_BLOCKED) |
6f8d67fa SF |
1274 | svg_blocked(Y, sample->cpu, |
1275 | sample->start_time, | |
1276 | sample->end_time, | |
1277 | sample->backtrace); | |
10274989 | 1278 | if (sample->type == TYPE_WAITING) |
6f8d67fa SF |
1279 | svg_waiting(Y, sample->cpu, |
1280 | sample->start_time, | |
1281 | sample->end_time, | |
1282 | sample->backtrace); | |
10274989 AV |
1283 | sample = sample->next; |
1284 | } | |
1285 | ||
1286 | if (c->comm) { | |
1287 | char comm[256]; | |
1288 | if (c->total_time > 5000000000) /* 5 seconds */ | |
1289 | sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0); | |
1290 | else | |
1291 | sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0); | |
1292 | ||
1293 | svg_text(Y, c->start_time, comm); | |
1294 | } | |
1295 | c->Y = Y; | |
1296 | Y++; | |
1297 | c = c->next; | |
1298 | } | |
1299 | p = p->next; | |
1300 | } | |
1301 | } | |
1302 | ||
bbe2987b AV |
1303 | static void add_process_filter(const char *string) |
1304 | { | |
e0dcd6fb ACM |
1305 | int pid = strtoull(string, NULL, 10); |
1306 | struct process_filter *filt = malloc(sizeof(*filt)); | |
bbe2987b | 1307 | |
bbe2987b AV |
1308 | if (!filt) |
1309 | return; | |
1310 | ||
1311 | filt->name = strdup(string); | |
1312 | filt->pid = pid; | |
1313 | filt->next = process_filter; | |
1314 | ||
1315 | process_filter = filt; | |
1316 | } | |
1317 | ||
1318 | static int passes_filter(struct per_pid *p, struct per_pidcomm *c) | |
1319 | { | |
1320 | struct process_filter *filt; | |
1321 | if (!process_filter) | |
1322 | return 1; | |
1323 | ||
1324 | filt = process_filter; | |
1325 | while (filt) { | |
1326 | if (filt->pid && p->pid == filt->pid) | |
1327 | return 1; | |
1328 | if (strcmp(filt->name, c->comm) == 0) | |
1329 | return 1; | |
1330 | filt = filt->next; | |
1331 | } | |
1332 | return 0; | |
1333 | } | |
1334 | ||
985b12e6 | 1335 | static int determine_display_tasks_filtered(struct timechart *tchart) |
bbe2987b AV |
1336 | { |
1337 | struct per_pid *p; | |
1338 | struct per_pidcomm *c; | |
1339 | int count = 0; | |
1340 | ||
5e22f6d2 | 1341 | p = tchart->all_data; |
bbe2987b AV |
1342 | while (p) { |
1343 | p->display = 0; | |
1344 | if (p->start_time == 1) | |
985b12e6 | 1345 | p->start_time = tchart->first_time; |
bbe2987b AV |
1346 | |
1347 | /* no exit marker, task kept running to the end */ | |
1348 | if (p->end_time == 0) | |
985b12e6 | 1349 | p->end_time = tchart->last_time; |
bbe2987b AV |
1350 | |
1351 | c = p->all; | |
1352 | ||
1353 | while (c) { | |
1354 | c->display = 0; | |
1355 | ||
1356 | if (c->start_time == 1) | |
985b12e6 | 1357 | c->start_time = tchart->first_time; |
bbe2987b AV |
1358 | |
1359 | if (passes_filter(p, c)) { | |
1360 | c->display = 1; | |
1361 | p->display = 1; | |
1362 | count++; | |
1363 | } | |
1364 | ||
1365 | if (c->end_time == 0) | |
985b12e6 | 1366 | c->end_time = tchart->last_time; |
bbe2987b AV |
1367 | |
1368 | c = c->next; | |
1369 | } | |
1370 | p = p->next; | |
1371 | } | |
1372 | return count; | |
1373 | } | |
1374 | ||
985b12e6 | 1375 | static int determine_display_tasks(struct timechart *tchart, u64 threshold) |
10274989 AV |
1376 | { |
1377 | struct per_pid *p; | |
1378 | struct per_pidcomm *c; | |
1379 | int count = 0; | |
1380 | ||
5e22f6d2 | 1381 | p = tchart->all_data; |
10274989 AV |
1382 | while (p) { |
1383 | p->display = 0; | |
1384 | if (p->start_time == 1) | |
985b12e6 | 1385 | p->start_time = tchart->first_time; |
10274989 AV |
1386 | |
1387 | /* no exit marker, task kept running to the end */ | |
1388 | if (p->end_time == 0) | |
985b12e6 | 1389 | p->end_time = tchart->last_time; |
753c505d | 1390 | if (p->total_time >= threshold) |
10274989 AV |
1391 | p->display = 1; |
1392 | ||
1393 | c = p->all; | |
1394 | ||
1395 | while (c) { | |
1396 | c->display = 0; | |
1397 | ||
1398 | if (c->start_time == 1) | |
985b12e6 | 1399 | c->start_time = tchart->first_time; |
10274989 | 1400 | |
753c505d | 1401 | if (c->total_time >= threshold) { |
10274989 AV |
1402 | c->display = 1; |
1403 | count++; | |
1404 | } | |
1405 | ||
1406 | if (c->end_time == 0) | |
985b12e6 | 1407 | c->end_time = tchart->last_time; |
10274989 AV |
1408 | |
1409 | c = c->next; | |
1410 | } | |
1411 | p = p->next; | |
1412 | } | |
1413 | return count; | |
1414 | } | |
1415 | ||
b97b59b9 SF |
1416 | static int determine_display_io_tasks(struct timechart *timechart, u64 threshold) |
1417 | { | |
1418 | struct per_pid *p; | |
1419 | struct per_pidcomm *c; | |
1420 | int count = 0; | |
1421 | ||
1422 | p = timechart->all_data; | |
1423 | while (p) { | |
1424 | /* no exit marker, task kept running to the end */ | |
1425 | if (p->end_time == 0) | |
1426 | p->end_time = timechart->last_time; | |
1427 | ||
1428 | c = p->all; | |
1429 | ||
1430 | while (c) { | |
1431 | c->display = 0; | |
1432 | ||
1433 | if (c->total_bytes >= threshold) { | |
1434 | c->display = 1; | |
1435 | count++; | |
1436 | } | |
10274989 | 1437 | |
b97b59b9 SF |
1438 | if (c->end_time == 0) |
1439 | c->end_time = timechart->last_time; | |
1440 | ||
1441 | c = c->next; | |
1442 | } | |
1443 | p = p->next; | |
1444 | } | |
1445 | return count; | |
1446 | } | |
10274989 | 1447 | |
b97b59b9 | 1448 | #define BYTES_THRESH (1 * 1024 * 1024) |
10274989 AV |
1449 | #define TIME_THRESH 10000000 |
1450 | ||
985b12e6 | 1451 | static void write_svg_file(struct timechart *tchart, const char *filename) |
10274989 AV |
1452 | { |
1453 | u64 i; | |
1454 | int count; | |
b97b59b9 | 1455 | int thresh = tchart->io_events ? BYTES_THRESH : TIME_THRESH; |
10274989 | 1456 | |
985b12e6 ACM |
1457 | if (tchart->power_only) |
1458 | tchart->proc_num = 0; | |
10274989 | 1459 | |
0a8eb275 SF |
1460 | /* We'd like to show at least proc_num tasks; |
1461 | * be less picky if we have fewer */ | |
1462 | do { | |
b97b59b9 SF |
1463 | if (process_filter) |
1464 | count = determine_display_tasks_filtered(tchart); | |
1465 | else if (tchart->io_events) | |
1466 | count = determine_display_io_tasks(tchart, thresh); | |
1467 | else | |
1468 | count = determine_display_tasks(tchart, thresh); | |
0a8eb275 | 1469 | thresh /= 10; |
985b12e6 | 1470 | } while (!process_filter && thresh && count < tchart->proc_num); |
10274989 | 1471 | |
3415d8b8 SF |
1472 | if (!tchart->proc_num) |
1473 | count = 0; | |
1474 | ||
b97b59b9 SF |
1475 | if (tchart->io_events) { |
1476 | open_svg(filename, 0, count, tchart->first_time, tchart->last_time); | |
10274989 | 1477 | |
b97b59b9 SF |
1478 | svg_time_grid(0.5); |
1479 | svg_io_legenda(); | |
10274989 | 1480 | |
b97b59b9 SF |
1481 | draw_io_bars(tchart); |
1482 | } else { | |
1483 | open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time); | |
10274989 | 1484 | |
b97b59b9 SF |
1485 | svg_time_grid(0); |
1486 | ||
1487 | svg_legenda(); | |
1488 | ||
1489 | for (i = 0; i < tchart->numcpus; i++) | |
1490 | svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency); | |
1491 | ||
1492 | draw_cpu_usage(tchart); | |
1493 | if (tchart->proc_num) | |
1494 | draw_process_bars(tchart); | |
1495 | if (!tchart->tasks_only) | |
1496 | draw_c_p_states(tchart); | |
1497 | if (tchart->proc_num) | |
1498 | draw_wakeups(tchart); | |
1499 | } | |
10274989 AV |
1500 | |
1501 | svg_close(); | |
1502 | } | |
1503 | ||
58b9a18e SF |
1504 | static int process_header(struct perf_file_section *section __maybe_unused, |
1505 | struct perf_header *ph, | |
1506 | int feat, | |
1507 | int fd __maybe_unused, | |
1508 | void *data) | |
1509 | { | |
1510 | struct timechart *tchart = data; | |
1511 | ||
1512 | switch (feat) { | |
1513 | case HEADER_NRCPUS: | |
1514 | tchart->numcpus = ph->env.nr_cpus_avail; | |
1515 | break; | |
c5079997 SF |
1516 | |
1517 | case HEADER_CPU_TOPOLOGY: | |
1518 | if (!tchart->topology) | |
1519 | break; | |
1520 | ||
1521 | if (svg_build_topology_map(ph->env.sibling_cores, | |
1522 | ph->env.nr_sibling_cores, | |
1523 | ph->env.sibling_threads, | |
1524 | ph->env.nr_sibling_threads)) | |
1525 | fprintf(stderr, "problem building topology\n"); | |
1526 | break; | |
1527 | ||
58b9a18e SF |
1528 | default: |
1529 | break; | |
1530 | } | |
1531 | ||
1532 | return 0; | |
1533 | } | |
1534 | ||
985b12e6 | 1535 | static int __cmd_timechart(struct timechart *tchart, const char *output_name) |
5cbd0805 | 1536 | { |
5936678e JO |
1537 | const struct perf_evsel_str_handler power_tracepoints[] = { |
1538 | { "power:cpu_idle", process_sample_cpu_idle }, | |
1539 | { "power:cpu_frequency", process_sample_cpu_frequency }, | |
1540 | { "sched:sched_wakeup", process_sample_sched_wakeup }, | |
1541 | { "sched:sched_switch", process_sample_sched_switch }, | |
1542 | #ifdef SUPPORT_OLD_POWER_EVENTS | |
1543 | { "power:power_start", process_sample_power_start }, | |
1544 | { "power:power_end", process_sample_power_end }, | |
1545 | { "power:power_frequency", process_sample_power_frequency }, | |
1546 | #endif | |
b97b59b9 SF |
1547 | |
1548 | { "syscalls:sys_enter_read", process_enter_read }, | |
1549 | { "syscalls:sys_enter_pread64", process_enter_read }, | |
1550 | { "syscalls:sys_enter_readv", process_enter_read }, | |
1551 | { "syscalls:sys_enter_preadv", process_enter_read }, | |
1552 | { "syscalls:sys_enter_write", process_enter_write }, | |
1553 | { "syscalls:sys_enter_pwrite64", process_enter_write }, | |
1554 | { "syscalls:sys_enter_writev", process_enter_write }, | |
1555 | { "syscalls:sys_enter_pwritev", process_enter_write }, | |
1556 | { "syscalls:sys_enter_sync", process_enter_sync }, | |
1557 | { "syscalls:sys_enter_sync_file_range", process_enter_sync }, | |
1558 | { "syscalls:sys_enter_fsync", process_enter_sync }, | |
1559 | { "syscalls:sys_enter_msync", process_enter_sync }, | |
1560 | { "syscalls:sys_enter_recvfrom", process_enter_rx }, | |
1561 | { "syscalls:sys_enter_recvmmsg", process_enter_rx }, | |
1562 | { "syscalls:sys_enter_recvmsg", process_enter_rx }, | |
1563 | { "syscalls:sys_enter_sendto", process_enter_tx }, | |
1564 | { "syscalls:sys_enter_sendmsg", process_enter_tx }, | |
1565 | { "syscalls:sys_enter_sendmmsg", process_enter_tx }, | |
1566 | { "syscalls:sys_enter_epoll_pwait", process_enter_poll }, | |
1567 | { "syscalls:sys_enter_epoll_wait", process_enter_poll }, | |
1568 | { "syscalls:sys_enter_poll", process_enter_poll }, | |
1569 | { "syscalls:sys_enter_ppoll", process_enter_poll }, | |
1570 | { "syscalls:sys_enter_pselect6", process_enter_poll }, | |
1571 | { "syscalls:sys_enter_select", process_enter_poll }, | |
1572 | ||
1573 | { "syscalls:sys_exit_read", process_exit_read }, | |
1574 | { "syscalls:sys_exit_pread64", process_exit_read }, | |
1575 | { "syscalls:sys_exit_readv", process_exit_read }, | |
1576 | { "syscalls:sys_exit_preadv", process_exit_read }, | |
1577 | { "syscalls:sys_exit_write", process_exit_write }, | |
1578 | { "syscalls:sys_exit_pwrite64", process_exit_write }, | |
1579 | { "syscalls:sys_exit_writev", process_exit_write }, | |
1580 | { "syscalls:sys_exit_pwritev", process_exit_write }, | |
1581 | { "syscalls:sys_exit_sync", process_exit_sync }, | |
1582 | { "syscalls:sys_exit_sync_file_range", process_exit_sync }, | |
1583 | { "syscalls:sys_exit_fsync", process_exit_sync }, | |
1584 | { "syscalls:sys_exit_msync", process_exit_sync }, | |
1585 | { "syscalls:sys_exit_recvfrom", process_exit_rx }, | |
1586 | { "syscalls:sys_exit_recvmmsg", process_exit_rx }, | |
1587 | { "syscalls:sys_exit_recvmsg", process_exit_rx }, | |
1588 | { "syscalls:sys_exit_sendto", process_exit_tx }, | |
1589 | { "syscalls:sys_exit_sendmsg", process_exit_tx }, | |
1590 | { "syscalls:sys_exit_sendmmsg", process_exit_tx }, | |
1591 | { "syscalls:sys_exit_epoll_pwait", process_exit_poll }, | |
1592 | { "syscalls:sys_exit_epoll_wait", process_exit_poll }, | |
1593 | { "syscalls:sys_exit_poll", process_exit_poll }, | |
1594 | { "syscalls:sys_exit_ppoll", process_exit_poll }, | |
1595 | { "syscalls:sys_exit_pselect6", process_exit_poll }, | |
1596 | { "syscalls:sys_exit_select", process_exit_poll }, | |
5936678e | 1597 | }; |
f5fc1412 JO |
1598 | struct perf_data_file file = { |
1599 | .path = input_name, | |
1600 | .mode = PERF_DATA_MODE_READ, | |
1601 | }; | |
1602 | ||
1603 | struct perf_session *session = perf_session__new(&file, false, | |
985b12e6 | 1604 | &tchart->tool); |
d549c769 | 1605 | int ret = -EINVAL; |
10274989 | 1606 | |
94c744b6 | 1607 | if (session == NULL) |
52e02834 | 1608 | return -1; |
94c744b6 | 1609 | |
0a7e6d1b | 1610 | symbol__init(&session->header.env); |
dc5c8190 | 1611 | |
58b9a18e SF |
1612 | (void)perf_header__process_sections(&session->header, |
1613 | perf_data_file__fd(session->file), | |
1614 | tchart, | |
1615 | process_header); | |
1616 | ||
d549c769 ACM |
1617 | if (!perf_session__has_traces(session, "timechart record")) |
1618 | goto out_delete; | |
1619 | ||
5936678e JO |
1620 | if (perf_session__set_tracepoints_handlers(session, |
1621 | power_tracepoints)) { | |
1622 | pr_err("Initializing session tracepoint handlers failed\n"); | |
1623 | goto out_delete; | |
1624 | } | |
1625 | ||
985b12e6 | 1626 | ret = perf_session__process_events(session, &tchart->tool); |
5cbd0805 | 1627 | if (ret) |
94c744b6 | 1628 | goto out_delete; |
10274989 | 1629 | |
985b12e6 | 1630 | end_sample_processing(tchart); |
10274989 | 1631 | |
5e22f6d2 | 1632 | sort_pids(tchart); |
10274989 | 1633 | |
985b12e6 | 1634 | write_svg_file(tchart, output_name); |
10274989 | 1635 | |
6beba7ad | 1636 | pr_info("Written %2.1f seconds of trace to %s.\n", |
985b12e6 | 1637 | (tchart->last_time - tchart->first_time) / 1000000000.0, output_name); |
94c744b6 ACM |
1638 | out_delete: |
1639 | perf_session__delete(session); | |
1640 | return ret; | |
10274989 AV |
1641 | } |
1642 | ||
b97b59b9 SF |
1643 | static int timechart__io_record(int argc, const char **argv) |
1644 | { | |
1645 | unsigned int rec_argc, i; | |
1646 | const char **rec_argv; | |
1647 | const char **p; | |
1648 | char *filter = NULL; | |
1649 | ||
1650 | const char * const common_args[] = { | |
1651 | "record", "-a", "-R", "-c", "1", | |
1652 | }; | |
1653 | unsigned int common_args_nr = ARRAY_SIZE(common_args); | |
1654 | ||
1655 | const char * const disk_events[] = { | |
1656 | "syscalls:sys_enter_read", | |
1657 | "syscalls:sys_enter_pread64", | |
1658 | "syscalls:sys_enter_readv", | |
1659 | "syscalls:sys_enter_preadv", | |
1660 | "syscalls:sys_enter_write", | |
1661 | "syscalls:sys_enter_pwrite64", | |
1662 | "syscalls:sys_enter_writev", | |
1663 | "syscalls:sys_enter_pwritev", | |
1664 | "syscalls:sys_enter_sync", | |
1665 | "syscalls:sys_enter_sync_file_range", | |
1666 | "syscalls:sys_enter_fsync", | |
1667 | "syscalls:sys_enter_msync", | |
1668 | ||
1669 | "syscalls:sys_exit_read", | |
1670 | "syscalls:sys_exit_pread64", | |
1671 | "syscalls:sys_exit_readv", | |
1672 | "syscalls:sys_exit_preadv", | |
1673 | "syscalls:sys_exit_write", | |
1674 | "syscalls:sys_exit_pwrite64", | |
1675 | "syscalls:sys_exit_writev", | |
1676 | "syscalls:sys_exit_pwritev", | |
1677 | "syscalls:sys_exit_sync", | |
1678 | "syscalls:sys_exit_sync_file_range", | |
1679 | "syscalls:sys_exit_fsync", | |
1680 | "syscalls:sys_exit_msync", | |
1681 | }; | |
1682 | unsigned int disk_events_nr = ARRAY_SIZE(disk_events); | |
1683 | ||
1684 | const char * const net_events[] = { | |
1685 | "syscalls:sys_enter_recvfrom", | |
1686 | "syscalls:sys_enter_recvmmsg", | |
1687 | "syscalls:sys_enter_recvmsg", | |
1688 | "syscalls:sys_enter_sendto", | |
1689 | "syscalls:sys_enter_sendmsg", | |
1690 | "syscalls:sys_enter_sendmmsg", | |
1691 | ||
1692 | "syscalls:sys_exit_recvfrom", | |
1693 | "syscalls:sys_exit_recvmmsg", | |
1694 | "syscalls:sys_exit_recvmsg", | |
1695 | "syscalls:sys_exit_sendto", | |
1696 | "syscalls:sys_exit_sendmsg", | |
1697 | "syscalls:sys_exit_sendmmsg", | |
1698 | }; | |
1699 | unsigned int net_events_nr = ARRAY_SIZE(net_events); | |
1700 | ||
1701 | const char * const poll_events[] = { | |
1702 | "syscalls:sys_enter_epoll_pwait", | |
1703 | "syscalls:sys_enter_epoll_wait", | |
1704 | "syscalls:sys_enter_poll", | |
1705 | "syscalls:sys_enter_ppoll", | |
1706 | "syscalls:sys_enter_pselect6", | |
1707 | "syscalls:sys_enter_select", | |
1708 | ||
1709 | "syscalls:sys_exit_epoll_pwait", | |
1710 | "syscalls:sys_exit_epoll_wait", | |
1711 | "syscalls:sys_exit_poll", | |
1712 | "syscalls:sys_exit_ppoll", | |
1713 | "syscalls:sys_exit_pselect6", | |
1714 | "syscalls:sys_exit_select", | |
1715 | }; | |
1716 | unsigned int poll_events_nr = ARRAY_SIZE(poll_events); | |
1717 | ||
1718 | rec_argc = common_args_nr + | |
1719 | disk_events_nr * 4 + | |
1720 | net_events_nr * 4 + | |
1721 | poll_events_nr * 4 + | |
1722 | argc; | |
1723 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); | |
1724 | ||
1725 | if (rec_argv == NULL) | |
1726 | return -ENOMEM; | |
1727 | ||
1728 | if (asprintf(&filter, "common_pid != %d", getpid()) < 0) | |
1729 | return -ENOMEM; | |
1730 | ||
1731 | p = rec_argv; | |
1732 | for (i = 0; i < common_args_nr; i++) | |
1733 | *p++ = strdup(common_args[i]); | |
1734 | ||
1735 | for (i = 0; i < disk_events_nr; i++) { | |
1736 | if (!is_valid_tracepoint(disk_events[i])) { | |
1737 | rec_argc -= 4; | |
1738 | continue; | |
1739 | } | |
1740 | ||
1741 | *p++ = "-e"; | |
1742 | *p++ = strdup(disk_events[i]); | |
1743 | *p++ = "--filter"; | |
1744 | *p++ = filter; | |
1745 | } | |
1746 | for (i = 0; i < net_events_nr; i++) { | |
1747 | if (!is_valid_tracepoint(net_events[i])) { | |
1748 | rec_argc -= 4; | |
1749 | continue; | |
1750 | } | |
1751 | ||
1752 | *p++ = "-e"; | |
1753 | *p++ = strdup(net_events[i]); | |
1754 | *p++ = "--filter"; | |
1755 | *p++ = filter; | |
1756 | } | |
1757 | for (i = 0; i < poll_events_nr; i++) { | |
1758 | if (!is_valid_tracepoint(poll_events[i])) { | |
1759 | rec_argc -= 4; | |
1760 | continue; | |
1761 | } | |
1762 | ||
1763 | *p++ = "-e"; | |
1764 | *p++ = strdup(poll_events[i]); | |
1765 | *p++ = "--filter"; | |
1766 | *p++ = filter; | |
1767 | } | |
1768 | ||
1769 | for (i = 0; i < (unsigned int)argc; i++) | |
1770 | *p++ = argv[i]; | |
1771 | ||
1772 | return cmd_record(rec_argc, rec_argv, NULL); | |
1773 | } | |
1774 | ||
1775 | ||
985b12e6 | 1776 | static int timechart__record(struct timechart *tchart, int argc, const char **argv) |
3c09eebd | 1777 | { |
367b3152 SF |
1778 | unsigned int rec_argc, i, j; |
1779 | const char **rec_argv; | |
1780 | const char **p; | |
1781 | unsigned int record_elems; | |
1782 | ||
1783 | const char * const common_args[] = { | |
4a4d371a | 1784 | "record", "-a", "-R", "-c", "1", |
367b3152 SF |
1785 | }; |
1786 | unsigned int common_args_nr = ARRAY_SIZE(common_args); | |
1787 | ||
6f8d67fa SF |
1788 | const char * const backtrace_args[] = { |
1789 | "-g", | |
1790 | }; | |
1791 | unsigned int backtrace_args_no = ARRAY_SIZE(backtrace_args); | |
1792 | ||
367b3152 SF |
1793 | const char * const power_args[] = { |
1794 | "-e", "power:cpu_frequency", | |
1795 | "-e", "power:cpu_idle", | |
1796 | }; | |
1797 | unsigned int power_args_nr = ARRAY_SIZE(power_args); | |
1798 | ||
1799 | const char * const old_power_args[] = { | |
1800 | #ifdef SUPPORT_OLD_POWER_EVENTS | |
73bdc715 ACM |
1801 | "-e", "power:power_start", |
1802 | "-e", "power:power_end", | |
1803 | "-e", "power:power_frequency", | |
73bdc715 | 1804 | #endif |
367b3152 SF |
1805 | }; |
1806 | unsigned int old_power_args_nr = ARRAY_SIZE(old_power_args); | |
1807 | ||
1808 | const char * const tasks_args[] = { | |
73bdc715 ACM |
1809 | "-e", "sched:sched_wakeup", |
1810 | "-e", "sched:sched_switch", | |
1811 | }; | |
367b3152 | 1812 | unsigned int tasks_args_nr = ARRAY_SIZE(tasks_args); |
20c457b8 TR |
1813 | |
1814 | #ifdef SUPPORT_OLD_POWER_EVENTS | |
1815 | if (!is_valid_tracepoint("power:cpu_idle") && | |
1816 | is_valid_tracepoint("power:power_start")) { | |
1817 | use_old_power_events = 1; | |
367b3152 SF |
1818 | power_args_nr = 0; |
1819 | } else { | |
1820 | old_power_args_nr = 0; | |
20c457b8 TR |
1821 | } |
1822 | #endif | |
3c09eebd | 1823 | |
985b12e6 | 1824 | if (tchart->power_only) |
367b3152 SF |
1825 | tasks_args_nr = 0; |
1826 | ||
985b12e6 | 1827 | if (tchart->tasks_only) { |
367b3152 SF |
1828 | power_args_nr = 0; |
1829 | old_power_args_nr = 0; | |
1830 | } | |
1831 | ||
985b12e6 | 1832 | if (!tchart->with_backtrace) |
6f8d67fa SF |
1833 | backtrace_args_no = 0; |
1834 | ||
367b3152 | 1835 | record_elems = common_args_nr + tasks_args_nr + |
6f8d67fa | 1836 | power_args_nr + old_power_args_nr + backtrace_args_no; |
367b3152 SF |
1837 | |
1838 | rec_argc = record_elems + argc; | |
3c09eebd AV |
1839 | rec_argv = calloc(rec_argc + 1, sizeof(char *)); |
1840 | ||
ce47dc56 CS |
1841 | if (rec_argv == NULL) |
1842 | return -ENOMEM; | |
1843 | ||
367b3152 SF |
1844 | p = rec_argv; |
1845 | for (i = 0; i < common_args_nr; i++) | |
1846 | *p++ = strdup(common_args[i]); | |
1847 | ||
6f8d67fa SF |
1848 | for (i = 0; i < backtrace_args_no; i++) |
1849 | *p++ = strdup(backtrace_args[i]); | |
1850 | ||
367b3152 SF |
1851 | for (i = 0; i < tasks_args_nr; i++) |
1852 | *p++ = strdup(tasks_args[i]); | |
1853 | ||
1854 | for (i = 0; i < power_args_nr; i++) | |
1855 | *p++ = strdup(power_args[i]); | |
3c09eebd | 1856 | |
367b3152 SF |
1857 | for (i = 0; i < old_power_args_nr; i++) |
1858 | *p++ = strdup(old_power_args[i]); | |
3c09eebd | 1859 | |
263f89bf | 1860 | for (j = 0; j < (unsigned int)argc; j++) |
367b3152 SF |
1861 | *p++ = argv[j]; |
1862 | ||
1863 | return cmd_record(rec_argc, rec_argv, NULL); | |
3c09eebd AV |
1864 | } |
1865 | ||
bbe2987b | 1866 | static int |
1d037ca1 IT |
1867 | parse_process(const struct option *opt __maybe_unused, const char *arg, |
1868 | int __maybe_unused unset) | |
bbe2987b AV |
1869 | { |
1870 | if (arg) | |
1871 | add_process_filter(arg); | |
1872 | return 0; | |
1873 | } | |
1874 | ||
e57a2dff SF |
1875 | static int |
1876 | parse_highlight(const struct option *opt __maybe_unused, const char *arg, | |
1877 | int __maybe_unused unset) | |
1878 | { | |
1879 | unsigned long duration = strtoul(arg, NULL, 0); | |
1880 | ||
1881 | if (svg_highlight || svg_highlight_name) | |
1882 | return -1; | |
1883 | ||
1884 | if (duration) | |
1885 | svg_highlight = duration; | |
1886 | else | |
1887 | svg_highlight_name = strdup(arg); | |
1888 | ||
1889 | return 0; | |
1890 | } | |
1891 | ||
d243144a SF |
1892 | static int |
1893 | parse_time(const struct option *opt, const char *arg, int __maybe_unused unset) | |
1894 | { | |
1895 | char unit = 'n'; | |
1896 | u64 *value = opt->value; | |
1897 | ||
1898 | if (sscanf(arg, "%" PRIu64 "%cs", value, &unit) > 0) { | |
1899 | switch (unit) { | |
1900 | case 'm': | |
1901 | *value *= 1000000; | |
1902 | break; | |
1903 | case 'u': | |
1904 | *value *= 1000; | |
1905 | break; | |
1906 | case 'n': | |
1907 | break; | |
1908 | default: | |
1909 | return -1; | |
1910 | } | |
1911 | } | |
1912 | ||
1913 | return 0; | |
1914 | } | |
1915 | ||
73bdc715 ACM |
1916 | int cmd_timechart(int argc, const char **argv, |
1917 | const char *prefix __maybe_unused) | |
1918 | { | |
985b12e6 ACM |
1919 | struct timechart tchart = { |
1920 | .tool = { | |
1921 | .comm = process_comm_event, | |
1922 | .fork = process_fork_event, | |
1923 | .exit = process_exit_event, | |
1924 | .sample = process_sample_event, | |
0a8cb85c | 1925 | .ordered_events = true, |
985b12e6 ACM |
1926 | }, |
1927 | .proc_num = 15, | |
d243144a SF |
1928 | .min_time = 1000000, |
1929 | .merge_dist = 1000, | |
985b12e6 | 1930 | }; |
73bdc715 | 1931 | const char *output_name = "output.svg"; |
367b3152 | 1932 | const struct option timechart_options[] = { |
73bdc715 ACM |
1933 | OPT_STRING('i', "input", &input_name, "file", "input file name"), |
1934 | OPT_STRING('o', "output", &output_name, "file", "output file name"), | |
1935 | OPT_INTEGER('w', "width", &svg_page_width, "page width"), | |
e57a2dff SF |
1936 | OPT_CALLBACK(0, "highlight", NULL, "duration or task name", |
1937 | "highlight tasks. Pass duration in ns or process name.", | |
1938 | parse_highlight), | |
985b12e6 ACM |
1939 | OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"), |
1940 | OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only, | |
c87097d3 | 1941 | "output processes data only"), |
bbe2987b AV |
1942 | OPT_CALLBACK('p', "process", NULL, "process", |
1943 | "process selector. Pass a pid or process name.", | |
1944 | parse_process), | |
ec5761ea DA |
1945 | OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", |
1946 | "Look for files with symbols relative to this directory"), | |
985b12e6 | 1947 | OPT_INTEGER('n', "proc-num", &tchart.proc_num, |
54874e32 | 1948 | "min. number of tasks to print"), |
c5079997 SF |
1949 | OPT_BOOLEAN('t', "topology", &tchart.topology, |
1950 | "sort CPUs according to topology"), | |
d243144a SF |
1951 | OPT_BOOLEAN(0, "io-skip-eagain", &tchart.skip_eagain, |
1952 | "skip EAGAIN errors"), | |
1953 | OPT_CALLBACK(0, "io-min-time", &tchart.min_time, "time", | |
1954 | "all IO faster than min-time will visually appear longer", | |
1955 | parse_time), | |
1956 | OPT_CALLBACK(0, "io-merge-dist", &tchart.merge_dist, "time", | |
1957 | "merge events that are merge-dist us apart", | |
1958 | parse_time), | |
10274989 | 1959 | OPT_END() |
73bdc715 ACM |
1960 | }; |
1961 | const char * const timechart_usage[] = { | |
1962 | "perf timechart [<options>] {record}", | |
1963 | NULL | |
1964 | }; | |
10274989 | 1965 | |
e5b2c207 | 1966 | const struct option timechart_record_options[] = { |
985b12e6 ACM |
1967 | OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"), |
1968 | OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only, | |
367b3152 | 1969 | "output processes data only"), |
b97b59b9 SF |
1970 | OPT_BOOLEAN('I', "io-only", &tchart.io_only, |
1971 | "record only IO data"), | |
985b12e6 | 1972 | OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"), |
367b3152 SF |
1973 | OPT_END() |
1974 | }; | |
e5b2c207 | 1975 | const char * const timechart_record_usage[] = { |
367b3152 SF |
1976 | "perf timechart record [<options>]", |
1977 | NULL | |
1978 | }; | |
1979 | argc = parse_options(argc, argv, timechart_options, timechart_usage, | |
3c09eebd | 1980 | PARSE_OPT_STOP_AT_NON_OPTION); |
10274989 | 1981 | |
985b12e6 | 1982 | if (tchart.power_only && tchart.tasks_only) { |
c87097d3 SF |
1983 | pr_err("-P and -T options cannot be used at the same time.\n"); |
1984 | return -1; | |
1985 | } | |
1986 | ||
367b3152 | 1987 | if (argc && !strncmp(argv[0], "rec", 3)) { |
e5b2c207 NK |
1988 | argc = parse_options(argc, argv, timechart_record_options, |
1989 | timechart_record_usage, | |
367b3152 SF |
1990 | PARSE_OPT_STOP_AT_NON_OPTION); |
1991 | ||
985b12e6 | 1992 | if (tchart.power_only && tchart.tasks_only) { |
367b3152 SF |
1993 | pr_err("-P and -T options cannot be used at the same time.\n"); |
1994 | return -1; | |
1995 | } | |
1996 | ||
b97b59b9 SF |
1997 | if (tchart.io_only) |
1998 | return timechart__io_record(argc, argv); | |
1999 | else | |
2000 | return timechart__record(&tchart, argc, argv); | |
367b3152 SF |
2001 | } else if (argc) |
2002 | usage_with_options(timechart_usage, timechart_options); | |
10274989 AV |
2003 | |
2004 | setup_pager(); | |
2005 | ||
985b12e6 | 2006 | return __cmd_timechart(&tchart, output_name); |
10274989 | 2007 | } |