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 #include "util/data.h"
  40
  41 #define SUPPORT_OLD_POWER_EVENTS 1
  42 #define PWR_EVENT_EXIT -1
  43
  44 struct per_pid;
  45 struct power_event;
  46 struct wake_event;
  47
  48 struct timechart {
  49         struct perf_tool        tool;
  50         struct per_pid          *all_data;
  51         struct power_event      *power_events;
  52         struct wake_event       *wake_events;
  53         int                     proc_num;
  54         unsigned int            numcpus;
  55         u64                     min_freq,       /* Lowest CPU frequency seen */
  56                                 max_freq,       /* Highest CPU frequency seen */
  57                                 turbo_frequency,
  58                                 first_time, last_time;
  59         bool                    power_only,
  60                                 tasks_only,
  61                                 with_backtrace,
  62                                 topology;
  63 };
  64
  65 struct per_pidcomm;
  66 struct cpu_sample;
  67
  68 /*
  69  * Datastructure layout:
  70  * We keep an list of "pid"s, matching the kernels notion of a task struct.
  71  * Each "pid" entry, has a list of "comm"s.
  72  *      this is because we want to track different programs different, while
  73  *      exec will reuse the original pid (by design).
  74  * Each comm has a list of samples that will be used to draw
  75  * final graph.
  76  */
  77
  78 struct per_pid {
  79         struct per_pid *next;
  80
  81         int             pid;
  82         int             ppid;
  83
  84         u64             start_time;
  85         u64             end_time;
  86         u64             total_time;
  87         int             display;
  88
  89         struct per_pidcomm *all;
  90         struct per_pidcomm *current;
  91 };
  92
  93
  94 struct per_pidcomm {
  95         struct per_pidcomm *next;
  96
  97         u64             start_time;
  98         u64             end_time;
  99         u64             total_time;
 100
 101         int             Y;
 102         int             display;
 103
 104         long            state;
 105         u64             state_since;
 106
 107         char            *comm;
 108
 109         struct cpu_sample *samples;
 110 };
 111
 112 struct sample_wrapper {
 113         struct sample_wrapper *next;
 114
 115         u64             timestamp;
 116         unsigned char   data[0];
 117 };
 118
 119 #define TYPE_NONE       0
 120 #define TYPE_RUNNING    1
 121 #define TYPE_WAITING    2
 122 #define TYPE_BLOCKED    3
 123
 124 struct cpu_sample {
 125         struct cpu_sample *next;
 126
 127         u64 start_time;
 128         u64 end_time;
 129         int type;
 130         int cpu;
 131         const char *backtrace;
 132 };
 133
 134 #define CSTATE 1
 135 #define PSTATE 2
 136
 137 struct power_event {
 138         struct power_event *next;
 139         int type;
 140         int state;
 141         u64 start_time;
 142         u64 end_time;
 143         int cpu;
 144 };
 145
 146 struct wake_event {
 147         struct wake_event *next;
 148         int waker;
 149         int wakee;
 150         u64 time;
 151         const char *backtrace;
 152 };
 153
 154 struct process_filter {
 155         char                    *name;
 156         int                     pid;
 157         struct process_filter   *next;
 158 };
 159
 160 static struct process_filter *process_filter;
 161
 162
 163 static struct per_pid *find_create_pid(struct timechart *tchart, int pid)
 164 {
 165         struct per_pid *cursor = tchart->all_data;
 166
 167         while (cursor) {
 168                 if (cursor->pid == pid)
 169                         return cursor;
 170                 cursor = cursor->next;
 171         }
 172         cursor = zalloc(sizeof(*cursor));
 173         assert(cursor != NULL);
 174         cursor->pid = pid;
 175         cursor->next = tchart->all_data;
 176         tchart->all_data = cursor;
 177         return cursor;
 178 }
 179
 180 static void pid_set_comm(struct timechart *tchart, int pid, char *comm)
 181 {
 182         struct per_pid *p;
 183         struct per_pidcomm *c;
 184         p = find_create_pid(tchart, pid);
 185         c = p->all;
 186         while (c) {
 187                 if (c->comm && strcmp(c->comm, comm) == 0) {
 188                         p->current = c;
 189                         return;
 190                 }
 191                 if (!c->comm) {
 192                         c->comm = strdup(comm);
 193                         p->current = c;
 194                         return;
 195                 }
 196                 c = c->next;
 197         }
 198         c = zalloc(sizeof(*c));
 199         assert(c != NULL);
 200         c->comm = strdup(comm);
 201         p->current = c;
 202         c->next = p->all;
 203         p->all = c;
 204 }
 205
 206 static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
 207 {
 208         struct per_pid *p, *pp;
 209         p = find_create_pid(tchart, pid);
 210         pp = find_create_pid(tchart, ppid);
 211         p->ppid = ppid;
 212         if (pp->current && pp->current->comm && !p->current)
 213                 pid_set_comm(tchart, pid, pp->current->comm);
 214
 215         p->start_time = timestamp;
 216         if (p->current) {
 217                 p->current->start_time = timestamp;
 218                 p->current->state_since = timestamp;
 219         }
 220 }
 221
 222 static void pid_exit(struct timechart *tchart, int pid, u64 timestamp)
 223 {
 224         struct per_pid *p;
 225         p = find_create_pid(tchart, pid);
 226         p->end_time = timestamp;
 227         if (p->current)
 228                 p->current->end_time = timestamp;
 229 }
 230
 231 static void pid_put_sample(struct timechart *tchart, int pid, int type,
 232                            unsigned int cpu, u64 start, u64 end,
 233                            const char *backtrace)
 234 {
 235         struct per_pid *p;
 236         struct per_pidcomm *c;
 237         struct cpu_sample *sample;
 238
 239         p = find_create_pid(tchart, pid);
 240         c = p->current;
 241         if (!c) {
 242                 c = zalloc(sizeof(*c));
 243                 assert(c != NULL);
 244                 p->current = c;
 245                 c->next = p->all;
 246                 p->all = c;
 247         }
 248
 249         sample = zalloc(sizeof(*sample));
 250         assert(sample != NULL);
 251         sample->start_time = start;
 252         sample->end_time = end;
 253         sample->type = type;
 254         sample->next = c->samples;
 255         sample->cpu = cpu;
 256         sample->backtrace = backtrace;
 257         c->samples = sample;
 258
 259         if (sample->type == TYPE_RUNNING && end > start && start > 0) {
 260                 c->total_time += (end-start);
 261                 p->total_time += (end-start);
 262         }
 263
 264         if (c->start_time == 0 || c->start_time > start)
 265                 c->start_time = start;
 266         if (p->start_time == 0 || p->start_time > start)
 267                 p->start_time = start;
 268 }
 269
 270 #define MAX_CPUS 4096
 271
 272 static u64 cpus_cstate_start_times[MAX_CPUS];
 273 static int cpus_cstate_state[MAX_CPUS];
 274 static u64 cpus_pstate_start_times[MAX_CPUS];
 275 static u64 cpus_pstate_state[MAX_CPUS];
 276
 277 static int process_comm_event(struct perf_tool *tool,
 278                               union perf_event *event,
 279                               struct perf_sample *sample __maybe_unused,
 280                               struct machine *machine __maybe_unused)
 281 {
 282         struct timechart *tchart = container_of(tool, struct timechart, tool);
 283         pid_set_comm(tchart, event->comm.tid, event->comm.comm);
 284         return 0;
 285 }
 286
 287 static int process_fork_event(struct perf_tool *tool,
 288                               union perf_event *event,
 289                               struct perf_sample *sample __maybe_unused,
 290                               struct machine *machine __maybe_unused)
 291 {
 292         struct timechart *tchart = container_of(tool, struct timechart, tool);
 293         pid_fork(tchart, event->fork.pid, event->fork.ppid, event->fork.time);
 294         return 0;
 295 }
 296
 297 static int process_exit_event(struct perf_tool *tool,
 298                               union perf_event *event,
 299                               struct perf_sample *sample __maybe_unused,
 300                               struct machine *machine __maybe_unused)
 301 {
 302         struct timechart *tchart = container_of(tool, struct timechart, tool);
 303         pid_exit(tchart, event->fork.pid, event->fork.time);
 304         return 0;
 305 }
 306
 307 #ifdef SUPPORT_OLD_POWER_EVENTS
 308 static int use_old_power_events;
 309 #endif
 310
 311 static void c_state_start(int cpu, u64 timestamp, int state)
 312 {
 313         cpus_cstate_start_times[cpu] = timestamp;
 314         cpus_cstate_state[cpu] = state;
 315 }
 316
 317 static void c_state_end(struct timechart *tchart, int cpu, u64 timestamp)
 318 {
 319         struct power_event *pwr = zalloc(sizeof(*pwr));
 320
 321         if (!pwr)
 322                 return;
 323
 324         pwr->state = cpus_cstate_state[cpu];
 325         pwr->start_time = cpus_cstate_start_times[cpu];
 326         pwr->end_time = timestamp;
 327         pwr->cpu = cpu;
 328         pwr->type = CSTATE;
 329         pwr->next = tchart->power_events;
 330
 331         tchart->power_events = pwr;
 332 }
 333
 334 static void p_state_change(struct timechart *tchart, int cpu, u64 timestamp, u64 new_freq)
 335 {
 336         struct power_event *pwr;
 337
 338         if (new_freq > 8000000) /* detect invalid data */
 339                 return;
 340
 341         pwr = zalloc(sizeof(*pwr));
 342         if (!pwr)
 343                 return;
 344
 345         pwr->state = cpus_pstate_state[cpu];
 346         pwr->start_time = cpus_pstate_start_times[cpu];
 347         pwr->end_time = timestamp;
 348         pwr->cpu = cpu;
 349         pwr->type = PSTATE;
 350         pwr->next = tchart->power_events;
 351
 352         if (!pwr->start_time)
 353                 pwr->start_time = tchart->first_time;
 354
 355         tchart->power_events = pwr;
 356
 357         cpus_pstate_state[cpu] = new_freq;
 358         cpus_pstate_start_times[cpu] = timestamp;
 359
 360         if ((u64)new_freq > tchart->max_freq)
 361                 tchart->max_freq = new_freq;
 362
 363         if (new_freq < tchart->min_freq || tchart->min_freq == 0)
 364                 tchart->min_freq = new_freq;
 365
 366         if (new_freq == tchart->max_freq - 1000)
 367                 tchart->turbo_frequency = tchart->max_freq;
 368 }
 369
 370 static void sched_wakeup(struct timechart *tchart, int cpu, u64 timestamp,
 371                          int waker, int wakee, u8 flags, const char *backtrace)
 372 {
 373         struct per_pid *p;
 374         struct wake_event *we = zalloc(sizeof(*we));
 375
 376         if (!we)
 377                 return;
 378
 379         we->time = timestamp;
 380         we->waker = waker;
 381         we->backtrace = backtrace;
 382
 383         if ((flags & TRACE_FLAG_HARDIRQ) || (flags & TRACE_FLAG_SOFTIRQ))
 384                 we->waker = -1;
 385
 386         we->wakee = wakee;
 387         we->next = tchart->wake_events;
 388         tchart->wake_events = we;
 389         p = find_create_pid(tchart, we->wakee);
 390
 391         if (p && p->current && p->current->state == TYPE_NONE) {
 392                 p->current->state_since = timestamp;
 393                 p->current->state = TYPE_WAITING;
 394         }
 395         if (p && p->current && p->current->state == TYPE_BLOCKED) {
 396                 pid_put_sample(tchart, p->pid, p->current->state, cpu,
 397                                p->current->state_since, timestamp, NULL);
 398                 p->current->state_since = timestamp;
 399                 p->current->state = TYPE_WAITING;
 400         }
 401 }
 402
 403 static void sched_switch(struct timechart *tchart, int cpu, u64 timestamp,
 404                          int prev_pid, int next_pid, u64 prev_state,
 405                          const char *backtrace)
 406 {
 407         struct per_pid *p = NULL, *prev_p;
 408
 409         prev_p = find_create_pid(tchart, prev_pid);
 410
 411         p = find_create_pid(tchart, next_pid);
 412
 413         if (prev_p->current && prev_p->current->state != TYPE_NONE)
 414                 pid_put_sample(tchart, prev_pid, TYPE_RUNNING, cpu,
 415                                prev_p->current->state_since, timestamp,
 416                                backtrace);
 417         if (p && p->current) {
 418                 if (p->current->state != TYPE_NONE)
 419                         pid_put_sample(tchart, next_pid, p->current->state, cpu,
 420                                        p->current->state_since, timestamp,
 421                                        backtrace);
 422
 423                 p->current->state_since = timestamp;
 424                 p->current->state = TYPE_RUNNING;
 425         }
 426
 427         if (prev_p->current) {
 428                 prev_p->current->state = TYPE_NONE;
 429                 prev_p->current->state_since = timestamp;
 430                 if (prev_state & 2)
 431                         prev_p->current->state = TYPE_BLOCKED;
 432                 if (prev_state == 0)
 433                         prev_p->current->state = TYPE_WAITING;
 434         }
 435 }
 436
 437 static const char *cat_backtrace(union perf_event *event,
 438                                  struct perf_sample *sample,
 439                                  struct machine *machine)
 440 {
 441         struct addr_location al;
 442         unsigned int i;
 443         char *p = NULL;
 444         size_t p_len;
 445         u8 cpumode = PERF_RECORD_MISC_USER;
 446         struct addr_location tal;
 447         struct ip_callchain *chain = sample->callchain;
 448         FILE *f = open_memstream(&p, &p_len);
 449
 450         if (!f) {
 451                 perror("open_memstream error");
 452                 return NULL;
 453         }
 454
 455         if (!chain)
 456                 goto exit;
 457
 458         if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
 459                 fprintf(stderr, "problem processing %d event, skipping it.\n",
 460                         event->header.type);
 461                 goto exit;
 462         }
 463
 464         for (i = 0; i < chain->nr; i++) {
 465                 u64 ip;
 466
 467                 if (callchain_param.order == ORDER_CALLEE)
 468                         ip = chain->ips[i];
 469                 else
 470                         ip = chain->ips[chain->nr - i - 1];
 471
 472                 if (ip >= PERF_CONTEXT_MAX) {
 473                         switch (ip) {
 474                         case PERF_CONTEXT_HV:
 475                                 cpumode = PERF_RECORD_MISC_HYPERVISOR;
 476                                 break;
 477                         case PERF_CONTEXT_KERNEL:
 478                                 cpumode = PERF_RECORD_MISC_KERNEL;
 479                                 break;
 480                         case PERF_CONTEXT_USER:
 481                                 cpumode = PERF_RECORD_MISC_USER;
 482                                 break;
 483                         default:
 484                                 pr_debug("invalid callchain context: "
 485                                          "%"PRId64"\n", (s64) ip);
 486
 487                                 /*
 488                                  * It seems the callchain is corrupted.
 489                                  * Discard all.
 490                                  */
 491                                 free(p);
 492                                 p = NULL;
 493                                 goto exit;
 494                         }
 495                         continue;
 496                 }
 497
 498                 tal.filtered = false;
 499                 thread__find_addr_location(al.thread, machine, cpumode,
 500                                            MAP__FUNCTION, ip, &tal);
 501
 502                 if (tal.sym)
 503                         fprintf(f, "..... %016" PRIx64 " %s\n", ip,
 504                                 tal.sym->name);
 505                 else
 506                         fprintf(f, "..... %016" PRIx64 "\n", ip);
 507         }
 508
 509 exit:
 510         fclose(f);
 511
 512         return p;
 513 }
 514
 515 typedef int (*tracepoint_handler)(struct timechart *tchart,
 516                                   struct perf_evsel *evsel,
 517                                   struct perf_sample *sample,
 518                                   const char *backtrace);
 519
 520 static int process_sample_event(struct perf_tool *tool,
 521                                 union perf_event *event,
 522                                 struct perf_sample *sample,
 523                                 struct perf_evsel *evsel,
 524                                 struct machine *machine)
 525 {
 526         struct timechart *tchart = container_of(tool, struct timechart, tool);
 527
 528         if (evsel->attr.sample_type & PERF_SAMPLE_TIME) {
 529                 if (!tchart->first_time || tchart->first_time > sample->time)
 530                         tchart->first_time = sample->time;
 531                 if (tchart->last_time < sample->time)
 532                         tchart->last_time = sample->time;
 533         }
 534
 535         if (evsel->handler != NULL) {
 536                 tracepoint_handler f = evsel->handler;
 537                 return f(tchart, evsel, sample,
 538                          cat_backtrace(event, sample, machine));
 539         }
 540
 541         return 0;
 542 }
 543
 544 static int
 545 process_sample_cpu_idle(struct timechart *tchart __maybe_unused,
 546                         struct perf_evsel *evsel,
 547                         struct perf_sample *sample,
 548                         const char *backtrace __maybe_unused)
 549 {
 550         u32 state = perf_evsel__intval(evsel, sample, "state");
 551         u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
 552
 553         if (state == (u32)PWR_EVENT_EXIT)
 554                 c_state_end(tchart, cpu_id, sample->time);
 555         else
 556                 c_state_start(cpu_id, sample->time, state);
 557         return 0;
 558 }
 559
 560 static int
 561 process_sample_cpu_frequency(struct timechart *tchart,
 562                              struct perf_evsel *evsel,
 563                              struct perf_sample *sample,
 564                              const char *backtrace __maybe_unused)
 565 {
 566         u32 state = perf_evsel__intval(evsel, sample, "state");
 567         u32 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
 568
 569         p_state_change(tchart, cpu_id, sample->time, state);
 570         return 0;
 571 }
 572
 573 static int
 574 process_sample_sched_wakeup(struct timechart *tchart,
 575                             struct perf_evsel *evsel,
 576                             struct perf_sample *sample,
 577                             const char *backtrace)
 578 {
 579         u8 flags = perf_evsel__intval(evsel, sample, "common_flags");
 580         int waker = perf_evsel__intval(evsel, sample, "common_pid");
 581         int wakee = perf_evsel__intval(evsel, sample, "pid");
 582
 583         sched_wakeup(tchart, sample->cpu, sample->time, waker, wakee, flags, backtrace);
 584         return 0;
 585 }
 586
 587 static int
 588 process_sample_sched_switch(struct timechart *tchart,
 589                             struct perf_evsel *evsel,
 590                             struct perf_sample *sample,
 591                             const char *backtrace)
 592 {
 593         int prev_pid = perf_evsel__intval(evsel, sample, "prev_pid");
 594         int next_pid = perf_evsel__intval(evsel, sample, "next_pid");
 595         u64 prev_state = perf_evsel__intval(evsel, sample, "prev_state");
 596
 597         sched_switch(tchart, sample->cpu, sample->time, prev_pid, next_pid,
 598                      prev_state, backtrace);
 599         return 0;
 600 }
 601
 602 #ifdef SUPPORT_OLD_POWER_EVENTS
 603 static int
 604 process_sample_power_start(struct timechart *tchart __maybe_unused,
 605                            struct perf_evsel *evsel,
 606                            struct perf_sample *sample,
 607                            const char *backtrace __maybe_unused)
 608 {
 609         u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
 610         u64 value = perf_evsel__intval(evsel, sample, "value");
 611
 612         c_state_start(cpu_id, sample->time, value);
 613         return 0;
 614 }
 615
 616 static int
 617 process_sample_power_end(struct timechart *tchart,
 618                          struct perf_evsel *evsel __maybe_unused,
 619                          struct perf_sample *sample,
 620                          const char *backtrace __maybe_unused)
 621 {
 622         c_state_end(tchart, sample->cpu, sample->time);
 623         return 0;
 624 }
 625
 626 static int
 627 process_sample_power_frequency(struct timechart *tchart,
 628                                struct perf_evsel *evsel,
 629                                struct perf_sample *sample,
 630                                const char *backtrace __maybe_unused)
 631 {
 632         u64 cpu_id = perf_evsel__intval(evsel, sample, "cpu_id");
 633         u64 value = perf_evsel__intval(evsel, sample, "value");
 634
 635         p_state_change(tchart, cpu_id, sample->time, value);
 636         return 0;
 637 }
 638 #endif /* SUPPORT_OLD_POWER_EVENTS */
 639
 640 /*
 641  * After the last sample we need to wrap up the current C/P state
 642  * and close out each CPU for these.
 643  */
 644 static void end_sample_processing(struct timechart *tchart)
 645 {
 646         u64 cpu;
 647         struct power_event *pwr;
 648
 649         for (cpu = 0; cpu <= tchart->numcpus; cpu++) {
 650                 /* C state */
 651 #if 0
 652                 pwr = zalloc(sizeof(*pwr));
 653                 if (!pwr)
 654                         return;
 655
 656                 pwr->state = cpus_cstate_state[cpu];
 657                 pwr->start_time = cpus_cstate_start_times[cpu];
 658                 pwr->end_time = tchart->last_time;
 659                 pwr->cpu = cpu;
 660                 pwr->type = CSTATE;
 661                 pwr->next = tchart->power_events;
 662
 663                 tchart->power_events = pwr;
 664 #endif
 665                 /* P state */
 666
 667                 pwr = zalloc(sizeof(*pwr));
 668                 if (!pwr)
 669                         return;
 670
 671                 pwr->state = cpus_pstate_state[cpu];
 672                 pwr->start_time = cpus_pstate_start_times[cpu];
 673                 pwr->end_time = tchart->last_time;
 674                 pwr->cpu = cpu;
 675                 pwr->type = PSTATE;
 676                 pwr->next = tchart->power_events;
 677
 678                 if (!pwr->start_time)
 679                         pwr->start_time = tchart->first_time;
 680                 if (!pwr->state)
 681                         pwr->state = tchart->min_freq;
 682                 tchart->power_events = pwr;
 683         }
 684 }
 685
 686 /*
 687  * Sort the pid datastructure
 688  */
 689 static void sort_pids(struct timechart *tchart)
 690 {
 691         struct per_pid *new_list, *p, *cursor, *prev;
 692         /* sort by ppid first, then by pid, lowest to highest */
 693
 694         new_list = NULL;
 695
 696         while (tchart->all_data) {
 697                 p = tchart->all_data;
 698                 tchart->all_data = p->next;
 699                 p->next = NULL;
 700
 701                 if (new_list == NULL) {
 702                         new_list = p;
 703                         p->next = NULL;
 704                         continue;
 705                 }
 706                 prev = NULL;
 707                 cursor = new_list;
 708                 while (cursor) {
 709                         if (cursor->ppid > p->ppid ||
 710                                 (cursor->ppid == p->ppid && cursor->pid > p->pid)) {
 711                                 /* must insert before */
 712                                 if (prev) {
 713                                         p->next = prev->next;
 714                                         prev->next = p;
 715                                         cursor = NULL;
 716                                         continue;
 717                                 } else {
 718                                         p->next = new_list;
 719                                         new_list = p;
 720                                         cursor = NULL;
 721                                         continue;
 722                                 }
 723                         }
 724
 725                         prev = cursor;
 726                         cursor = cursor->next;
 727                         if (!cursor)
 728                                 prev->next = p;
 729                 }
 730         }
 731         tchart->all_data = new_list;
 732 }
 733
 734
 735 static void draw_c_p_states(struct timechart *tchart)
 736 {
 737         struct power_event *pwr;
 738         pwr = tchart->power_events;
 739
 740         /*
 741          * two pass drawing so that the P state bars are on top of the C state blocks
 742          */
 743         while (pwr) {
 744                 if (pwr->type == CSTATE)
 745                         svg_cstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
 746                 pwr = pwr->next;
 747         }
 748
 749         pwr = tchart->power_events;
 750         while (pwr) {
 751                 if (pwr->type == PSTATE) {
 752                         if (!pwr->state)
 753                                 pwr->state = tchart->min_freq;
 754                         svg_pstate(pwr->cpu, pwr->start_time, pwr->end_time, pwr->state);
 755                 }
 756                 pwr = pwr->next;
 757         }
 758 }
 759
 760 static void draw_wakeups(struct timechart *tchart)
 761 {
 762         struct wake_event *we;
 763         struct per_pid *p;
 764         struct per_pidcomm *c;
 765
 766         we = tchart->wake_events;
 767         while (we) {
 768                 int from = 0, to = 0;
 769                 char *task_from = NULL, *task_to = NULL;
 770
 771                 /* locate the column of the waker and wakee */
 772                 p = tchart->all_data;
 773                 while (p) {
 774                         if (p->pid == we->waker || p->pid == we->wakee) {
 775                                 c = p->all;
 776                                 while (c) {
 777                                         if (c->Y && c->start_time <= we->time && c->end_time >= we->time) {
 778                                                 if (p->pid == we->waker && !from) {
 779                                                         from = c->Y;
 780                                                         task_from = strdup(c->comm);
 781                                                 }
 782                                                 if (p->pid == we->wakee && !to) {
 783                                                         to = c->Y;
 784                                                         task_to = strdup(c->comm);
 785                                                 }
 786                                         }
 787                                         c = c->next;
 788                                 }
 789                                 c = p->all;
 790                                 while (c) {
 791                                         if (p->pid == we->waker && !from) {
 792                                                 from = c->Y;
 793                                                 task_from = strdup(c->comm);
 794                                         }
 795                                         if (p->pid == we->wakee && !to) {
 796                                                 to = c->Y;
 797                                                 task_to = strdup(c->comm);
 798                                         }
 799                                         c = c->next;
 800                                 }
 801                         }
 802                         p = p->next;
 803                 }
 804
 805                 if (!task_from) {
 806                         task_from = malloc(40);
 807                         sprintf(task_from, "[%i]", we->waker);
 808                 }
 809                 if (!task_to) {
 810                         task_to = malloc(40);
 811                         sprintf(task_to, "[%i]", we->wakee);
 812                 }
 813
 814                 if (we->waker == -1)
 815                         svg_interrupt(we->time, to, we->backtrace);
 816                 else if (from && to && abs(from - to) == 1)
 817                         svg_wakeline(we->time, from, to, we->backtrace);
 818                 else
 819                         svg_partial_wakeline(we->time, from, task_from, to,
 820                                              task_to, we->backtrace);
 821                 we = we->next;
 822
 823                 free(task_from);
 824                 free(task_to);
 825         }
 826 }
 827
 828 static void draw_cpu_usage(struct timechart *tchart)
 829 {
 830         struct per_pid *p;
 831         struct per_pidcomm *c;
 832         struct cpu_sample *sample;
 833         p = tchart->all_data;
 834         while (p) {
 835                 c = p->all;
 836                 while (c) {
 837                         sample = c->samples;
 838                         while (sample) {
 839                                 if (sample->type == TYPE_RUNNING) {
 840                                         svg_process(sample->cpu,
 841                                                     sample->start_time,
 842                                                     sample->end_time,
 843                                                     p->pid,
 844                                                     c->comm,
 845                                                     sample->backtrace);
 846                                 }
 847
 848                                 sample = sample->next;
 849                         }
 850                         c = c->next;
 851                 }
 852                 p = p->next;
 853         }
 854 }
 855
 856 static void draw_process_bars(struct timechart *tchart)
 857 {
 858         struct per_pid *p;
 859         struct per_pidcomm *c;
 860         struct cpu_sample *sample;
 861         int Y = 0;
 862
 863         Y = 2 * tchart->numcpus + 2;
 864
 865         p = tchart->all_data;
 866         while (p) {
 867                 c = p->all;
 868                 while (c) {
 869                         if (!c->display) {
 870                                 c->Y = 0;
 871                                 c = c->next;
 872                                 continue;
 873                         }
 874
 875                         svg_box(Y, c->start_time, c->end_time, "process");
 876                         sample = c->samples;
 877                         while (sample) {
 878                                 if (sample->type == TYPE_RUNNING)
 879                                         svg_running(Y, sample->cpu,
 880                                                     sample->start_time,
 881                                                     sample->end_time,
 882                                                     sample->backtrace);
 883                                 if (sample->type == TYPE_BLOCKED)
 884                                         svg_blocked(Y, sample->cpu,
 885                                                     sample->start_time,
 886                                                     sample->end_time,
 887                                                     sample->backtrace);
 888                                 if (sample->type == TYPE_WAITING)
 889                                         svg_waiting(Y, sample->cpu,
 890                                                     sample->start_time,
 891                                                     sample->end_time,
 892                                                     sample->backtrace);
 893                                 sample = sample->next;
 894                         }
 895
 896                         if (c->comm) {
 897                                 char comm[256];
 898                                 if (c->total_time > 5000000000) /* 5 seconds */
 899                                         sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0);
 900                                 else
 901                                         sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0);
 902
 903                                 svg_text(Y, c->start_time, comm);
 904                         }
 905                         c->Y = Y;
 906                         Y++;
 907                         c = c->next;
 908                 }
 909                 p = p->next;
 910         }
 911 }
 912
 913 static void add_process_filter(const char *string)
 914 {
 915         int pid = strtoull(string, NULL, 10);
 916         struct process_filter *filt = malloc(sizeof(*filt));
 917
 918         if (!filt)
 919                 return;
 920
 921         filt->name = strdup(string);
 922         filt->pid  = pid;
 923         filt->next = process_filter;
 924
 925         process_filter = filt;
 926 }
 927
 928 static int passes_filter(struct per_pid *p, struct per_pidcomm *c)
 929 {
 930         struct process_filter *filt;
 931         if (!process_filter)
 932                 return 1;
 933
 934         filt = process_filter;
 935         while (filt) {
 936                 if (filt->pid && p->pid == filt->pid)
 937                         return 1;
 938                 if (strcmp(filt->name, c->comm) == 0)
 939                         return 1;
 940                 filt = filt->next;
 941         }
 942         return 0;
 943 }
 944
 945 static int determine_display_tasks_filtered(struct timechart *tchart)
 946 {
 947         struct per_pid *p;
 948         struct per_pidcomm *c;
 949         int count = 0;
 950
 951         p = tchart->all_data;
 952         while (p) {
 953                 p->display = 0;
 954                 if (p->start_time == 1)
 955                         p->start_time = tchart->first_time;
 956
 957                 /* no exit marker, task kept running to the end */
 958                 if (p->end_time == 0)
 959                         p->end_time = tchart->last_time;
 960
 961                 c = p->all;
 962
 963                 while (c) {
 964                         c->display = 0;
 965
 966                         if (c->start_time == 1)
 967                                 c->start_time = tchart->first_time;
 968
 969                         if (passes_filter(p, c)) {
 970                                 c->display = 1;
 971                                 p->display = 1;
 972                                 count++;
 973                         }
 974
 975                         if (c->end_time == 0)
 976                                 c->end_time = tchart->last_time;
 977
 978                         c = c->next;
 979                 }
 980                 p = p->next;
 981         }
 982         return count;
 983 }
 984
 985 static int determine_display_tasks(struct timechart *tchart, u64 threshold)
 986 {
 987         struct per_pid *p;
 988         struct per_pidcomm *c;
 989         int count = 0;
 990
 991         if (process_filter)
 992                 return determine_display_tasks_filtered(tchart);
 993
 994         p = tchart->all_data;
 995         while (p) {
 996                 p->display = 0;
 997                 if (p->start_time == 1)
 998                         p->start_time = tchart->first_time;
 999
1000                 /* no exit marker, task kept running to the end */
1001                 if (p->end_time == 0)
1002                         p->end_time = tchart->last_time;
1003                 if (p->total_time >= threshold)
1004                         p->display = 1;
1005
1006                 c = p->all;
1007
1008                 while (c) {
1009                         c->display = 0;
1010
1011                         if (c->start_time == 1)
1012                                 c->start_time = tchart->first_time;
1013
1014                         if (c->total_time >= threshold) {
1015                                 c->display = 1;
1016                                 count++;
1017                         }
1018
1019                         if (c->end_time == 0)
1020                                 c->end_time = tchart->last_time;
1021
1022                         c = c->next;
1023                 }
1024                 p = p->next;
1025         }
1026         return count;
1027 }
1028
1029
1030
1031 #define TIME_THRESH 10000000
1032
1033 static void write_svg_file(struct timechart *tchart, const char *filename)
1034 {
1035         u64 i;
1036         int count;
1037         int thresh = TIME_THRESH;
1038
1039         if (tchart->power_only)
1040                 tchart->proc_num = 0;
1041
1042         /* We'd like to show at least proc_num tasks;
1043          * be less picky if we have fewer */
1044         do {
1045                 count = determine_display_tasks(tchart, thresh);
1046                 thresh /= 10;
1047         } while (!process_filter && thresh && count < tchart->proc_num);
1048
1049         open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
1050
1051         svg_time_grid();
1052         svg_legenda();
1053
1054         for (i = 0; i < tchart->numcpus; i++)
1055                 svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
1056
1057         draw_cpu_usage(tchart);
1058         if (tchart->proc_num)
1059                 draw_process_bars(tchart);
1060         if (!tchart->tasks_only)
1061                 draw_c_p_states(tchart);
1062         if (tchart->proc_num)
1063                 draw_wakeups(tchart);
1064
1065         svg_close();
1066 }
1067
1068 static int process_header(struct perf_file_section *section __maybe_unused,
1069                           struct perf_header *ph,
1070                           int feat,
1071                           int fd __maybe_unused,
1072                           void *data)
1073 {
1074         struct timechart *tchart = data;
1075
1076         switch (feat) {
1077         case HEADER_NRCPUS:
1078                 tchart->numcpus = ph->env.nr_cpus_avail;
1079                 break;
1080
1081         case HEADER_CPU_TOPOLOGY:
1082                 if (!tchart->topology)
1083                         break;
1084
1085                 if (svg_build_topology_map(ph->env.sibling_cores,
1086                                            ph->env.nr_sibling_cores,
1087                                            ph->env.sibling_threads,
1088                                            ph->env.nr_sibling_threads))
1089                         fprintf(stderr, "problem building topology\n");
1090                 break;
1091
1092         default:
1093                 break;
1094         }
1095
1096         return 0;
1097 }
1098
1099 static int __cmd_timechart(struct timechart *tchart, const char *output_name)
1100 {
1101         const struct perf_evsel_str_handler power_tracepoints[] = {
1102                 { "power:cpu_idle",             process_sample_cpu_idle },
1103                 { "power:cpu_frequency",        process_sample_cpu_frequency },
1104                 { "sched:sched_wakeup",         process_sample_sched_wakeup },
1105                 { "sched:sched_switch",         process_sample_sched_switch },
1106 #ifdef SUPPORT_OLD_POWER_EVENTS
1107                 { "power:power_start",          process_sample_power_start },
1108                 { "power:power_end",            process_sample_power_end },
1109                 { "power:power_frequency",      process_sample_power_frequency },
1110 #endif
1111         };
1112         struct perf_data_file file = {
1113                 .path = input_name,
1114                 .mode = PERF_DATA_MODE_READ,
1115         };
1116
1117         struct perf_session *session = perf_session__new(&file, false,
1118                                                          &tchart->tool);
1119         int ret = -EINVAL;
1120
1121         if (session == NULL)
1122                 return -ENOMEM;
1123
1124         (void)perf_header__process_sections(&session->header,
1125                                             perf_data_file__fd(session->file),
1126                                             tchart,
1127                                             process_header);
1128
1129         if (!perf_session__has_traces(session, "timechart record"))
1130                 goto out_delete;
1131
1132         if (perf_session__set_tracepoints_handlers(session,
1133                                                    power_tracepoints)) {
1134                 pr_err("Initializing session tracepoint handlers failed\n");
1135                 goto out_delete;
1136         }
1137
1138         ret = perf_session__process_events(session, &tchart->tool);
1139         if (ret)
1140                 goto out_delete;
1141
1142         end_sample_processing(tchart);
1143
1144         sort_pids(tchart);
1145
1146         write_svg_file(tchart, output_name);
1147
1148         pr_info("Written %2.1f seconds of trace to %s.\n",
1149                 (tchart->last_time - tchart->first_time) / 1000000000.0, output_name);
1150 out_delete:
1151         perf_session__delete(session);
1152         return ret;
1153 }
1154
1155 static int timechart__record(struct timechart *tchart, int argc, const char **argv)
1156 {
1157         unsigned int rec_argc, i, j;
1158         const char **rec_argv;
1159         const char **p;
1160         unsigned int record_elems;
1161
1162         const char * const common_args[] = {
1163                 "record", "-a", "-R", "-c", "1",
1164         };
1165         unsigned int common_args_nr = ARRAY_SIZE(common_args);
1166
1167         const char * const backtrace_args[] = {
1168                 "-g",
1169         };
1170         unsigned int backtrace_args_no = ARRAY_SIZE(backtrace_args);
1171
1172         const char * const power_args[] = {
1173                 "-e", "power:cpu_frequency",
1174                 "-e", "power:cpu_idle",
1175         };
1176         unsigned int power_args_nr = ARRAY_SIZE(power_args);
1177
1178         const char * const old_power_args[] = {
1179 #ifdef SUPPORT_OLD_POWER_EVENTS
1180                 "-e", "power:power_start",
1181                 "-e", "power:power_end",
1182                 "-e", "power:power_frequency",
1183 #endif
1184         };
1185         unsigned int old_power_args_nr = ARRAY_SIZE(old_power_args);
1186
1187         const char * const tasks_args[] = {
1188                 "-e", "sched:sched_wakeup",
1189                 "-e", "sched:sched_switch",
1190         };
1191         unsigned int tasks_args_nr = ARRAY_SIZE(tasks_args);
1192
1193 #ifdef SUPPORT_OLD_POWER_EVENTS
1194         if (!is_valid_tracepoint("power:cpu_idle") &&
1195             is_valid_tracepoint("power:power_start")) {
1196                 use_old_power_events = 1;
1197                 power_args_nr = 0;
1198         } else {
1199                 old_power_args_nr = 0;
1200         }
1201 #endif
1202
1203         if (tchart->power_only)
1204                 tasks_args_nr = 0;
1205
1206         if (tchart->tasks_only) {
1207                 power_args_nr = 0;
1208                 old_power_args_nr = 0;
1209         }
1210
1211         if (!tchart->with_backtrace)
1212                 backtrace_args_no = 0;
1213
1214         record_elems = common_args_nr + tasks_args_nr +
1215                 power_args_nr + old_power_args_nr + backtrace_args_no;
1216
1217         rec_argc = record_elems + argc;
1218         rec_argv = calloc(rec_argc + 1, sizeof(char *));
1219
1220         if (rec_argv == NULL)
1221                 return -ENOMEM;
1222
1223         p = rec_argv;
1224         for (i = 0; i < common_args_nr; i++)
1225                 *p++ = strdup(common_args[i]);
1226
1227         for (i = 0; i < backtrace_args_no; i++)
1228                 *p++ = strdup(backtrace_args[i]);
1229
1230         for (i = 0; i < tasks_args_nr; i++)
1231                 *p++ = strdup(tasks_args[i]);
1232
1233         for (i = 0; i < power_args_nr; i++)
1234                 *p++ = strdup(power_args[i]);
1235
1236         for (i = 0; i < old_power_args_nr; i++)
1237                 *p++ = strdup(old_power_args[i]);
1238
1239         for (j = 1; j < (unsigned int)argc; j++)
1240                 *p++ = argv[j];
1241
1242         return cmd_record(rec_argc, rec_argv, NULL);
1243 }
1244
1245 static int
1246 parse_process(const struct option *opt __maybe_unused, const char *arg,
1247               int __maybe_unused unset)
1248 {
1249         if (arg)
1250                 add_process_filter(arg);
1251         return 0;
1252 }
1253
1254 static int
1255 parse_highlight(const struct option *opt __maybe_unused, const char *arg,
1256                 int __maybe_unused unset)
1257 {
1258         unsigned long duration = strtoul(arg, NULL, 0);
1259
1260         if (svg_highlight || svg_highlight_name)
1261                 return -1;
1262
1263         if (duration)
1264                 svg_highlight = duration;
1265         else
1266                 svg_highlight_name = strdup(arg);
1267
1268         return 0;
1269 }
1270
1271 int cmd_timechart(int argc, const char **argv,
1272                   const char *prefix __maybe_unused)
1273 {
1274         struct timechart tchart = {
1275                 .tool = {
1276                         .comm            = process_comm_event,
1277                         .fork            = process_fork_event,
1278                         .exit            = process_exit_event,
1279                         .sample          = process_sample_event,
1280                         .ordered_samples = true,
1281                 },
1282                 .proc_num = 15,
1283         };
1284         const char *output_name = "output.svg";
1285         const struct option timechart_options[] = {
1286         OPT_STRING('i', "input", &input_name, "file", "input file name"),
1287         OPT_STRING('o', "output", &output_name, "file", "output file name"),
1288         OPT_INTEGER('w', "width", &svg_page_width, "page width"),
1289         OPT_CALLBACK(0, "highlight", NULL, "duration or task name",
1290                       "highlight tasks. Pass duration in ns or process name.",
1291                        parse_highlight),
1292         OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
1293         OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
1294                     "output processes data only"),
1295         OPT_CALLBACK('p', "process", NULL, "process",
1296                       "process selector. Pass a pid or process name.",
1297                        parse_process),
1298         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1299                     "Look for files with symbols relative to this directory"),
1300         OPT_INTEGER('n', "proc-num", &tchart.proc_num,
1301                     "min. number of tasks to print"),
1302         OPT_BOOLEAN('t', "topology", &tchart.topology,
1303                     "sort CPUs according to topology"),
1304         OPT_END()
1305         };
1306         const char * const timechart_usage[] = {
1307                 "perf timechart [<options>] {record}",
1308                 NULL
1309         };
1310
1311         const struct option record_options[] = {
1312         OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
1313         OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
1314                     "output processes data only"),
1315         OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
1316         OPT_END()
1317         };
1318         const char * const record_usage[] = {
1319                 "perf timechart record [<options>]",
1320                 NULL
1321         };
1322         argc = parse_options(argc, argv, timechart_options, timechart_usage,
1323                         PARSE_OPT_STOP_AT_NON_OPTION);
1324
1325         if (tchart.power_only && tchart.tasks_only) {
1326                 pr_err("-P and -T options cannot be used at the same time.\n");
1327                 return -1;
1328         }
1329
1330         symbol__init();
1331
1332         if (argc && !strncmp(argv[0], "rec", 3)) {
1333                 argc = parse_options(argc, argv, record_options, record_usage,
1334                                      PARSE_OPT_STOP_AT_NON_OPTION);
1335
1336                 if (tchart.power_only && tchart.tasks_only) {
1337                         pr_err("-P and -T options cannot be used at the same time.\n");
1338                         return -1;
1339                 }
1340
1341                 return timechart__record(&tchart, argc, argv);
1342         } else if (argc)
1343                 usage_with_options(timechart_usage, timechart_options);
1344
1345         setup_pager();
1346
1347         return __cmd_timechart(&tchart, output_name);
1348 }