tools/perf/util/newt.c

   1 #define _GNU_SOURCE
   2 #include <stdio.h>
   3 #undef _GNU_SOURCE
   4
   5 #include <stdlib.h>
   6 #include <newt.h>
   7 #include <sys/ttydefaults.h>
   8
   9 #include "cache.h"
  10 #include "hist.h"
  11 #include "session.h"
  12 #include "sort.h"
  13 #include "symbol.h"
  14
  15 struct ui_progress {
  16         newtComponent form, scale;
  17 };
  18
  19 struct ui_progress *ui_progress__new(const char *title, u64 total)
  20 {
  21         struct ui_progress *self = malloc(sizeof(*self));
  22
  23         if (self != NULL) {
  24                 int cols;
  25                 newtGetScreenSize(&cols, NULL);
  26                 cols -= 4;
  27                 newtCenteredWindow(cols, 1, title);
  28                 self->form  = newtForm(NULL, NULL, 0);
  29                 if (self->form == NULL)
  30                         goto out_free_self;
  31                 self->scale = newtScale(0, 0, cols, total);
  32                 if (self->scale == NULL)
  33                         goto out_free_form;
  34                 newtFormAddComponents(self->form, self->scale, NULL);
  35                 newtRefresh();
  36         }
  37
  38         return self;
  39
  40 out_free_form:
  41         newtFormDestroy(self->form);
  42 out_free_self:
  43         free(self);
  44         return NULL;
  45 }
  46
  47 void ui_progress__update(struct ui_progress *self, u64 curr)
  48 {
  49         newtScaleSet(self->scale, curr);
  50         newtRefresh();
  51 }
  52
  53 void ui_progress__delete(struct ui_progress *self)
  54 {
  55         newtFormDestroy(self->form);
  56         newtPopWindow();
  57         free(self);
  58 }
  59
  60 static char browser__last_msg[1024];
  61
  62 int browser__show_help(const char *format, va_list ap)
  63 {
  64         int ret;
  65         static int backlog;
  66
  67         ret = vsnprintf(browser__last_msg + backlog,
  68                         sizeof(browser__last_msg) - backlog, format, ap);
  69         backlog += ret;
  70
  71         if (browser__last_msg[backlog - 1] == '\n') {
  72                 newtPopHelpLine();
  73                 newtPushHelpLine(browser__last_msg);
  74                 newtRefresh();
  75                 backlog = 0;
  76         }
  77
  78         return ret;
  79 }
  80
  81 static void newt_form__set_exit_keys(newtComponent self)
  82 {
  83         newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
  84         newtFormAddHotKey(self, 'Q');
  85         newtFormAddHotKey(self, 'q');
  86         newtFormAddHotKey(self, CTRL('c'));
  87 }
  88
  89 static newtComponent newt_form__new(void)
  90 {
  91         newtComponent self = newtForm(NULL, NULL, 0);
  92         if (self)
  93                 newt_form__set_exit_keys(self);
  94         return self;
  95 }
  96
  97 static int popup_menu(int argc, const char *argv[])
  98 {
  99         struct newtExitStruct es;
 100         int i, rc = -1, max_len = 5;
 101         newtComponent listbox, form = newt_form__new();
 102
 103         if (form == NULL)
 104                 return -1;
 105
 106         listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
 107         if (listbox == NULL)
 108                 goto out_destroy_form;
 109
 110         newtFormAddComponents(form, listbox, NULL);
 111
 112         for (i = 0; i < argc; ++i) {
 113                 int len = strlen(argv[i]);
 114                 if (len > max_len)
 115                         max_len = len;
 116                 if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
 117                         goto out_destroy_form;
 118         }
 119
 120         newtCenteredWindow(max_len, argc, NULL);
 121         newtFormRun(form, &es);
 122         rc = newtListboxGetCurrent(listbox) - NULL;
 123         if (es.reason == NEWT_EXIT_HOTKEY)
 124                 rc = -1;
 125         newtPopWindow();
 126 out_destroy_form:
 127         newtFormDestroy(form);
 128         return rc;
 129 }
 130
 131 static bool dialog_yesno(const char *msg)
 132 {
 133         /* newtWinChoice should really be accepting const char pointers... */
 134         char yes[] = "Yes", no[] = "No";
 135         return newtWinChoice(NULL, no, yes, (char *)msg) == 2;
 136 }
 137
 138 /*
 139  * When debugging newt problems it was useful to be able to "unroll"
 140  * the calls to newtCheckBoxTreeAdd{Array,Item}, so that we can generate
 141  * a source file with the sequence of calls to these methods, to then
 142  * tweak the arrays to get the intended results, so I'm keeping this code
 143  * here, may be useful again in the future.
 144  */
 145 #undef NEWT_DEBUG
 146
 147 static void newt_checkbox_tree__add(newtComponent tree, const char *str,
 148                                     void *priv, int *indexes)
 149 {
 150 #ifdef NEWT_DEBUG
 151         /* Print the newtCheckboxTreeAddArray to tinker with its index arrays */
 152         int i = 0, len = 40 - strlen(str);
 153
 154         fprintf(stderr,
 155                 "\tnewtCheckboxTreeAddItem(tree, %*.*s\"%s\", (void *)%p, 0, ",
 156                 len, len, " ", str, priv);
 157         while (indexes[i] != NEWT_ARG_LAST) {
 158                 if (indexes[i] != NEWT_ARG_APPEND)
 159                         fprintf(stderr, " %d,", indexes[i]);
 160                 else
 161                         fprintf(stderr, " %s,", "NEWT_ARG_APPEND");
 162                 ++i;
 163         }
 164         fprintf(stderr, " %s", " NEWT_ARG_LAST);\n");
 165         fflush(stderr);
 166 #endif
 167         newtCheckboxTreeAddArray(tree, str, priv, 0, indexes);
 168 }
 169
 170 static char *callchain_list__sym_name(struct callchain_list *self,
 171                                       char *bf, size_t bfsize)
 172 {
 173         if (self->ms.sym)
 174                 return self->ms.sym->name;
 175
 176         snprintf(bf, bfsize, "%#Lx", self->ip);
 177         return bf;
 178 }
 179
 180 static void __callchain__append_graph_browser(struct callchain_node *self,
 181                                               newtComponent tree, u64 total,
 182                                               int *indexes, int depth)
 183 {
 184         struct rb_node *node;
 185         u64 new_total, remaining;
 186         int idx = 0;
 187
 188         if (callchain_param.mode == CHAIN_GRAPH_REL)
 189                 new_total = self->children_hit;
 190         else
 191                 new_total = total;
 192
 193         remaining = new_total;
 194         node = rb_first(&self->rb_root);
 195         while (node) {
 196                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 197                 struct rb_node *next = rb_next(node);
 198                 u64 cumul = cumul_hits(child);
 199                 struct callchain_list *chain;
 200                 int first = true, printed = 0;
 201                 int chain_idx = -1;
 202                 remaining -= cumul;
 203
 204                 indexes[depth] = NEWT_ARG_APPEND;
 205                 indexes[depth + 1] = NEWT_ARG_LAST;
 206
 207                 list_for_each_entry(chain, &child->val, list) {
 208                         char ipstr[BITS_PER_LONG / 4 + 1],
 209                              *alloc_str = NULL;
 210                         const char *str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
 211
 212                         if (first) {
 213                                 double percent = cumul * 100.0 / new_total;
 214
 215                                 first = false;
 216                                 if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
 217                                         str = "Not enough memory!";
 218                                 else
 219                                         str = alloc_str;
 220                         } else {
 221                                 indexes[depth] = idx;
 222                                 indexes[depth + 1] = NEWT_ARG_APPEND;
 223                                 indexes[depth + 2] = NEWT_ARG_LAST;
 224                                 ++chain_idx;
 225                         }
 226                         newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
 227                         free(alloc_str);
 228                         ++printed;
 229                 }
 230
 231                 indexes[depth] = idx;
 232                 if (chain_idx != -1)
 233                         indexes[depth + 1] = chain_idx;
 234                 if (printed != 0)
 235                         ++idx;
 236                 __callchain__append_graph_browser(child, tree, new_total, indexes,
 237                                                   depth + (chain_idx != -1 ? 2 : 1));
 238                 node = next;
 239         }
 240 }
 241
 242 static void callchain__append_graph_browser(struct callchain_node *self,
 243                                             newtComponent tree, u64 total,
 244                                             int *indexes, int parent_idx)
 245 {
 246         struct callchain_list *chain;
 247         int i = 0;
 248
 249         indexes[1] = NEWT_ARG_APPEND;
 250         indexes[2] = NEWT_ARG_LAST;
 251
 252         list_for_each_entry(chain, &self->val, list) {
 253                 char ipstr[BITS_PER_LONG / 4 + 1], *str;
 254
 255                 if (chain->ip >= PERF_CONTEXT_MAX)
 256                         continue;
 257
 258                 if (!i++ && sort__first_dimension == SORT_SYM)
 259                         continue;
 260
 261                 str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
 262                 newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
 263         }
 264
 265         indexes[1] = parent_idx;
 266         indexes[2] = NEWT_ARG_APPEND;
 267         indexes[3] = NEWT_ARG_LAST;
 268         __callchain__append_graph_browser(self, tree, total, indexes, 2);
 269 }
 270
 271 static void hist_entry__append_callchain_browser(struct hist_entry *self,
 272                                                  newtComponent tree, u64 total, int parent_idx)
 273 {
 274         struct rb_node *rb_node;
 275         int indexes[1024] = { [0] = parent_idx, };
 276         int idx = 0;
 277         struct callchain_node *chain;
 278
 279         rb_node = rb_first(&self->sorted_chain);
 280         while (rb_node) {
 281                 chain = rb_entry(rb_node, struct callchain_node, rb_node);
 282                 switch (callchain_param.mode) {
 283                 case CHAIN_FLAT:
 284                         break;
 285                 case CHAIN_GRAPH_ABS: /* falldown */
 286                 case CHAIN_GRAPH_REL:
 287                         callchain__append_graph_browser(chain, tree, total, indexes, idx++);
 288                         break;
 289                 case CHAIN_NONE:
 290                 default:
 291                         break;
 292                 }
 293                 rb_node = rb_next(rb_node);
 294         }
 295 }
 296
 297 static size_t hist_entry__append_browser(struct hist_entry *self,
 298                                          newtComponent tree, u64 total)
 299 {
 300         char s[256];
 301         size_t ret;
 302
 303         if (symbol_conf.exclude_other && !self->parent)
 304                 return 0;
 305
 306         ret = hist_entry__snprintf(self, s, sizeof(s), NULL,
 307                                    false, 0, false, total);
 308         if (symbol_conf.use_callchain) {
 309                 int indexes[2];
 310
 311                 indexes[0] = NEWT_ARG_APPEND;
 312                 indexes[1] = NEWT_ARG_LAST;
 313                 newt_checkbox_tree__add(tree, s, &self->ms, indexes);
 314         } else
 315                 newtListboxAppendEntry(tree, s, &self->ms);
 316
 317         return ret;
 318 }
 319
 320 static void map_symbol__annotate_browser(const struct map_symbol *self,
 321                                          const char *input_name)
 322 {
 323         FILE *fp;
 324         int cols, rows;
 325         newtComponent form, tree;
 326         struct newtExitStruct es;
 327         char *str;
 328         size_t line_len, max_line_len = 0;
 329         size_t max_usable_width;
 330         char *line = NULL;
 331
 332         if (self->sym == NULL)
 333                 return;
 334
 335         if (asprintf(&str, "perf annotate -i \"%s\" -d \"%s\" %s 2>&1 | expand",
 336                      input_name, self->map->dso->name, self->sym->name) < 0)
 337                 return;
 338
 339         fp = popen(str, "r");
 340         if (fp == NULL)
 341                 goto out_free_str;
 342
 343         newtPushHelpLine("Press ESC to exit");
 344         newtGetScreenSize(&cols, &rows);
 345         tree = newtListbox(0, 0, rows - 5, NEWT_FLAG_SCROLL);
 346
 347         while (!feof(fp)) {
 348                 if (getline(&line, &line_len, fp) < 0 || !line_len)
 349                         break;
 350                 while (line_len != 0 && isspace(line[line_len - 1]))
 351                         line[--line_len] = '\0';
 352
 353                 if (line_len > max_line_len)
 354                         max_line_len = line_len;
 355                 newtListboxAppendEntry(tree, line, NULL);
 356         }
 357         fclose(fp);
 358         free(line);
 359
 360         max_usable_width = cols - 22;
 361         if (max_line_len > max_usable_width)
 362                 max_line_len = max_usable_width;
 363
 364         newtListboxSetWidth(tree, max_line_len);
 365
 366         newtCenteredWindow(max_line_len + 2, rows - 5, self->sym->name);
 367         form = newt_form__new();
 368         newtFormAddComponents(form, tree, NULL);
 369
 370         newtFormRun(form, &es);
 371         newtFormDestroy(form);
 372         newtPopWindow();
 373         newtPopHelpLine();
 374 out_free_str:
 375         free(str);
 376 }
 377
 378 static const void *newt__symbol_tree_get_current(newtComponent self)
 379 {
 380         if (symbol_conf.use_callchain)
 381                 return newtCheckboxTreeGetCurrent(self);
 382         return newtListboxGetCurrent(self);
 383 }
 384
 385 static void hist_browser__selection(newtComponent self, void *data)
 386 {
 387         const struct map_symbol **symbol_ptr = data;
 388         *symbol_ptr = newt__symbol_tree_get_current(self);
 389 }
 390
 391 struct hist_browser {
 392         newtComponent           form, tree;
 393         const struct map_symbol *selection;
 394 };
 395
 396 static struct hist_browser *hist_browser__new(void)
 397 {
 398         struct hist_browser *self = malloc(sizeof(*self));
 399
 400         if (self != NULL) {
 401                 char seq[] = ".";
 402                 int rows;
 403
 404                 newtGetScreenSize(NULL, &rows);
 405
 406                 if (symbol_conf.use_callchain)
 407                         self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
 408                                                            NEWT_FLAG_SCROLL);
 409                 else
 410                         self->tree = newtListbox(0, 0, rows - 5,
 411                                                 (NEWT_FLAG_SCROLL |
 412                                                  NEWT_FLAG_RETURNEXIT));
 413                 newtComponentAddCallback(self->tree, hist_browser__selection,
 414                                          &self->selection);
 415         }
 416
 417         return self;
 418 }
 419
 420 static void hist_browser__delete(struct hist_browser *self)
 421 {
 422         newtFormDestroy(self->form);
 423         newtPopWindow();
 424         free(self);
 425 }
 426
 427 static int hist_browser__populate(struct hist_browser *self, struct rb_root *hists,
 428                                   u64 nr_hists, u64 session_total)
 429 {
 430         int max_len = 0, idx, cols, rows;
 431         struct ui_progress *progress;
 432         struct rb_node *nd;
 433         u64 curr_hist = 0;
 434
 435         progress = ui_progress__new("Adding entries to the browser...", nr_hists);
 436         if (progress == NULL)
 437                 return -1;
 438
 439         idx = 0;
 440         for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
 441                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 442                 int len = hist_entry__append_browser(h, self->tree, session_total);
 443                 if (len > max_len)
 444                         max_len = len;
 445                 if (symbol_conf.use_callchain)
 446                         hist_entry__append_callchain_browser(h, self->tree,
 447                                                              session_total, idx++);
 448                 ++curr_hist;
 449                 if (curr_hist % 5)
 450                         ui_progress__update(progress, curr_hist);
 451         }
 452
 453         ui_progress__delete(progress);
 454
 455         newtGetScreenSize(&cols, &rows);
 456
 457         if (max_len > cols)
 458                 max_len = cols - 3;
 459
 460         if (!symbol_conf.use_callchain)
 461                 newtListboxSetWidth(self->tree, max_len);
 462
 463         newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
 464                            rows - 5, "Report");
 465         self->form = newt_form__new();
 466         newtFormAddHotKey(self->form, 'A');
 467         newtFormAddHotKey(self->form, 'a');
 468         newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
 469         newtFormAddComponents(self->form, self->tree, NULL);
 470         self->selection = newt__symbol_tree_get_current(self->tree);
 471
 472         return 0;
 473 }
 474
 475 int perf_session__browse_hists(struct rb_root *hists, u64 nr_hists,
 476                                u64 session_total, const char *helpline,
 477                                const char *input_name)
 478 {
 479         struct newtExitStruct es;
 480         char str[1024];
 481         int err = -1;
 482         struct hist_browser *browser = hist_browser__new();
 483
 484         if (browser == NULL)
 485                 return -1;
 486
 487         snprintf(str, sizeof(str), "Samples: %Ld", session_total);
 488         newtDrawRootText(0, 0, str);
 489         newtPushHelpLine(helpline);
 490
 491         if (hist_browser__populate(browser, hists, nr_hists, session_total) < 0)
 492                 goto out;
 493
 494         while (1) {
 495                 char annotate[512];
 496                 const char *options[2];
 497                 int nr_options = 0, choice = 0;
 498
 499                 newtFormRun(browser->form, &es);
 500                 if (es.reason == NEWT_EXIT_HOTKEY) {
 501                         if (toupper(es.u.key) == 'A')
 502                                 goto do_annotate;
 503                         if (es.u.key == NEWT_KEY_ESCAPE ||
 504                             toupper(es.u.key) == 'Q' ||
 505                             es.u.key == CTRL('c')) {
 506                                 if (dialog_yesno("Do you really want to exit?"))
 507                                         break;
 508                                 else
 509                                         continue;
 510                         }
 511                 }
 512
 513                 if (browser->selection->sym != NULL) {
 514                         snprintf(annotate, sizeof(annotate),
 515                                  "Annotate %s", browser->selection->sym->name);
 516                         options[nr_options++] = annotate;
 517                 }
 518
 519                 options[nr_options++] = "Exit";
 520                 choice = popup_menu(nr_options, options);
 521                 if (choice == nr_options - 1)
 522                         break;
 523 do_annotate:
 524                 if (browser->selection->sym != NULL && choice >= 0) {
 525                         if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
 526                                 newtPopHelpLine();
 527                                 newtPushHelpLine("No vmlinux file found, can't "
 528                                                  "annotate with just a "
 529                                                  "kallsyms file");
 530                                 continue;
 531                         }
 532                         map_symbol__annotate_browser(browser->selection,
 533                                                      input_name);
 534                 }
 535         }
 536         err = 0;
 537 out:
 538         hist_browser__delete(browser);
 539         return err;
 540 }
 541
 542 void setup_browser(void)
 543 {
 544         if (!isatty(1))
 545                 return;
 546
 547         use_browser = true;
 548         newtInit();
 549         newtCls();
 550         newtPushHelpLine(" ");
 551 }
 552
 553 void exit_browser(bool wait_for_ok)
 554 {
 555         if (use_browser) {
 556                 if (wait_for_ok) {
 557                         char title[] = "Fatal Error", ok[] = "Ok";
 558                         newtWinMessage(title, ok, browser__last_msg);
 559                 }
 560                 newtFinished();
 561         }
 562 }