2 * builtin-timechart.c - make an svg timechart of system activity
4 * (C) Copyright 2009 Intel Corporation
7 * Arjan van de Ven <arjan@linux.intel.com>
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
17 #include <traceevent/event-parse.h>
21 #include "util/util.h"
23 #include "util/color.h"
24 #include <linux/list.h>
25 #include "util/cache.h"
26 #include "util/evlist.h"
27 #include "util/evsel.h"
28 #include <linux/kernel.h>
29 #include <linux/rbtree.h>
30 #include <linux/time64.h>
31 #include "util/symbol.h"
32 #include "util/thread.h"
33 #include "util/callchain.h"
36 #include "util/header.h"
37 #include <subcmd/parse-options.h>
38 #include "util/parse-events.h"
39 #include "util/event.h"
40 #include "util/session.h"
41 #include "util/svghelper.h"
42 #include "util/tool.h"
43 #include "util/data.h"
44 #include "util/debug.h"
46 #ifdef LACKS_OPEN_MEMSTREAM_PROTOTYPE
47 FILE *open_memstream(char **ptr
, size_t *sizeloc
);
50 #define SUPPORT_OLD_POWER_EVENTS 1
51 #define PWR_EVENT_EXIT -1
58 struct perf_tool tool
;
59 struct per_pid
*all_data
;
60 struct power_event
*power_events
;
61 struct wake_event
*wake_events
;
64 u64 min_freq
, /* Lowest CPU frequency seen */
65 max_freq
, /* Highest CPU frequency seen */
67 first_time
, last_time
;
73 /* IO related settings */
86 * Datastructure layout:
87 * We keep an list of "pid"s, matching the kernels notion of a task struct.
88 * Each "pid" entry, has a list of "comm"s.
89 * this is because we want to track different programs different, while
90 * exec will reuse the original pid (by design).
91 * Each comm has a list of samples that will be used to draw
107 struct per_pidcomm
*all
;
108 struct per_pidcomm
*current
;
113 struct per_pidcomm
*next
;
129 struct cpu_sample
*samples
;
130 struct io_sample
*io_samples
;
133 struct sample_wrapper
{
134 struct sample_wrapper
*next
;
137 unsigned char data
[0];
141 #define TYPE_RUNNING 1
142 #define TYPE_WAITING 2
143 #define TYPE_BLOCKED 3
146 struct cpu_sample
*next
;
152 const char *backtrace
;
165 struct io_sample
*next
;
180 struct power_event
*next
;
189 struct wake_event
*next
;
193 const char *backtrace
;
196 struct process_filter
{
199 struct process_filter
*next
;
202 static struct process_filter
*process_filter
;
205 static struct per_pid
*find_create_pid(struct timechart
*tchart
, int pid
)
207 struct per_pid
*cursor
= tchart
->all_data
;
210 if (cursor
->pid
== pid
)
212 cursor
= cursor
->next
;
214 cursor
= zalloc(sizeof(*cursor
));
215 assert(cursor
!= NULL
);
217 cursor
->next
= tchart
->all_data
;
218 tchart
->all_data
= cursor
;
222 static void pid_set_comm(struct timechart
*tchart
, int pid
, char *comm
)
225 struct per_pidcomm
*c
;
226 p
= find_create_pid(tchart
, pid
);
229 if (c
->comm
&& strcmp(c
->comm
, comm
) == 0) {
234 c
->comm
= strdup(comm
);
240 c
= zalloc(sizeof(*c
));
242 c
->comm
= strdup(comm
);
248 static void pid_fork(struct timechart
*tchart
, int pid
, int ppid
, u64 timestamp
)
250 struct per_pid
*p
, *pp
;
251 p
= find_create_pid(tchart
, pid
);
252 pp
= find_create_pid(tchart
, ppid
);
254 if (pp
->current
&& pp
->current
->comm
&& !p
->current
)
255 pid_set_comm(tchart
, pid
, pp
->current
->comm
);
257 p
->start_time
= timestamp
;
258 if (p
->current
&& !p
->current
->start_time
) {
259 p
->current
->start_time
= timestamp
;
260 p
->current
->state_since
= timestamp
;
264 static void pid_exit(struct timechart
*tchart
, int pid
, u64 timestamp
)
267 p
= find_create_pid(tchart
, pid
);
268 p
->end_time
= timestamp
;
270 p
->current
->end_time
= timestamp
;
273 static void pid_put_sample(struct timechart
*tchart
, int pid
, int type
,
274 unsigned int cpu
, u64 start
, u64 end
,
275 const char *backtrace
)
278 struct per_pidcomm
*c
;
279 struct cpu_sample
*sample
;
281 p
= find_create_pid(tchart
, pid
);
284 c
= zalloc(sizeof(*c
));
291 sample
= zalloc(sizeof(*sample
));
292 assert(sample
!= NULL
);
293 sample
->start_time
= start
;
294 sample
->end_time
= end
;
296 sample
->next
= c
->samples
;
298 sample
->backtrace
= backtrace
;
301 if (sample
->type
== TYPE_RUNNING
&& end
> start
&& start
> 0) {
302 c
->total_time
+= (end
-start
);
303 p
->total_time
+= (end
-start
);
306 if (c
->start_time
== 0 || c
->start_time
> start
)
307 c
->start_time
= start
;
308 if (p
->start_time
== 0 || p
->start_time
> start
)
309 p
->start_time
= start
;
312 #define MAX_CPUS 4096
314 static u64 cpus_cstate_start_times
[MAX_CPUS
];
315 static int cpus_cstate_state
[MAX_CPUS
];
316 static u64 cpus_pstate_start_times
[MAX_CPUS
];
317 static u64 cpus_pstate_state
[MAX_CPUS
];
319 static int process_comm_event(struct perf_tool
*tool
,
320 union perf_event
*event
,
321 struct perf_sample
*sample __maybe_unused
,
322 struct machine
*machine __maybe_unused
)
324 struct timechart
*tchart
= container_of(tool
, struct timechart
, tool
);
325 pid_set_comm(tchart
, event
->comm
.tid
, event
->comm
.comm
);
329 static int process_fork_event(struct perf_tool
*tool
,
330 union perf_event
*event
,
331 struct perf_sample
*sample __maybe_unused
,
332 struct machine
*machine __maybe_unused
)
334 struct timechart
*tchart
= container_of(tool
, struct timechart
, tool
);
335 pid_fork(tchart
, event
->fork
.pid
, event
->fork
.ppid
, event
->fork
.time
);
339 static int process_exit_event(struct perf_tool
*tool
,
340 union perf_event
*event
,
341 struct perf_sample
*sample __maybe_unused
,
342 struct machine
*machine __maybe_unused
)
344 struct timechart
*tchart
= container_of(tool
, struct timechart
, tool
);
345 pid_exit(tchart
, event
->fork
.pid
, event
->fork
.time
);
349 #ifdef SUPPORT_OLD_POWER_EVENTS
350 static int use_old_power_events
;
353 static void c_state_start(int cpu
, u64 timestamp
, int state
)
355 cpus_cstate_start_times
[cpu
] = timestamp
;
356 cpus_cstate_state
[cpu
] = state
;
359 static void c_state_end(struct timechart
*tchart
, int cpu
, u64 timestamp
)
361 struct power_event
*pwr
= zalloc(sizeof(*pwr
));
366 pwr
->state
= cpus_cstate_state
[cpu
];
367 pwr
->start_time
= cpus_cstate_start_times
[cpu
];
368 pwr
->end_time
= timestamp
;
371 pwr
->next
= tchart
->power_events
;
373 tchart
->power_events
= pwr
;
376 static void p_state_change(struct timechart
*tchart
, int cpu
, u64 timestamp
, u64 new_freq
)
378 struct power_event
*pwr
;
380 if (new_freq
> 8000000) /* detect invalid data */
383 pwr
= zalloc(sizeof(*pwr
));
387 pwr
->state
= cpus_pstate_state
[cpu
];
388 pwr
->start_time
= cpus_pstate_start_times
[cpu
];
389 pwr
->end_time
= timestamp
;
392 pwr
->next
= tchart
->power_events
;
394 if (!pwr
->start_time
)
395 pwr
->start_time
= tchart
->first_time
;
397 tchart
->power_events
= pwr
;
399 cpus_pstate_state
[cpu
] = new_freq
;
400 cpus_pstate_start_times
[cpu
] = timestamp
;
402 if ((u64
)new_freq
> tchart
->max_freq
)
403 tchart
->max_freq
= new_freq
;
405 if (new_freq
< tchart
->min_freq
|| tchart
->min_freq
== 0)
406 tchart
->min_freq
= new_freq
;
408 if (new_freq
== tchart
->max_freq
- 1000)
409 tchart
->turbo_frequency
= tchart
->max_freq
;
412 static void sched_wakeup(struct timechart
*tchart
, int cpu
, u64 timestamp
,
413 int waker
, int wakee
, u8 flags
, const char *backtrace
)
416 struct wake_event
*we
= zalloc(sizeof(*we
));
421 we
->time
= timestamp
;
423 we
->backtrace
= backtrace
;
425 if ((flags
& TRACE_FLAG_HARDIRQ
) || (flags
& TRACE_FLAG_SOFTIRQ
))
429 we
->next
= tchart
->wake_events
;
430 tchart
->wake_events
= we
;
431 p
= find_create_pid(tchart
, we
->wakee
);
433 if (p
&& p
->current
&& p
->current
->state
== TYPE_NONE
) {
434 p
->current
->state_since
= timestamp
;
435 p
->current
->state
= TYPE_WAITING
;
437 if (p
&& p
->current
&& p
->current
->state
== TYPE_BLOCKED
) {
438 pid_put_sample(tchart
, p
->pid
, p
->current
->state
, cpu
,
439 p
->current
->state_since
, timestamp
, NULL
);
440 p
->current
->state_since
= timestamp
;
441 p
->current
->state
= TYPE_WAITING
;
445 static void sched_switch(struct timechart
*tchart
, int cpu
, u64 timestamp
,
446 int prev_pid
, int next_pid
, u64 prev_state
,
447 const char *backtrace
)
449 struct per_pid
*p
= NULL
, *prev_p
;
451 prev_p
= find_create_pid(tchart
, prev_pid
);
453 p
= find_create_pid(tchart
, next_pid
);
455 if (prev_p
->current
&& prev_p
->current
->state
!= TYPE_NONE
)
456 pid_put_sample(tchart
, prev_pid
, TYPE_RUNNING
, cpu
,
457 prev_p
->current
->state_since
, timestamp
,
459 if (p
&& p
->current
) {
460 if (p
->current
->state
!= TYPE_NONE
)
461 pid_put_sample(tchart
, next_pid
, p
->current
->state
, cpu
,
462 p
->current
->state_since
, timestamp
,
465 p
->current
->state_since
= timestamp
;
466 p
->current
->state
= TYPE_RUNNING
;
469 if (prev_p
->current
) {
470 prev_p
->current
->state
= TYPE_NONE
;
471 prev_p
->current
->state_since
= timestamp
;
473 prev_p
->current
->state
= TYPE_BLOCKED
;
475 prev_p
->current
->state
= TYPE_WAITING
;
479 static const char *cat_backtrace(union perf_event
*event
,
480 struct perf_sample
*sample
,
481 struct machine
*machine
)
483 struct addr_location al
;
487 u8 cpumode
= PERF_RECORD_MISC_USER
;
488 struct addr_location tal
;
489 struct ip_callchain
*chain
= sample
->callchain
;
490 FILE *f
= open_memstream(&p
, &p_len
);
493 perror("open_memstream error");
500 if (machine__resolve(machine
, &al
, sample
) < 0) {
501 fprintf(stderr
, "problem processing %d event, skipping it.\n",
506 for (i
= 0; i
< chain
->nr
; i
++) {
509 if (callchain_param
.order
== ORDER_CALLEE
)
512 ip
= chain
->ips
[chain
->nr
- i
- 1];
514 if (ip
>= PERF_CONTEXT_MAX
) {
516 case PERF_CONTEXT_HV
:
517 cpumode
= PERF_RECORD_MISC_HYPERVISOR
;
519 case PERF_CONTEXT_KERNEL
:
520 cpumode
= PERF_RECORD_MISC_KERNEL
;
522 case PERF_CONTEXT_USER
:
523 cpumode
= PERF_RECORD_MISC_USER
;
526 pr_debug("invalid callchain context: "
527 "%"PRId64
"\n", (s64
) ip
);
530 * It seems the callchain is corrupted.
540 thread__find_addr_location(al
.thread
, cpumode
,
541 MAP__FUNCTION
, ip
, &tal
);
544 fprintf(f
, "..... %016" PRIx64
" %s\n", ip
,
547 fprintf(f
, "..... %016" PRIx64
"\n", ip
);
550 addr_location__put(&al
);
557 typedef int (*tracepoint_handler
)(struct timechart
*tchart
,
558 struct perf_evsel
*evsel
,
559 struct perf_sample
*sample
,
560 const char *backtrace
);
562 static int process_sample_event(struct perf_tool
*tool
,
563 union perf_event
*event
,
564 struct perf_sample
*sample
,
565 struct perf_evsel
*evsel
,
566 struct machine
*machine
)
568 struct timechart
*tchart
= container_of(tool
, struct timechart
, tool
);
570 if (evsel
->attr
.sample_type
& PERF_SAMPLE_TIME
) {
571 if (!tchart
->first_time
|| tchart
->first_time
> sample
->time
)
572 tchart
->first_time
= sample
->time
;
573 if (tchart
->last_time
< sample
->time
)
574 tchart
->last_time
= sample
->time
;
577 if (evsel
->handler
!= NULL
) {
578 tracepoint_handler f
= evsel
->handler
;
579 return f(tchart
, evsel
, sample
,
580 cat_backtrace(event
, sample
, machine
));
587 process_sample_cpu_idle(struct timechart
*tchart __maybe_unused
,
588 struct perf_evsel
*evsel
,
589 struct perf_sample
*sample
,
590 const char *backtrace __maybe_unused
)
592 u32 state
= perf_evsel__intval(evsel
, sample
, "state");
593 u32 cpu_id
= perf_evsel__intval(evsel
, sample
, "cpu_id");
595 if (state
== (u32
)PWR_EVENT_EXIT
)
596 c_state_end(tchart
, cpu_id
, sample
->time
);
598 c_state_start(cpu_id
, sample
->time
, state
);
603 process_sample_cpu_frequency(struct timechart
*tchart
,
604 struct perf_evsel
*evsel
,
605 struct perf_sample
*sample
,
606 const char *backtrace __maybe_unused
)
608 u32 state
= perf_evsel__intval(evsel
, sample
, "state");
609 u32 cpu_id
= perf_evsel__intval(evsel
, sample
, "cpu_id");
611 p_state_change(tchart
, cpu_id
, sample
->time
, state
);
616 process_sample_sched_wakeup(struct timechart
*tchart
,
617 struct perf_evsel
*evsel
,
618 struct perf_sample
*sample
,
619 const char *backtrace
)
621 u8 flags
= perf_evsel__intval(evsel
, sample
, "common_flags");
622 int waker
= perf_evsel__intval(evsel
, sample
, "common_pid");
623 int wakee
= perf_evsel__intval(evsel
, sample
, "pid");
625 sched_wakeup(tchart
, sample
->cpu
, sample
->time
, waker
, wakee
, flags
, backtrace
);
630 process_sample_sched_switch(struct timechart
*tchart
,
631 struct perf_evsel
*evsel
,
632 struct perf_sample
*sample
,
633 const char *backtrace
)
635 int prev_pid
= perf_evsel__intval(evsel
, sample
, "prev_pid");
636 int next_pid
= perf_evsel__intval(evsel
, sample
, "next_pid");
637 u64 prev_state
= perf_evsel__intval(evsel
, sample
, "prev_state");
639 sched_switch(tchart
, sample
->cpu
, sample
->time
, prev_pid
, next_pid
,
640 prev_state
, backtrace
);
644 #ifdef SUPPORT_OLD_POWER_EVENTS
646 process_sample_power_start(struct timechart
*tchart __maybe_unused
,
647 struct perf_evsel
*evsel
,
648 struct perf_sample
*sample
,
649 const char *backtrace __maybe_unused
)
651 u64 cpu_id
= perf_evsel__intval(evsel
, sample
, "cpu_id");
652 u64 value
= perf_evsel__intval(evsel
, sample
, "value");
654 c_state_start(cpu_id
, sample
->time
, value
);
659 process_sample_power_end(struct timechart
*tchart
,
660 struct perf_evsel
*evsel __maybe_unused
,
661 struct perf_sample
*sample
,
662 const char *backtrace __maybe_unused
)
664 c_state_end(tchart
, sample
->cpu
, sample
->time
);
669 process_sample_power_frequency(struct timechart
*tchart
,
670 struct perf_evsel
*evsel
,
671 struct perf_sample
*sample
,
672 const char *backtrace __maybe_unused
)
674 u64 cpu_id
= perf_evsel__intval(evsel
, sample
, "cpu_id");
675 u64 value
= perf_evsel__intval(evsel
, sample
, "value");
677 p_state_change(tchart
, cpu_id
, sample
->time
, value
);
680 #endif /* SUPPORT_OLD_POWER_EVENTS */
683 * After the last sample we need to wrap up the current C/P state
684 * and close out each CPU for these.
686 static void end_sample_processing(struct timechart
*tchart
)
689 struct power_event
*pwr
;
691 for (cpu
= 0; cpu
<= tchart
->numcpus
; cpu
++) {
694 pwr
= zalloc(sizeof(*pwr
));
698 pwr
->state
= cpus_cstate_state
[cpu
];
699 pwr
->start_time
= cpus_cstate_start_times
[cpu
];
700 pwr
->end_time
= tchart
->last_time
;
703 pwr
->next
= tchart
->power_events
;
705 tchart
->power_events
= pwr
;
709 pwr
= zalloc(sizeof(*pwr
));
713 pwr
->state
= cpus_pstate_state
[cpu
];
714 pwr
->start_time
= cpus_pstate_start_times
[cpu
];
715 pwr
->end_time
= tchart
->last_time
;
718 pwr
->next
= tchart
->power_events
;
720 if (!pwr
->start_time
)
721 pwr
->start_time
= tchart
->first_time
;
723 pwr
->state
= tchart
->min_freq
;
724 tchart
->power_events
= pwr
;
728 static int pid_begin_io_sample(struct timechart
*tchart
, int pid
, int type
,
731 struct per_pid
*p
= find_create_pid(tchart
, pid
);
732 struct per_pidcomm
*c
= p
->current
;
733 struct io_sample
*sample
;
734 struct io_sample
*prev
;
737 c
= zalloc(sizeof(*c
));
745 prev
= c
->io_samples
;
747 if (prev
&& prev
->start_time
&& !prev
->end_time
) {
748 pr_warning("Skip invalid start event: "
749 "previous event already started!\n");
751 /* remove previous event that has been started,
752 * we are not sure we will ever get an end for it */
753 c
->io_samples
= prev
->next
;
758 sample
= zalloc(sizeof(*sample
));
761 sample
->start_time
= start
;
764 sample
->next
= c
->io_samples
;
765 c
->io_samples
= sample
;
767 if (c
->start_time
== 0 || c
->start_time
> start
)
768 c
->start_time
= start
;
773 static int pid_end_io_sample(struct timechart
*tchart
, int pid
, int type
,
776 struct per_pid
*p
= find_create_pid(tchart
, pid
);
777 struct per_pidcomm
*c
= p
->current
;
778 struct io_sample
*sample
, *prev
;
781 pr_warning("Invalid pidcomm!\n");
785 sample
= c
->io_samples
;
787 if (!sample
) /* skip partially captured events */
790 if (sample
->end_time
) {
791 pr_warning("Skip invalid end event: "
792 "previous event already ended!\n");
796 if (sample
->type
!= type
) {
797 pr_warning("Skip invalid end event: invalid event type!\n");
801 sample
->end_time
= end
;
804 /* we want to be able to see small and fast transfers, so make them
805 * at least min_time long, but don't overlap them */
806 if (sample
->end_time
- sample
->start_time
< tchart
->min_time
)
807 sample
->end_time
= sample
->start_time
+ tchart
->min_time
;
808 if (prev
&& sample
->start_time
< prev
->end_time
) {
809 if (prev
->err
) /* try to make errors more visible */
810 sample
->start_time
= prev
->end_time
;
812 prev
->end_time
= sample
->start_time
;
817 } else if (type
== IOTYPE_READ
|| type
== IOTYPE_WRITE
||
818 type
== IOTYPE_TX
|| type
== IOTYPE_RX
) {
820 if ((u64
)ret
> c
->max_bytes
)
823 c
->total_bytes
+= ret
;
824 p
->total_bytes
+= ret
;
828 /* merge two requests to make svg smaller and render-friendly */
830 prev
->type
== sample
->type
&&
831 prev
->err
== sample
->err
&&
832 prev
->fd
== sample
->fd
&&
833 prev
->end_time
+ tchart
->merge_dist
>= sample
->start_time
) {
835 sample
->bytes
+= prev
->bytes
;
836 sample
->merges
+= prev
->merges
+ 1;
838 sample
->start_time
= prev
->start_time
;
839 sample
->next
= prev
->next
;
842 if (!sample
->err
&& sample
->bytes
> c
->max_bytes
)
843 c
->max_bytes
= sample
->bytes
;
852 process_enter_read(struct timechart
*tchart
,
853 struct perf_evsel
*evsel
,
854 struct perf_sample
*sample
)
856 long fd
= perf_evsel__intval(evsel
, sample
, "fd");
857 return pid_begin_io_sample(tchart
, sample
->tid
, IOTYPE_READ
,
862 process_exit_read(struct timechart
*tchart
,
863 struct perf_evsel
*evsel
,
864 struct perf_sample
*sample
)
866 long ret
= perf_evsel__intval(evsel
, sample
, "ret");
867 return pid_end_io_sample(tchart
, sample
->tid
, IOTYPE_READ
,
872 process_enter_write(struct timechart
*tchart
,
873 struct perf_evsel
*evsel
,
874 struct perf_sample
*sample
)
876 long fd
= perf_evsel__intval(evsel
, sample
, "fd");
877 return pid_begin_io_sample(tchart
, sample
->tid
, IOTYPE_WRITE
,
882 process_exit_write(struct timechart
*tchart
,
883 struct perf_evsel
*evsel
,
884 struct perf_sample
*sample
)
886 long ret
= perf_evsel__intval(evsel
, sample
, "ret");
887 return pid_end_io_sample(tchart
, sample
->tid
, IOTYPE_WRITE
,
892 process_enter_sync(struct timechart
*tchart
,
893 struct perf_evsel
*evsel
,
894 struct perf_sample
*sample
)
896 long fd
= perf_evsel__intval(evsel
, sample
, "fd");
897 return pid_begin_io_sample(tchart
, sample
->tid
, IOTYPE_SYNC
,
902 process_exit_sync(struct timechart
*tchart
,
903 struct perf_evsel
*evsel
,
904 struct perf_sample
*sample
)
906 long ret
= perf_evsel__intval(evsel
, sample
, "ret");
907 return pid_end_io_sample(tchart
, sample
->tid
, IOTYPE_SYNC
,
912 process_enter_tx(struct timechart
*tchart
,
913 struct perf_evsel
*evsel
,
914 struct perf_sample
*sample
)
916 long fd
= perf_evsel__intval(evsel
, sample
, "fd");
917 return pid_begin_io_sample(tchart
, sample
->tid
, IOTYPE_TX
,
922 process_exit_tx(struct timechart
*tchart
,
923 struct perf_evsel
*evsel
,
924 struct perf_sample
*sample
)
926 long ret
= perf_evsel__intval(evsel
, sample
, "ret");
927 return pid_end_io_sample(tchart
, sample
->tid
, IOTYPE_TX
,
932 process_enter_rx(struct timechart
*tchart
,
933 struct perf_evsel
*evsel
,
934 struct perf_sample
*sample
)
936 long fd
= perf_evsel__intval(evsel
, sample
, "fd");
937 return pid_begin_io_sample(tchart
, sample
->tid
, IOTYPE_RX
,
942 process_exit_rx(struct timechart
*tchart
,
943 struct perf_evsel
*evsel
,
944 struct perf_sample
*sample
)
946 long ret
= perf_evsel__intval(evsel
, sample
, "ret");
947 return pid_end_io_sample(tchart
, sample
->tid
, IOTYPE_RX
,
952 process_enter_poll(struct timechart
*tchart
,
953 struct perf_evsel
*evsel
,
954 struct perf_sample
*sample
)
956 long fd
= perf_evsel__intval(evsel
, sample
, "fd");
957 return pid_begin_io_sample(tchart
, sample
->tid
, IOTYPE_POLL
,
962 process_exit_poll(struct timechart
*tchart
,
963 struct perf_evsel
*evsel
,
964 struct perf_sample
*sample
)
966 long ret
= perf_evsel__intval(evsel
, sample
, "ret");
967 return pid_end_io_sample(tchart
, sample
->tid
, IOTYPE_POLL
,
972 * Sort the pid datastructure
974 static void sort_pids(struct timechart
*tchart
)
976 struct per_pid
*new_list
, *p
, *cursor
, *prev
;
977 /* sort by ppid first, then by pid, lowest to highest */
981 while (tchart
->all_data
) {
982 p
= tchart
->all_data
;
983 tchart
->all_data
= p
->next
;
986 if (new_list
== NULL
) {
994 if (cursor
->ppid
> p
->ppid
||
995 (cursor
->ppid
== p
->ppid
&& cursor
->pid
> p
->pid
)) {
996 /* must insert before */
998 p
->next
= prev
->next
;
1011 cursor
= cursor
->next
;
1016 tchart
->all_data
= new_list
;
1020 static void draw_c_p_states(struct timechart
*tchart
)
1022 struct power_event
*pwr
;
1023 pwr
= tchart
->power_events
;
1026 * two pass drawing so that the P state bars are on top of the C state blocks
1029 if (pwr
->type
== CSTATE
)
1030 svg_cstate(pwr
->cpu
, pwr
->start_time
, pwr
->end_time
, pwr
->state
);
1034 pwr
= tchart
->power_events
;
1036 if (pwr
->type
== PSTATE
) {
1038 pwr
->state
= tchart
->min_freq
;
1039 svg_pstate(pwr
->cpu
, pwr
->start_time
, pwr
->end_time
, pwr
->state
);
1045 static void draw_wakeups(struct timechart
*tchart
)
1047 struct wake_event
*we
;
1049 struct per_pidcomm
*c
;
1051 we
= tchart
->wake_events
;
1053 int from
= 0, to
= 0;
1054 char *task_from
= NULL
, *task_to
= NULL
;
1056 /* locate the column of the waker and wakee */
1057 p
= tchart
->all_data
;
1059 if (p
->pid
== we
->waker
|| p
->pid
== we
->wakee
) {
1062 if (c
->Y
&& c
->start_time
<= we
->time
&& c
->end_time
>= we
->time
) {
1063 if (p
->pid
== we
->waker
&& !from
) {
1065 task_from
= strdup(c
->comm
);
1067 if (p
->pid
== we
->wakee
&& !to
) {
1069 task_to
= strdup(c
->comm
);
1076 if (p
->pid
== we
->waker
&& !from
) {
1078 task_from
= strdup(c
->comm
);
1080 if (p
->pid
== we
->wakee
&& !to
) {
1082 task_to
= strdup(c
->comm
);
1091 task_from
= malloc(40);
1092 sprintf(task_from
, "[%i]", we
->waker
);
1095 task_to
= malloc(40);
1096 sprintf(task_to
, "[%i]", we
->wakee
);
1099 if (we
->waker
== -1)
1100 svg_interrupt(we
->time
, to
, we
->backtrace
);
1101 else if (from
&& to
&& abs(from
- to
) == 1)
1102 svg_wakeline(we
->time
, from
, to
, we
->backtrace
);
1104 svg_partial_wakeline(we
->time
, from
, task_from
, to
,
1105 task_to
, we
->backtrace
);
1113 static void draw_cpu_usage(struct timechart
*tchart
)
1116 struct per_pidcomm
*c
;
1117 struct cpu_sample
*sample
;
1118 p
= tchart
->all_data
;
1122 sample
= c
->samples
;
1124 if (sample
->type
== TYPE_RUNNING
) {
1125 svg_process(sample
->cpu
,
1133 sample
= sample
->next
;
1141 static void draw_io_bars(struct timechart
*tchart
)
1147 struct per_pidcomm
*c
;
1148 struct io_sample
*sample
;
1151 p
= tchart
->all_data
;
1161 svg_box(Y
, c
->start_time
, c
->end_time
, "process3");
1162 sample
= c
->io_samples
;
1163 for (sample
= c
->io_samples
; sample
; sample
= sample
->next
) {
1164 double h
= (double)sample
->bytes
/ c
->max_bytes
;
1166 if (tchart
->skip_eagain
&&
1167 sample
->err
== -EAGAIN
)
1173 if (sample
->type
== IOTYPE_SYNC
)
1178 sample
->err
? "error" : "sync",
1182 else if (sample
->type
== IOTYPE_POLL
)
1187 sample
->err
? "error" : "poll",
1191 else if (sample
->type
== IOTYPE_READ
)
1196 sample
->err
? "error" : "disk",
1200 else if (sample
->type
== IOTYPE_WRITE
)
1205 sample
->err
? "error" : "disk",
1209 else if (sample
->type
== IOTYPE_RX
)
1214 sample
->err
? "error" : "net",
1218 else if (sample
->type
== IOTYPE_TX
)
1223 sample
->err
? "error" : "net",
1230 bytes
= c
->total_bytes
;
1232 bytes
= bytes
/ 1024;
1236 bytes
= bytes
/ 1024;
1240 bytes
= bytes
/ 1024;
1245 sprintf(comm
, "%s:%i (%3.1f %sbytes)", c
->comm
?: "", p
->pid
, bytes
, suf
);
1246 svg_text(Y
, c
->start_time
, comm
);
1256 static void draw_process_bars(struct timechart
*tchart
)
1259 struct per_pidcomm
*c
;
1260 struct cpu_sample
*sample
;
1263 Y
= 2 * tchart
->numcpus
+ 2;
1265 p
= tchart
->all_data
;
1275 svg_box(Y
, c
->start_time
, c
->end_time
, "process");
1276 sample
= c
->samples
;
1278 if (sample
->type
== TYPE_RUNNING
)
1279 svg_running(Y
, sample
->cpu
,
1283 if (sample
->type
== TYPE_BLOCKED
)
1284 svg_blocked(Y
, sample
->cpu
,
1288 if (sample
->type
== TYPE_WAITING
)
1289 svg_waiting(Y
, sample
->cpu
,
1293 sample
= sample
->next
;
1298 if (c
->total_time
> 5000000000) /* 5 seconds */
1299 sprintf(comm
, "%s:%i (%2.2fs)", c
->comm
, p
->pid
, c
->total_time
/ (double)NSEC_PER_SEC
);
1301 sprintf(comm
, "%s:%i (%3.1fms)", c
->comm
, p
->pid
, c
->total_time
/ (double)NSEC_PER_MSEC
);
1303 svg_text(Y
, c
->start_time
, comm
);
1313 static void add_process_filter(const char *string
)
1315 int pid
= strtoull(string
, NULL
, 10);
1316 struct process_filter
*filt
= malloc(sizeof(*filt
));
1321 filt
->name
= strdup(string
);
1323 filt
->next
= process_filter
;
1325 process_filter
= filt
;
1328 static int passes_filter(struct per_pid
*p
, struct per_pidcomm
*c
)
1330 struct process_filter
*filt
;
1331 if (!process_filter
)
1334 filt
= process_filter
;
1336 if (filt
->pid
&& p
->pid
== filt
->pid
)
1338 if (strcmp(filt
->name
, c
->comm
) == 0)
1345 static int determine_display_tasks_filtered(struct timechart
*tchart
)
1348 struct per_pidcomm
*c
;
1351 p
= tchart
->all_data
;
1354 if (p
->start_time
== 1)
1355 p
->start_time
= tchart
->first_time
;
1357 /* no exit marker, task kept running to the end */
1358 if (p
->end_time
== 0)
1359 p
->end_time
= tchart
->last_time
;
1366 if (c
->start_time
== 1)
1367 c
->start_time
= tchart
->first_time
;
1369 if (passes_filter(p
, c
)) {
1375 if (c
->end_time
== 0)
1376 c
->end_time
= tchart
->last_time
;
1385 static int determine_display_tasks(struct timechart
*tchart
, u64 threshold
)
1388 struct per_pidcomm
*c
;
1391 p
= tchart
->all_data
;
1394 if (p
->start_time
== 1)
1395 p
->start_time
= tchart
->first_time
;
1397 /* no exit marker, task kept running to the end */
1398 if (p
->end_time
== 0)
1399 p
->end_time
= tchart
->last_time
;
1400 if (p
->total_time
>= threshold
)
1408 if (c
->start_time
== 1)
1409 c
->start_time
= tchart
->first_time
;
1411 if (c
->total_time
>= threshold
) {
1416 if (c
->end_time
== 0)
1417 c
->end_time
= tchart
->last_time
;
1426 static int determine_display_io_tasks(struct timechart
*timechart
, u64 threshold
)
1429 struct per_pidcomm
*c
;
1432 p
= timechart
->all_data
;
1434 /* no exit marker, task kept running to the end */
1435 if (p
->end_time
== 0)
1436 p
->end_time
= timechart
->last_time
;
1443 if (c
->total_bytes
>= threshold
) {
1448 if (c
->end_time
== 0)
1449 c
->end_time
= timechart
->last_time
;
1458 #define BYTES_THRESH (1 * 1024 * 1024)
1459 #define TIME_THRESH 10000000
1461 static void write_svg_file(struct timechart
*tchart
, const char *filename
)
1465 int thresh
= tchart
->io_events
? BYTES_THRESH
: TIME_THRESH
;
1467 if (tchart
->power_only
)
1468 tchart
->proc_num
= 0;
1470 /* We'd like to show at least proc_num tasks;
1471 * be less picky if we have fewer */
1474 count
= determine_display_tasks_filtered(tchart
);
1475 else if (tchart
->io_events
)
1476 count
= determine_display_io_tasks(tchart
, thresh
);
1478 count
= determine_display_tasks(tchart
, thresh
);
1480 } while (!process_filter
&& thresh
&& count
< tchart
->proc_num
);
1482 if (!tchart
->proc_num
)
1485 if (tchart
->io_events
) {
1486 open_svg(filename
, 0, count
, tchart
->first_time
, tchart
->last_time
);
1491 draw_io_bars(tchart
);
1493 open_svg(filename
, tchart
->numcpus
, count
, tchart
->first_time
, tchart
->last_time
);
1499 for (i
= 0; i
< tchart
->numcpus
; i
++)
1500 svg_cpu_box(i
, tchart
->max_freq
, tchart
->turbo_frequency
);
1502 draw_cpu_usage(tchart
);
1503 if (tchart
->proc_num
)
1504 draw_process_bars(tchart
);
1505 if (!tchart
->tasks_only
)
1506 draw_c_p_states(tchart
);
1507 if (tchart
->proc_num
)
1508 draw_wakeups(tchart
);
1514 static int process_header(struct perf_file_section
*section __maybe_unused
,
1515 struct perf_header
*ph
,
1517 int fd __maybe_unused
,
1520 struct timechart
*tchart
= data
;
1524 tchart
->numcpus
= ph
->env
.nr_cpus_avail
;
1527 case HEADER_CPU_TOPOLOGY
:
1528 if (!tchart
->topology
)
1531 if (svg_build_topology_map(ph
->env
.sibling_cores
,
1532 ph
->env
.nr_sibling_cores
,
1533 ph
->env
.sibling_threads
,
1534 ph
->env
.nr_sibling_threads
))
1535 fprintf(stderr
, "problem building topology\n");
1545 static int __cmd_timechart(struct timechart
*tchart
, const char *output_name
)
1547 const struct perf_evsel_str_handler power_tracepoints
[] = {
1548 { "power:cpu_idle", process_sample_cpu_idle
},
1549 { "power:cpu_frequency", process_sample_cpu_frequency
},
1550 { "sched:sched_wakeup", process_sample_sched_wakeup
},
1551 { "sched:sched_switch", process_sample_sched_switch
},
1552 #ifdef SUPPORT_OLD_POWER_EVENTS
1553 { "power:power_start", process_sample_power_start
},
1554 { "power:power_end", process_sample_power_end
},
1555 { "power:power_frequency", process_sample_power_frequency
},
1558 { "syscalls:sys_enter_read", process_enter_read
},
1559 { "syscalls:sys_enter_pread64", process_enter_read
},
1560 { "syscalls:sys_enter_readv", process_enter_read
},
1561 { "syscalls:sys_enter_preadv", process_enter_read
},
1562 { "syscalls:sys_enter_write", process_enter_write
},
1563 { "syscalls:sys_enter_pwrite64", process_enter_write
},
1564 { "syscalls:sys_enter_writev", process_enter_write
},
1565 { "syscalls:sys_enter_pwritev", process_enter_write
},
1566 { "syscalls:sys_enter_sync", process_enter_sync
},
1567 { "syscalls:sys_enter_sync_file_range", process_enter_sync
},
1568 { "syscalls:sys_enter_fsync", process_enter_sync
},
1569 { "syscalls:sys_enter_msync", process_enter_sync
},
1570 { "syscalls:sys_enter_recvfrom", process_enter_rx
},
1571 { "syscalls:sys_enter_recvmmsg", process_enter_rx
},
1572 { "syscalls:sys_enter_recvmsg", process_enter_rx
},
1573 { "syscalls:sys_enter_sendto", process_enter_tx
},
1574 { "syscalls:sys_enter_sendmsg", process_enter_tx
},
1575 { "syscalls:sys_enter_sendmmsg", process_enter_tx
},
1576 { "syscalls:sys_enter_epoll_pwait", process_enter_poll
},
1577 { "syscalls:sys_enter_epoll_wait", process_enter_poll
},
1578 { "syscalls:sys_enter_poll", process_enter_poll
},
1579 { "syscalls:sys_enter_ppoll", process_enter_poll
},
1580 { "syscalls:sys_enter_pselect6", process_enter_poll
},
1581 { "syscalls:sys_enter_select", process_enter_poll
},
1583 { "syscalls:sys_exit_read", process_exit_read
},
1584 { "syscalls:sys_exit_pread64", process_exit_read
},
1585 { "syscalls:sys_exit_readv", process_exit_read
},
1586 { "syscalls:sys_exit_preadv", process_exit_read
},
1587 { "syscalls:sys_exit_write", process_exit_write
},
1588 { "syscalls:sys_exit_pwrite64", process_exit_write
},
1589 { "syscalls:sys_exit_writev", process_exit_write
},
1590 { "syscalls:sys_exit_pwritev", process_exit_write
},
1591 { "syscalls:sys_exit_sync", process_exit_sync
},
1592 { "syscalls:sys_exit_sync_file_range", process_exit_sync
},
1593 { "syscalls:sys_exit_fsync", process_exit_sync
},
1594 { "syscalls:sys_exit_msync", process_exit_sync
},
1595 { "syscalls:sys_exit_recvfrom", process_exit_rx
},
1596 { "syscalls:sys_exit_recvmmsg", process_exit_rx
},
1597 { "syscalls:sys_exit_recvmsg", process_exit_rx
},
1598 { "syscalls:sys_exit_sendto", process_exit_tx
},
1599 { "syscalls:sys_exit_sendmsg", process_exit_tx
},
1600 { "syscalls:sys_exit_sendmmsg", process_exit_tx
},
1601 { "syscalls:sys_exit_epoll_pwait", process_exit_poll
},
1602 { "syscalls:sys_exit_epoll_wait", process_exit_poll
},
1603 { "syscalls:sys_exit_poll", process_exit_poll
},
1604 { "syscalls:sys_exit_ppoll", process_exit_poll
},
1605 { "syscalls:sys_exit_pselect6", process_exit_poll
},
1606 { "syscalls:sys_exit_select", process_exit_poll
},
1608 struct perf_data data
= {
1612 .mode
= PERF_DATA_MODE_READ
,
1613 .force
= tchart
->force
,
1616 struct perf_session
*session
= perf_session__new(&data
, false,
1620 if (session
== NULL
)
1623 symbol__init(&session
->header
.env
);
1625 (void)perf_header__process_sections(&session
->header
,
1626 perf_data__fd(session
->data
),
1630 if (!perf_session__has_traces(session
, "timechart record"))
1633 if (perf_session__set_tracepoints_handlers(session
,
1634 power_tracepoints
)) {
1635 pr_err("Initializing session tracepoint handlers failed\n");
1639 ret
= perf_session__process_events(session
);
1643 end_sample_processing(tchart
);
1647 write_svg_file(tchart
, output_name
);
1649 pr_info("Written %2.1f seconds of trace to %s.\n",
1650 (tchart
->last_time
- tchart
->first_time
) / (double)NSEC_PER_SEC
, output_name
);
1652 perf_session__delete(session
);
1656 static int timechart__io_record(int argc
, const char **argv
)
1658 unsigned int rec_argc
, i
;
1659 const char **rec_argv
;
1661 char *filter
= NULL
;
1663 const char * const common_args
[] = {
1664 "record", "-a", "-R", "-c", "1",
1666 unsigned int common_args_nr
= ARRAY_SIZE(common_args
);
1668 const char * const disk_events
[] = {
1669 "syscalls:sys_enter_read",
1670 "syscalls:sys_enter_pread64",
1671 "syscalls:sys_enter_readv",
1672 "syscalls:sys_enter_preadv",
1673 "syscalls:sys_enter_write",
1674 "syscalls:sys_enter_pwrite64",
1675 "syscalls:sys_enter_writev",
1676 "syscalls:sys_enter_pwritev",
1677 "syscalls:sys_enter_sync",
1678 "syscalls:sys_enter_sync_file_range",
1679 "syscalls:sys_enter_fsync",
1680 "syscalls:sys_enter_msync",
1682 "syscalls:sys_exit_read",
1683 "syscalls:sys_exit_pread64",
1684 "syscalls:sys_exit_readv",
1685 "syscalls:sys_exit_preadv",
1686 "syscalls:sys_exit_write",
1687 "syscalls:sys_exit_pwrite64",
1688 "syscalls:sys_exit_writev",
1689 "syscalls:sys_exit_pwritev",
1690 "syscalls:sys_exit_sync",
1691 "syscalls:sys_exit_sync_file_range",
1692 "syscalls:sys_exit_fsync",
1693 "syscalls:sys_exit_msync",
1695 unsigned int disk_events_nr
= ARRAY_SIZE(disk_events
);
1697 const char * const net_events
[] = {
1698 "syscalls:sys_enter_recvfrom",
1699 "syscalls:sys_enter_recvmmsg",
1700 "syscalls:sys_enter_recvmsg",
1701 "syscalls:sys_enter_sendto",
1702 "syscalls:sys_enter_sendmsg",
1703 "syscalls:sys_enter_sendmmsg",
1705 "syscalls:sys_exit_recvfrom",
1706 "syscalls:sys_exit_recvmmsg",
1707 "syscalls:sys_exit_recvmsg",
1708 "syscalls:sys_exit_sendto",
1709 "syscalls:sys_exit_sendmsg",
1710 "syscalls:sys_exit_sendmmsg",
1712 unsigned int net_events_nr
= ARRAY_SIZE(net_events
);
1714 const char * const poll_events
[] = {
1715 "syscalls:sys_enter_epoll_pwait",
1716 "syscalls:sys_enter_epoll_wait",
1717 "syscalls:sys_enter_poll",
1718 "syscalls:sys_enter_ppoll",
1719 "syscalls:sys_enter_pselect6",
1720 "syscalls:sys_enter_select",
1722 "syscalls:sys_exit_epoll_pwait",
1723 "syscalls:sys_exit_epoll_wait",
1724 "syscalls:sys_exit_poll",
1725 "syscalls:sys_exit_ppoll",
1726 "syscalls:sys_exit_pselect6",
1727 "syscalls:sys_exit_select",
1729 unsigned int poll_events_nr
= ARRAY_SIZE(poll_events
);
1731 rec_argc
= common_args_nr
+
1732 disk_events_nr
* 4 +
1734 poll_events_nr
* 4 +
1736 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1738 if (rec_argv
== NULL
)
1741 if (asprintf(&filter
, "common_pid != %d", getpid()) < 0) {
1747 for (i
= 0; i
< common_args_nr
; i
++)
1748 *p
++ = strdup(common_args
[i
]);
1750 for (i
= 0; i
< disk_events_nr
; i
++) {
1751 if (!is_valid_tracepoint(disk_events
[i
])) {
1757 *p
++ = strdup(disk_events
[i
]);
1761 for (i
= 0; i
< net_events_nr
; i
++) {
1762 if (!is_valid_tracepoint(net_events
[i
])) {
1768 *p
++ = strdup(net_events
[i
]);
1772 for (i
= 0; i
< poll_events_nr
; i
++) {
1773 if (!is_valid_tracepoint(poll_events
[i
])) {
1779 *p
++ = strdup(poll_events
[i
]);
1784 for (i
= 0; i
< (unsigned int)argc
; i
++)
1787 return cmd_record(rec_argc
, rec_argv
);
1791 static int timechart__record(struct timechart
*tchart
, int argc
, const char **argv
)
1793 unsigned int rec_argc
, i
, j
;
1794 const char **rec_argv
;
1796 unsigned int record_elems
;
1798 const char * const common_args
[] = {
1799 "record", "-a", "-R", "-c", "1",
1801 unsigned int common_args_nr
= ARRAY_SIZE(common_args
);
1803 const char * const backtrace_args
[] = {
1806 unsigned int backtrace_args_no
= ARRAY_SIZE(backtrace_args
);
1808 const char * const power_args
[] = {
1809 "-e", "power:cpu_frequency",
1810 "-e", "power:cpu_idle",
1812 unsigned int power_args_nr
= ARRAY_SIZE(power_args
);
1814 const char * const old_power_args
[] = {
1815 #ifdef SUPPORT_OLD_POWER_EVENTS
1816 "-e", "power:power_start",
1817 "-e", "power:power_end",
1818 "-e", "power:power_frequency",
1821 unsigned int old_power_args_nr
= ARRAY_SIZE(old_power_args
);
1823 const char * const tasks_args
[] = {
1824 "-e", "sched:sched_wakeup",
1825 "-e", "sched:sched_switch",
1827 unsigned int tasks_args_nr
= ARRAY_SIZE(tasks_args
);
1829 #ifdef SUPPORT_OLD_POWER_EVENTS
1830 if (!is_valid_tracepoint("power:cpu_idle") &&
1831 is_valid_tracepoint("power:power_start")) {
1832 use_old_power_events
= 1;
1835 old_power_args_nr
= 0;
1839 if (tchart
->power_only
)
1842 if (tchart
->tasks_only
) {
1844 old_power_args_nr
= 0;
1847 if (!tchart
->with_backtrace
)
1848 backtrace_args_no
= 0;
1850 record_elems
= common_args_nr
+ tasks_args_nr
+
1851 power_args_nr
+ old_power_args_nr
+ backtrace_args_no
;
1853 rec_argc
= record_elems
+ argc
;
1854 rec_argv
= calloc(rec_argc
+ 1, sizeof(char *));
1856 if (rec_argv
== NULL
)
1860 for (i
= 0; i
< common_args_nr
; i
++)
1861 *p
++ = strdup(common_args
[i
]);
1863 for (i
= 0; i
< backtrace_args_no
; i
++)
1864 *p
++ = strdup(backtrace_args
[i
]);
1866 for (i
= 0; i
< tasks_args_nr
; i
++)
1867 *p
++ = strdup(tasks_args
[i
]);
1869 for (i
= 0; i
< power_args_nr
; i
++)
1870 *p
++ = strdup(power_args
[i
]);
1872 for (i
= 0; i
< old_power_args_nr
; i
++)
1873 *p
++ = strdup(old_power_args
[i
]);
1875 for (j
= 0; j
< (unsigned int)argc
; j
++)
1878 return cmd_record(rec_argc
, rec_argv
);
1882 parse_process(const struct option
*opt __maybe_unused
, const char *arg
,
1883 int __maybe_unused unset
)
1886 add_process_filter(arg
);
1891 parse_highlight(const struct option
*opt __maybe_unused
, const char *arg
,
1892 int __maybe_unused unset
)
1894 unsigned long duration
= strtoul(arg
, NULL
, 0);
1896 if (svg_highlight
|| svg_highlight_name
)
1900 svg_highlight
= duration
;
1902 svg_highlight_name
= strdup(arg
);
1908 parse_time(const struct option
*opt
, const char *arg
, int __maybe_unused unset
)
1911 u64
*value
= opt
->value
;
1913 if (sscanf(arg
, "%" PRIu64
"%cs", value
, &unit
) > 0) {
1916 *value
*= NSEC_PER_MSEC
;
1919 *value
*= NSEC_PER_USEC
;
1931 int cmd_timechart(int argc
, const char **argv
)
1933 struct timechart tchart
= {
1935 .comm
= process_comm_event
,
1936 .fork
= process_fork_event
,
1937 .exit
= process_exit_event
,
1938 .sample
= process_sample_event
,
1939 .ordered_events
= true,
1942 .min_time
= NSEC_PER_MSEC
,
1945 const char *output_name
= "output.svg";
1946 const struct option timechart_common_options
[] = {
1947 OPT_BOOLEAN('P', "power-only", &tchart
.power_only
, "output power data only"),
1948 OPT_BOOLEAN('T', "tasks-only", &tchart
.tasks_only
, "output processes data only"),
1951 const struct option timechart_options
[] = {
1952 OPT_STRING('i', "input", &input_name
, "file", "input file name"),
1953 OPT_STRING('o', "output", &output_name
, "file", "output file name"),
1954 OPT_INTEGER('w', "width", &svg_page_width
, "page width"),
1955 OPT_CALLBACK(0, "highlight", NULL
, "duration or task name",
1956 "highlight tasks. Pass duration in ns or process name.",
1958 OPT_CALLBACK('p', "process", NULL
, "process",
1959 "process selector. Pass a pid or process name.",
1961 OPT_CALLBACK(0, "symfs", NULL
, "directory",
1962 "Look for files with symbols relative to this directory",
1963 symbol__config_symfs
),
1964 OPT_INTEGER('n', "proc-num", &tchart
.proc_num
,
1965 "min. number of tasks to print"),
1966 OPT_BOOLEAN('t', "topology", &tchart
.topology
,
1967 "sort CPUs according to topology"),
1968 OPT_BOOLEAN(0, "io-skip-eagain", &tchart
.skip_eagain
,
1969 "skip EAGAIN errors"),
1970 OPT_CALLBACK(0, "io-min-time", &tchart
.min_time
, "time",
1971 "all IO faster than min-time will visually appear longer",
1973 OPT_CALLBACK(0, "io-merge-dist", &tchart
.merge_dist
, "time",
1974 "merge events that are merge-dist us apart",
1976 OPT_BOOLEAN('f', "force", &tchart
.force
, "don't complain, do it"),
1977 OPT_PARENT(timechart_common_options
),
1979 const char * const timechart_subcommands
[] = { "record", NULL
};
1980 const char *timechart_usage
[] = {
1981 "perf timechart [<options>] {record}",
1984 const struct option timechart_record_options
[] = {
1985 OPT_BOOLEAN('I', "io-only", &tchart
.io_only
,
1986 "record only IO data"),
1987 OPT_BOOLEAN('g', "callchain", &tchart
.with_backtrace
, "record callchain"),
1988 OPT_PARENT(timechart_common_options
),
1990 const char * const timechart_record_usage
[] = {
1991 "perf timechart record [<options>]",
1994 argc
= parse_options_subcommand(argc
, argv
, timechart_options
, timechart_subcommands
,
1995 timechart_usage
, PARSE_OPT_STOP_AT_NON_OPTION
);
1997 if (tchart
.power_only
&& tchart
.tasks_only
) {
1998 pr_err("-P and -T options cannot be used at the same time.\n");
2002 if (argc
&& !strncmp(argv
[0], "rec", 3)) {
2003 argc
= parse_options(argc
, argv
, timechart_record_options
,
2004 timechart_record_usage
,
2005 PARSE_OPT_STOP_AT_NON_OPTION
);
2007 if (tchart
.power_only
&& tchart
.tasks_only
) {
2008 pr_err("-P and -T options cannot be used at the same time.\n");
2013 return timechart__io_record(argc
, argv
);
2015 return timechart__record(&tchart
, argc
, argv
);
2017 usage_with_options(timechart_usage
, timechart_options
);
2021 return __cmd_timechart(&tchart
, output_name
);