tools/perf/builtin-timechart.c

   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
  15 #include <traceevent/event-parse.h>
  16
  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"
  24 #include "util/evlist.h"
  25 #include "util/evsel.h"
  26 #include <linux/rbtree.h>
  27 #include "util/symbol.h"
  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"
  35 #include "util/event.h"
  36 #include "util/session.h"
  37 #include "util/svghelper.h"
  38 #include "util/tool.h"
  39
  40 #define SUPPORT_OLD_POWER_EVENTS 1
  41 #define PWR_EVENT_EXIT -1
  42
  43
  44 static unsigned int     numcpus;
  45 static u64              min_freq;       /* Lowest CPU frequency seen */
  46 static u64              max_freq;       /* Highest CPU frequency seen */
  47 static u64              turbo_frequency;
  48
  49 static u64              first_time, last_time;
  50
  51 static bool             power_only;
  52
  53
  54 struct per_pid;
  55 struct per_pidcomm;
  56
  57 struct cpu_sample;
  58 struct power_event;
  59 struct wake_event;
  60
  61 struct sample_wrapper;
  62
  63 /*
  64  * Datastructure layout:
  65  * We keep an list of "pid"s, matching the kernels notion of a task struct.
  66  * Each "pid" entry, has a list of "comm"s.
  67  *      this is because we want to track different programs different, while
  68  *      exec will reuse the original pid (by design).
  69  * Each comm has a list of samples that will be used to draw
  70  * final graph.
  71  */
  72
  73 struct per_pid {
  74         struct per_pid *next;
  75
  76         int             pid;
  77         int             ppid;
  78
  79         u64             start_time;
  80         u64             end_time;
  81         u64             total_time;
  82         int             display;
  83
  84         struct per_pidcomm *all;
  85         struct per_pidcomm *current;
  86 };
  87
  88
  89 struct per_pidcomm {
  90         struct per_pidcomm *next;
  91
  92         u64             start_time;
  93         u64             end_time;
  94         u64             total_time;
  95
  96         int             Y;
  97         int             display;
  98
  99         long            state;
 100         u64             state_since;
 101
 102         char            *comm;
 103
 104         struct cpu_sample *samples;
 105 };
 106
 107 struct sample_wrapper {
 108         struct sample_wrapper *next;
 109
 110         u64             timestamp;
 111         unsigned char   data[0];
 112 };
 113
 114 #define TYPE_NONE       0
 115 #define TYPE_RUNNING    1
 116 #define TYPE_WAITING    2
 117 #define TYPE_BLOCKED    3
 118
 119 struct cpu_sample {
 120         struct cpu_sample *next;
 121
 122         u64 start_time;
 123         u64 end_time;
 124         int type;
 125         int cpu;
 126 };
 127
 128 static struct per_pid *all_data;
 129
 130 #define CSTATE 1
 131 #define PSTATE 2
 132
 133 struct power_event {
 134         struct power_event *next;
 135         int type;
 136         int state;
 137         u64 start_time;
 138         u64 end_time;
 139         int cpu;
 140 };
 141
 142 struct wake_event {
 143         struct wake_event *next;
 144         int waker;
 145         int wakee;
 146         u64 time;
 147 };
 148
 149 static struct power_event    *power_events;
 150 static struct wake_event     *wake_events;
 151
 152 struct process_filter;
 153 struct process_filter {
 154         char                    *name;
 155         int                     pid;
 156         struct process_filter   *next;
 157 };
 158
 159 static struct process_filter *process_filter;
 160
 161
 162 static struct per_pid *find_create_pid(int pid)
 163 {
 164         struct per_pid *cursor = all_data;
 165
 166         while (cursor) {
 167                 if (cursor->pid == pid)
 168                         return cursor;
 169                 cursor = cursor->next;
 170         }
 171         cursor = zalloc(sizeof(*cursor));
 172         assert(cursor != NULL);
 173         cursor->pid = pid;
 174         cursor->next = all_data;
 175         all_data = cursor;
 176         return cursor;
 177 }
 178
 179 static void pid_set_comm(int pid, char *comm)
 180 {
 181         struct per_pid *p;
 182         struct per_pidcomm *c;
 183         p = find_create_pid(pid);
 184         c = p->all;
 185         while (c) {
 186                 if (c->comm && strcmp(c->comm, comm) == 0) {
 187                         p->current = c;
 188                         return;
 189                 }
 190                 if (!c->comm) {
 191                         c->comm = strdup(comm);
 192                         p->current = c;
 193                         return;
 194                 }
 195                 c = c->next;
 196         }
 197         c = zalloc(sizeof(*c));
 198         assert(c != NULL);
 199         c->comm = strdup(comm);
 200         p->current = c;
 201         c->next = p->all;
 202         p->all = c;
 203 }
 204
 205 static void pid_fork(int pid, int ppid, u64 timestamp)
 206 {
 207         struct per_pid *p, *pp;
 208         p = find_create_pid(pid);
 209         pp = find_create_pid(ppid);
 210         p->ppid = ppid;
 211         if (pp->current && pp->current->comm && !p->current)
 212                 pid_set_comm(pid, pp->current->comm);
 213
 214         p->start_time = timestamp;
 215         if (p->current) {
 216                 p->current->start_time = timestamp;
 217                 p->current->state_since = timestamp;
 218         }
 219 }
 220
 221 static void pid_exit(int pid, u64 timestamp)
 222 {
 223         struct per_pid *p;
 224         p = find_create_pid(pid);
 225         p->end_time = timestamp;
 226         if (p->current)
 227                 p->current->end_time = timestamp;
 228 }
 229
 230 static void
 231 pid_put_sample(int pid, int type, unsigned int cpu, u64 start, u64 end)
 232 {
 233         struct per_pid *p;
 234         struct per_pidcomm *c;
 235         struct cpu_sample *sample;
 236
 237         p = find_create_pid(pid);
 238         c = p->current;
 239         if (!c) {
 240                 c = zalloc(sizeof(*c));
 241                 assert(c != NULL);
 242                 p->current = c;
 243                 c->next = p->all;
 244                 p->all = c;
 245         }
 246
 247         sample = zalloc(sizeof(*sample));
 248         assert(sample != NULL);
 249         sample->start_time = start;
 250         sample->end_time = end;
 251         sample->type = type;
 252         sample->next = c->samples;
 253         sample->cpu = cpu;
 254         c->samples = sample;
 255
 256         if (sample->type == TYPE_RUNNING && end > start && start > 0) {
 257                 c->total_time += (end-start);
 258                 p->total_time += (end-start);
 259         }
 260
 261         if (c->start_time == 0 || c->start_time > start)
 262                 c->start_time = start;
 263         if (p->start_time == 0 || p->start_time > start)
 264                 p->start_time = start;
 265 }
 266
 267 #define MAX_CPUS 4096
 268
 269 static u64 cpus_cstate_start_times[MAX_CPUS];
 270 static int cpus_cstate_state[MAX_CPUS];
 271 static u64 cpus_pstate_start_times[MAX_CPUS];
 272 static u64 cpus_pstate_state[MAX_CPUS];
 273
 274 static int process_comm_event(struct perf_tool *tool __maybe_unused,
 275                               union perf_event *event,
 276                               struct perf_sample *sample __maybe_unused,
 277                               struct machine *machine __maybe_unused)
 278 {
 279         pid_set_comm(event->comm.tid, event->comm.comm);
 280         return 0;
 281 }
 282
 283 static int process_fork_event(struct perf_tool *tool __maybe_unused,
 284                               union perf_event *event,
 285                               struct perf_sample *sample __maybe_unused,
 286                               struct machine *machine __maybe_unused)
 287 {
 288         pid_fork(event->fork.pid, event->fork.ppid, event->fork.time);
 289         return 0;
 290 }
 291
 292 static int process_exit_event(struct perf_tool *tool __maybe_unused,
 293                               union perf_event *event,
 294                               struct perf_sample *sample __maybe_unused,
 295                               struct machine *machine __maybe_unused)
 296 {
 297         pid_exit(event->fork.pid, event->fork.time);
 298         return 0;
 299 }
 300
 301 struct trace_entry {
 302         unsigned short          type;
 303         unsigned char           flags;
 304         unsigned char           preempt_count;
 305         int                     pid;
 306         int                     lock_depth;
 307 };
 308
 309 #ifdef SUPPORT_OLD_POWER_EVENTS
 310 static int use_old_power_events;
 311 struct power_entry_old {
 312         struct trace_entry te;
 313         u64     type;
 314         u64     value;
 315         u64     cpu_id;
 316 };
 317 #endif
 318
 319 struct power_processor_entry {
 320         struct trace_entry te;
 321         u32     state;
 322         u32     cpu_id;
 323 };
 324
 325 #define TASK_COMM_LEN 16
 326 struct wakeup_entry {
 327         struct trace_entry te;
 328         char comm[TASK_COMM_LEN];
 329         int   pid;
 330         int   prio;
 331         int   success;
 332 };
 333
 334 struct sched_switch {
 335         struct trace_entry te;
 336         char prev_comm[TASK_COMM_LEN];
 337         int  prev_pid;
 338         int  prev_prio;
 339         long prev_state; /* Arjan weeps. */
 340         char next_comm[TASK_COMM_LEN];
 341         int  next_pid;
 342         int  next_prio;
 343 };
 344
 345 static void c_state_start(int cpu, u64 timestamp, int state)
 346 {
 347         cpus_cstate_start_times[cpu] = timestamp;
 348         cpus_cstate_state[cpu] = state;
 349 }
 350
 351 static void c_state_end(int cpu, u64 timestamp)
 352 {
 353         struct power_event *pwr = zalloc(sizeof(*pwr));
 354
 355         if (!pwr)
 356                 return;
 357
 358         pwr->state = cpus_cstate_state[cpu];
 359         pwr->start_time = cpus_cstate_start_times[cpu];
 360         pwr->end_time = timestamp;
 361         pwr->cpu = cpu;
 362         pwr->type = CSTATE;
 363         pwr->next = power_events;
 364
 365         power_events = pwr;
 366 }
 367
 368 static void p_state_change(int cpu, u64 timestamp, u64 new_freq)
 369 {
 370         struct power_event *pwr;
 371
 372         if (new_freq > 8000000) /* detect invalid data */
 373                 return;
 374
 375         pwr = zalloc(sizeof(*pwr));
 376         if (!pwr)
 377                 return;
 378
 379         pwr->state = cpus_pstate_state[cpu];
 380         pwr->start_time = cpus_pstate_start_times[cpu];
 381         pwr->end_time = timestamp;
 382         pwr->cpu = cpu;
 383         pwr->type = PSTATE;
 384         pwr->next = power_events;
 385
 386         if (!pwr->start_time)
 387                 pwr->start_time = first_time;
 388
 389         power_events = pwr;
 390
 391         cpus_pstate_state[cpu] = new_freq;
 392         cpus_pstate_start_times[cpu] = timestamp;
 393
 394         if ((u64)new_freq > max_freq)
 395                 max_freq = new_freq;
 396
 397         if (new_freq < min_freq || min_freq == 0)
 398                 min_freq = new_freq;
 399
 400         if (new_freq == max_freq - 1000)
 401                         turbo_frequency = max_freq;
 402 }
 403
 404 static void
 405 sched_wakeup(int cpu, u64 timestamp, int pid, struct trace_entry *te)
 406 {
 407         struct per_pid *p;
 408         struct wakeup_entry *wake = (void *)te;
 409         struct wake_event *we = zalloc(sizeof(*we));
 410
 411         if (!we)
 412                 return;
 413
 414         we->time = timestamp;
 415         we->waker = pid;
 416
 417         if ((te->flags & TRACE_FLAG_HARDIRQ) || (te->flags & TRACE_FLAG_SOFTIRQ))
 418                 we->waker = -1;
 419
 420         we->wakee = wake->pid;
 421         we->next = wake_events;
 422         wake_events = we;
 423         p = find_create_pid(we->wakee);
 424
 425         if (p && p->current && p->current->state == TYPE_NONE) {
 426                 p->current->state_since = timestamp;
 427                 p->current->state = TYPE_WAITING;
 428         }
 429         if (p && p->current && p->current->state == TYPE_BLOCKED) {
 430                 pid_put_sample(p->pid, p->current->state, cpu, p->current->state_since, timestamp);
 431                 p->current->state_since = timestamp;
 432                 p->current->state = TYPE_WAITING;
 433         }
 434 }
 435
 436 static void sched_switch(int cpu, u64 timestamp, struct trace_entry *te)
 437 {
 438         struct per_pid *p = NULL, *prev_p;
 439         struct sched_switch *sw = (void *)te;
 440
 441
 442         prev_p = find_create_pid(sw->prev_pid);
 443
 444         p = find_create_pid(sw->next_pid);
 445
 446         if (prev_p->current && prev_p->current->state != TYPE_NONE)
 447                 pid_put_sample(sw->prev_pid, TYPE_RUNNING, cpu, prev_p->current->state_since, timestamp);
 448         if (p && p->current) {
 449                 if (p->current->state != TYPE_NONE)
 450                         pid_put_sample(sw->next_pid, p->current->state, cpu, p->current->state_since, timestamp);
 451
 452                 p->current->state_since = timestamp;
 453                 p->current->state = TYPE_RUNNING;
 454         }
 455
 456         if (prev_p->current) {
 457                 prev_p->current->state = TYPE_NONE;
 458                 prev_p->current->state_since = timestamp;
 459                 if (sw->prev_state & 2)
 460                         prev_p->current->state = TYPE_BLOCKED;
 461                 if (sw->prev_state == 0)
 462                         prev_p->current->state = TYPE_WAITING;
 463         }
 464 }
 465
 466 typedef int (*tracepoint_handler)(struct perf_evsel *evsel,
 467                                   struct perf_sample *sample);
 468
 469 static int process_sample_event(struct perf_tool *tool __maybe_unused,
 470                                 union perf_event *event __maybe_unused,
 471                                 struct perf_sample *sample,
 472                                 struct perf_evsel *evsel,
 473                                 struct machine *machine __maybe_unused)
 474 {
 475         if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
 476                 if (!first_time || first_time > sample->time)
 477                         first_time = sample->time;
 478                 if (last_time < sample->time)
 479                         last_time = sample->time;
 480         }
 481
 482         if (sample->cpu > numcpus)
 483                 numcpus = sample->cpu;
 484
 485         if (evsel->handler.func != NULL) {
 486                 tracepoint_handler f = evsel->handler.func;
 487                 return f(evsel, sample);
 488         }
 489
 490         return 0;
 491 }
 492
 493 static int
 494 process_sample_cpu_idle(struct perf_evsel *evsel __maybe_unused,
 495                         struct perf_sample *sample)
 496 {
 497         struct power_processor_entry *ppe = sample->raw_data;
 498
 499         if (ppe->state == (u32) PWR_EVENT_EXIT)
 500                 c_state_end(ppe->cpu_id, sample->time);
 501         else
 502                 c_state_start(ppe->cpu_id, sample->time, ppe->state);
 503         return 0;
 504 }
 505
 506 static int
 507 process_sample_cpu_frequency(struct perf_evsel *evsel __maybe_unused,
 508                              struct perf_sample *sample)
 509 {
 510         struct power_processor_entry *ppe = sample->raw_data;
 511
 512         p_state_change(ppe->cpu_id, sample->time, ppe->state);
 513         return 0;
 514 }
 515
 516 static int
 517 process_sample_sched_wakeup(struct perf_evsel *evsel __maybe_unused,
 518                             struct perf_sample *sample)
 519 {
 520         struct trace_entry *te = sample->raw_data;
 521
 522         sched_wakeup(sample->cpu, sample->time, sample->pid, te);
 523         return 0;
 524 }
 525
 526 static int
 527 process_sample_sched_switch(struct perf_evsel *evsel __maybe_unused,
 528                             struct perf_sample *sample)
 529 {
 530         struct trace_entry *te = sample->raw_data;
 531
 532         sched_switch(sample->cpu, sample->time, te);
 533         return 0;
 534 }
 535
 536 #ifdef SUPPORT_OLD_POWER_EVENTS
 537 static int
 538 process_sample_power_start(struct perf_evsel *evsel __maybe_unused,
 539                            struct perf_sample *sample)
 540 {
 541         struct power_entry_old *peo = sample->raw_data;
 542
 543         c_state_start(peo->cpu_id, sample->time, peo->value);
 544         return 0;
 545 }
 546
 547 static int
 548 process_sample_power_end(struct perf_evsel *evsel __maybe_unused,
 549                          struct perf_sample *sample)
 550 {
 551         c_state_end(sample->cpu, sample->time);
 552         return 0;
 553 }
 554
 555 static int
 556 process_sample_power_frequency(struct perf_evsel *evsel __maybe_unused,
 557                                struct perf_sample *sample)
 558 {
 559         struct power_entry_old *peo = sample->raw_data;
 560
 561         p_state_change(peo->cpu_id, sample->time, peo->value);
 562         return 0;
 563 }
 564 #endif /* SUPPORT_OLD_POWER_EVENTS */
 565
 566 /*
 567  * After the last sample we need to wrap up the current C/P state
 568  * and close out each CPU for these.
 569  */
 570 static void end_sample_processing(void)
 571 {
 572         u64 cpu;
 573         struct power_event *pwr;
 574
 575         for (cpu = 0; cpu <= numcpus; cpu++) {
 576                 /* C state */
 577 #if 0
 578                 pwr = zalloc(sizeof(*pwr));
 579                 if (!pwr)
 580                         return;
 581
 582                 pwr->state = cpus_cstate_state[cpu];
 583                 pwr->start_time = cpus_cstate_start_times[cpu];
 584                 pwr->end_time = last_time;
 585                 pwr->cpu = cpu;
 586                 pwr->type = CSTATE;
 587                 pwr->next = power_events;
 588
 589                 power_events = pwr;
 590 #endif
 591                 /* P state */
 592
 593                 pwr = zalloc(sizeof(*pwr));
 594                 if (!pwr)
 595                         return;
 596
 597                 pwr->state = cpus_pstate_state[cpu];
 598                 pwr->start_time = cpus_pstate_start_times[cpu];
 599                 pwr->end_time = last_time;
 600                 pwr->cpu = cpu;
 601                 pwr->type = PSTATE;
 602                 pwr->next = power_events;
 603
 604                 if (!pwr->start_time)
 605                         pwr->start_time = first_time;
 606                 if (!pwr->state)
 607                         pwr->state = min_freq;
 608                 power_events = pwr;
 609         }
 610 }
 611
 612 /*
 613  * Sort the pid datastructure
 614  */
 615 static void sort_pids(void)
 616 {
 617         struct per_pid *new_list, *p, *cursor, *prev;
 618         /* sort by ppid first, then by pid, lowest to highest */
 619
 620         new_list = NULL;
 621
 622         while (all_data) {
 623                 p = all_data;
 624                 all_data = p->next;
 625                 p->next = NULL;
 626
 627                 if (new_list == NULL) {
 628                         new_list = p;
 629                         p->next = NULL;
 630                         continue;
 631                 }
 632                 prev = NULL;
 633                 cursor = new_list;
 634                 while (cursor) {
 635                         if (cursor->ppid > p->ppid ||
 636                                 (cursor->ppid == p->ppid && cursor->pid > p->pid)) {
 637                                 /* must insert before */
 638                                 if (prev) {
 639                                         p->next = prev->next;
 640                                         prev->next = p;
 641                                         cursor = NULL;
 642                                         continue;
 643                                 } else {
 644                                         p->next = new_list;
 645                                         new_list = p;
 646                                         cursor = NULL;
 647                                         continue;
 648                                 }
 649                         }
 650
 651                         prev = cursor;
 652                         cursor = cursor->next;
 653                         if (!cursor)
 654                                 prev->next = p;
 655                 }
 656         }
 657         all_data = new_list;
 658 }
 659
 660
 661 static void draw_c_p_states(void)
 662 {
 663         struct power_event *pwr;
 664         pwr = power_events;
 665
 666         /*
 667          * two pass drawing so that the P state bars are on top of the C state blocks
 668          */
 669         while (pwr) {
 670                 if (pwr->type == CSTATE)
 671                         svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
 672                 pwr = pwr->next;
 673         }
 674
 675         pwr = power_events;
 676         while (pwr) {
 677                 if (pwr->type == PSTATE) {
 678                         if (!pwr->state)
 679                                 pwr->state = min_freq;
 680                         svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
 681                 }
 682                 pwr = pwr->next;
 683         }
 684 }
 685
 686 static void draw_wakeups(void)
 687 {
 688         struct wake_event *we;
 689         struct per_pid *p;
 690         struct per_pidcomm *c;
 691
 692         we = wake_events;
 693         while (we) {
 694                 int from = 0, to = 0;
 695                 char *task_from = NULL, *task_to = NULL;
 696
 697                 /* locate the column of the waker and wakee */
 698                 p = all_data;
 699                 while (p) {
 700                         if (p->pid == we->waker || p->pid == we->wakee) {
 701                                 c = p->all;
 702                                 while (c) {
 703                                         if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
 704                                                 if (p->pid == we->waker && !from) {
 705                                                         from = c->Y;
 706                                                         task_from = strdup(c->comm);
 707                                                 }
 708                                                 if (p->pid == we->wakee && !to) {
 709                                                         to = c->Y;
 710                                                         task_to = strdup(c->comm);
 711                                                 }
 712                                         }
 713                                         c = c->next;
 714                                 }
 715                                 c = p->all;
 716                                 while (c) {
 717                                         if (p->pid == we->waker && !from) {
 718                                                 from = c->Y;
 719                                                 task_from = strdup(c->comm);
 720                                         }
 721                                         if (p->pid == we->wakee && !to) {
 722                                                 to = c->Y;
 723                                                 task_to = strdup(c->comm);
 724                                         }
 725                                         c = c->next;
 726                                 }
 727                         }
 728                         p = p->next;
 729                 }
 730
 731                 if (!task_from) {
 732                         task_from = malloc(40);
 733                         sprintf(task_from, "[%i]", we->waker);
 734                 }
 735                 if (!task_to) {
 736                         task_to = malloc(40);
 737                         sprintf(task_to, "[%i]", we->wakee);
 738                 }
 739
 740                 if (we->waker == -1)
 741                         svg_interrupt(we->time, to);
 742                 else if (from && to && abs(from - to) == 1)
 743                         svg_wakeline(we->time, from, to);
 744                 else
 745                         svg_partial_wakeline(we->time, from, task_from, to, task_to);
 746                 we = we->next;
 747
 748                 free(task_from);
 749                 free(task_to);
 750         }
 751 }
 752
 753 static void draw_cpu_usage(void)
 754 {
 755         struct per_pid *p;
 756         struct per_pidcomm *c;
 757         struct cpu_sample *sample;
 758         p = all_data;
 759         while (p) {
 760                 c = p->all;
 761                 while (c) {
 762                         sample = c->samples;
 763                         while (sample) {
 764                                 if (sample->type == TYPE_RUNNING)
 765                                         svg_process(sample->cpu, sample->start_time, sample->end_time, "sample", c->comm);
 766
 767                                 sample = sample->next;
 768                         }
 769                         c = c->next;
 770                 }
 771                 p = p->next;
 772         }
 773 }
 774
 775 static void draw_process_bars(void)
 776 {
 777         struct per_pid *p;
 778         struct per_pidcomm *c;
 779         struct cpu_sample *sample;
 780         int Y = 0;
 781
 782         Y = 2 * numcpus + 2;
 783
 784         p = all_data;
 785         while (p) {
 786                 c = p->all;
 787                 while (c) {
 788                         if (!c->display) {
 789                                 c->Y = 0;
 790                                 c = c->next;
 791                                 continue;
 792                         }
 793
 794                         svg_box(Y, c->start_time, c->end_time, "process");
 795                         sample = c->samples;
 796                         while (sample) {
 797                                 if (sample->type == TYPE_RUNNING)
 798                                         svg_sample(Y, sample->cpu, sample->start_time, sample->end_time);
 799                                 if (sample->type == TYPE_BLOCKED)
 800                                         svg_box(Y, sample->start_time, sample->end_time, "blocked");
 801                                 if (sample->type == TYPE_WAITING)
 802                                         svg_waiting(Y, sample->start_time, sample->end_time);
 803                                 sample = sample->next;
 804                         }
 805
 806                         if (c->comm) {
 807                                 char comm[256];
 808                                 if (c->total_time > 5000000000) /* 5 seconds */
 809                                         sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0);
 810                                 else
 811                                         sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0);
 812
 813                                 svg_text(Y, c->start_time, comm);
 814                         }
 815                         c->Y = Y;
 816                         Y++;
 817                         c = c->next;
 818                 }
 819                 p = p->next;
 820         }
 821 }
 822
 823 static void add_process_filter(const char *string)
 824 {
 825         int pid = strtoull(string, NULL, 10);
 826         struct process_filter *filt = malloc(sizeof(*filt));
 827
 828         if (!filt)
 829                 return;
 830
 831         filt->name = strdup(string);
 832         filt->pid  = pid;
 833         filt->next = process_filter;
 834
 835         process_filter = filt;
 836 }
 837
 838 static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
 839 {
 840         struct process_filter *filt;
 841         if (!process_filter)
 842                 return 1;
 843
 844         filt = process_filter;
 845         while (filt) {
 846                 if (filt->pid && p->pid == filt->pid)
 847                         return 1;
 848                 if (strcmp(filt->name, c->comm) == 0)
 849                         return 1;
 850                 filt = filt->next;
 851         }
 852         return 0;
 853 }
 854
 855 static int determine_display_tasks_filtered(void)
 856 {
 857         struct per_pid *p;
 858         struct per_pidcomm *c;
 859         int count = 0;
 860
 861         p = all_data;
 862         while (p) {
 863                 p->display = 0;
 864                 if (p->start_time == 1)
 865                         p->start_time = first_time;
 866
 867                 /* no exit marker, task kept running to the end */
 868                 if (p->end_time == 0)
 869                         p->end_time = last_time;
 870
 871                 c = p->all;
 872
 873                 while (c) {
 874                         c->display = 0;
 875
 876                         if (c->start_time == 1)
 877                                 c->start_time = first_time;
 878
 879                         if (passes_filter(p, c)) {
 880                                 c->display = 1;
 881                                 p->display = 1;
 882                                 count++;
 883                         }
 884
 885                         if (c->end_time == 0)
 886                                 c->end_time = last_time;
 887
 888                         c = c->next;
 889                 }
 890                 p = p->next;
 891         }
 892         return count;
 893 }
 894
 895 static int determine_display_tasks(u64 threshold)
 896 {
 897         struct per_pid *p;
 898         struct per_pidcomm *c;
 899         int count = 0;
 900
 901         if (process_filter)
 902                 return determine_display_tasks_filtered();
 903
 904         p = all_data;
 905         while (p) {
 906                 p->display = 0;
 907                 if (p->start_time == 1)
 908                         p->start_time = first_time;
 909
 910                 /* no exit marker, task kept running to the end */
 911                 if (p->end_time == 0)
 912                         p->end_time = last_time;
 913                 if (p->total_time >= threshold && !power_only)
 914                         p->display = 1;
 915
 916                 c = p->all;
 917
 918                 while (c) {
 919                         c->display = 0;
 920
 921                         if (c->start_time == 1)
 922                                 c->start_time = first_time;
 923
 924                         if (c->total_time >= threshold && !power_only) {
 925                                 c->display = 1;
 926                                 count++;
 927                         }
 928
 929                         if (c->end_time == 0)
 930                                 c->end_time = last_time;
 931
 932                         c = c->next;
 933                 }
 934                 p = p->next;
 935         }
 936         return count;
 937 }
 938
 939
 940
 941 #define TIME_THRESH 10000000
 942
 943 static void write_svg_file(const char *filename)
 944 {
 945         u64 i;
 946         int count;
 947
 948         numcpus++;
 949
 950
 951         count = determine_display_tasks(TIME_THRESH);
 952
 953         /* We'd like to show at least 15 tasks; be less picky if we have fewer */
 954         if (count < 15)
 955                 count = determine_display_tasks(TIME_THRESH / 10);
 956
 957         open_svg(filename, numcpus, count, first_time, last_time);
 958
 959         svg_time_grid();
 960         svg_legenda();
 961
 962         for (i = 0; i < numcpus; i++)
 963                 svg_cpu_box(i, max_freq, turbo_frequency);
 964
 965         draw_cpu_usage();
 966         draw_process_bars();
 967         draw_c_p_states();
 968         draw_wakeups();
 969
 970         svg_close();
 971 }
 972
 973 static int __cmd_timechart(const char *output_name)
 974 {
 975         struct perf_tool perf_timechart = {
 976                 .comm            = process_comm_event,
 977                 .fork            = process_fork_event,
 978                 .exit            = process_exit_event,
 979                 .sample          = process_sample_event,
 980                 .ordered_samples = true,
 981         };
 982         const struct perf_evsel_str_handler power_tracepoints[] = {
 983                 { "power:cpu_idle",             process_sample_cpu_idle },
 984                 { "power:cpu_frequency",        process_sample_cpu_frequency },
 985                 { "sched:sched_wakeup",         process_sample_sched_wakeup },
 986                 { "sched:sched_switch",         process_sample_sched_switch },
 987 #ifdef SUPPORT_OLD_POWER_EVENTS
 988                 { "power:power_start",          process_sample_power_start },
 989                 { "power:power_end",            process_sample_power_end },
 990                 { "power:power_frequency",      process_sample_power_frequency },
 991 #endif
 992         };
 993         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
 994                                                          0, false, &perf_timechart);
 995         int ret = -EINVAL;
 996
 997         if (session == NULL)
 998                 return -ENOMEM;
 999
1000         if (!perf_session__has_traces(session, "timechart record"))
1001                 goto out_delete;
1002
1003         if (perf_session__set_tracepoints_handlers(session,
1004                                                    power_tracepoints)) {
1005                 pr_err("Initializing session tracepoint handlers failed\n");
1006                 goto out_delete;
1007         }
1008
1009         ret = perf_session__process_events(session, &perf_timechart);
1010         if (ret)
1011                 goto out_delete;
1012
1013         end_sample_processing();
1014
1015         sort_pids();
1016
1017         write_svg_file(output_name);
1018
1019         pr_info("Written %2.1f seconds of trace to %s.\n",
1020                 (last_time - first_time) / 1000000000.0, output_name);
1021 out_delete:
1022         perf_session__delete(session);
1023         return ret;
1024 }
1025
1026 static int __cmd_record(int argc, const char **argv)
1027 {
1028 #ifdef SUPPORT_OLD_POWER_EVENTS
1029         const char * const record_old_args[] = {
1030                 "record", "-a", "-R", "-c", "1",
1031                 "-e", "power:power_start",
1032                 "-e", "power:power_end",
1033                 "-e", "power:power_frequency",
1034                 "-e", "sched:sched_wakeup",
1035                 "-e", "sched:sched_switch",
1036         };
1037 #endif
1038         const char * const record_new_args[] = {
1039                 "record", "-a", "-R", "-c", "1",
1040                 "-e", "power:cpu_frequency",
1041                 "-e", "power:cpu_idle",
1042                 "-e", "sched:sched_wakeup",
1043                 "-e", "sched:sched_switch",
1044         };
1045         unsigned int rec_argc, i, j;
1046         const char **rec_argv;
1047         const char * const *record_args = record_new_args;
1048         unsigned int record_elems = ARRAY_SIZE(record_new_args);
1049
1050 #ifdef SUPPORT_OLD_POWER_EVENTS
1051         if (!is_valid_tracepoint("power:cpu_idle") &&
1052             is_valid_tracepoint("power:power_start")) {
1053                 use_old_power_events = 1;
1054                 record_args = record_old_args;
1055                 record_elems = ARRAY_SIZE(record_old_args);
1056         }
1057 #endif
1058
1059         rec_argc = record_elems + argc - 1;
1060         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1061
1062         if (rec_argv == NULL)
1063                 return -ENOMEM;
1064
1065         for (i = 0; i < record_elems; i++)
1066                 rec_argv[i] = strdup(record_args[i]);
1067
1068         for (j = 1; j < (unsigned int)argc; j++, i++)
1069                 rec_argv[i] = argv[j];
1070
1071         return cmd_record(i, rec_argv, NULL);
1072 }
1073
1074 static int
1075 parse_process(const struct option *opt __maybe_unused, const char *arg,
1076               int __maybe_unused unset)
1077 {
1078         if (arg)
1079                 add_process_filter(arg);
1080         return 0;
1081 }
1082
1083 int cmd_timechart(int argc, const char **argv,
1084                   const char *prefix __maybe_unused)
1085 {
1086         const char *output_name = "output.svg";
1087         const struct option options[] = {
1088         OPT_STRING('i', "input", &input_name, "file", "input file name"),
1089         OPT_STRING('o', "output", &output_name, "file", "output file name"),
1090         OPT_INTEGER('w', "width", &svg_page_width, "page width"),
1091         OPT_BOOLEAN('P', "power-only", &power_only, "output power data only"),
1092         OPT_CALLBACK('p', "process", NULL, "process",
1093                       "process selector. Pass a pid or process name.",
1094                        parse_process),
1095         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1096                     "Look for files with symbols relative to this directory"),
1097         OPT_END()
1098         };
1099         const char * const timechart_usage[] = {
1100                 "perf timechart [<options>] {record}",
1101                 NULL
1102         };
1103
1104         argc = parse_options(argc, argv, options, timechart_usage,
1105                         PARSE_OPT_STOP_AT_NON_OPTION);
1106
1107         symbol__init();
1108
1109         if (argc && !strncmp(argv[0], "rec", 3))
1110                 return __cmd_record(argc, argv);
1111         else if (argc)
1112                 usage_with_options(timechart_usage, options);
1113
1114         setup_pager();
1115
1116         return __cmd_timechart(output_name);
1117 }