tools/perf/builtin-timechart.c

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