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                 newtFormAddComponent(self->form, self->scale);
  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, char * const 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         newtFormAddComponent(form, listbox);
 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, yes, no, (char *)msg) == 1;
 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         newtFormAddComponent(form, tree);
 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                 self->form = NULL;
 402
 403         return self;
 404 }
 405
 406 static void hist_browser__delete(struct hist_browser *self)
 407 {
 408         newtFormDestroy(self->form);
 409         newtPopWindow();
 410         free(self);
 411 }
 412
 413 static int hist_browser__populate(struct hist_browser *self, struct rb_root *hists,
 414                                   u64 nr_hists, u64 session_total, const char *title)
 415 {
 416         int max_len = 0, idx, cols, rows;
 417         struct ui_progress *progress;
 418         struct rb_node *nd;
 419         u64 curr_hist = 0;
 420         char seq[] = ".";
 421         char str[256];
 422
 423         if (self->form) {
 424                 newtFormDestroy(self->form);
 425                 newtPopWindow();
 426         }
 427
 428         snprintf(str, sizeof(str), "Samples: %Ld                            ",
 429                  session_total);
 430         newtDrawRootText(0, 0, str);
 431
 432         newtGetScreenSize(NULL, &rows);
 433
 434         if (symbol_conf.use_callchain)
 435                 self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
 436                                                    NEWT_FLAG_SCROLL);
 437         else
 438                 self->tree = newtListbox(0, 0, rows - 5,
 439                                         (NEWT_FLAG_SCROLL |
 440                                          NEWT_FLAG_RETURNEXIT));
 441
 442         newtComponentAddCallback(self->tree, hist_browser__selection,
 443                                  &self->selection);
 444
 445         progress = ui_progress__new("Adding entries to the browser...", nr_hists);
 446         if (progress == NULL)
 447                 return -1;
 448
 449         idx = 0;
 450         for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
 451                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 452                 int len;
 453
 454                 if (h->filtered)
 455                         continue;
 456
 457                 len = hist_entry__append_browser(h, self->tree, session_total);
 458                 if (len > max_len)
 459                         max_len = len;
 460                 if (symbol_conf.use_callchain)
 461                         hist_entry__append_callchain_browser(h, self->tree,
 462                                                              session_total, idx++);
 463                 ++curr_hist;
 464                 if (curr_hist % 5)
 465                         ui_progress__update(progress, curr_hist);
 466         }
 467
 468         ui_progress__delete(progress);
 469
 470         newtGetScreenSize(&cols, &rows);
 471
 472         if (max_len > cols)
 473                 max_len = cols - 3;
 474
 475         if (!symbol_conf.use_callchain)
 476                 newtListboxSetWidth(self->tree, max_len);
 477
 478         newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
 479                            rows - 5, title);
 480         self->form = newt_form__new();
 481         if (self->form == NULL)
 482                 return -1;
 483
 484         newtFormAddHotKey(self->form, 'A');
 485         newtFormAddHotKey(self->form, 'a');
 486         newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
 487         newtFormAddComponents(self->form, self->tree, NULL);
 488         self->selection = newt__symbol_tree_get_current(self->tree);
 489
 490         return 0;
 491 }
 492
 493 enum hist_filter {
 494         HIST_FILTER__DSO,
 495         HIST_FILTER__THREAD,
 496 };
 497
 498 static u64 hists__filter_by_dso(struct rb_root *hists, const struct dso *dso,
 499                                 u64 *session_total)
 500 {
 501         struct rb_node *nd;
 502         u64 nr_hists = 0;
 503
 504         *session_total = 0;
 505
 506         for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
 507                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 508
 509                 if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
 510                         h->filtered |= (1 << HIST_FILTER__DSO);
 511                         continue;
 512                 }
 513                 h->filtered &= ~(1 << HIST_FILTER__DSO);
 514                 ++nr_hists;
 515                 *session_total += h->count;
 516         }
 517
 518         return nr_hists;
 519 }
 520
 521 static u64 hists__filter_by_thread(struct rb_root *hists, const struct thread *thread,
 522                                    u64 *session_total)
 523 {
 524         struct rb_node *nd;
 525         u64 nr_hists = 0;
 526
 527         *session_total = 0;
 528
 529         for (nd = rb_first(hists); nd; nd = rb_next(nd)) {
 530                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 531
 532                 if (thread != NULL && h->thread != thread) {
 533                         h->filtered |= (1 << HIST_FILTER__THREAD);
 534                         continue;
 535                 }
 536                 h->filtered &= ~(1 << HIST_FILTER__THREAD);
 537                 ++nr_hists;
 538                 *session_total += h->count;
 539         }
 540
 541         return nr_hists;
 542 }
 543
 544 static struct thread *hist_browser__selected_thread(struct hist_browser *self)
 545 {
 546         int *indexes;
 547
 548         if (!symbol_conf.use_callchain)
 549                 goto out;
 550
 551         indexes = newtCheckboxTreeFindItem(self->tree, (void *)self->selection);
 552         if (indexes) {
 553                 bool is_hist_entry = indexes[1] == NEWT_ARG_LAST;
 554                 free(indexes);
 555                 if (is_hist_entry)
 556                         goto out;
 557         }
 558         return NULL;
 559 out:
 560         return *(struct thread **)(self->selection + 1);
 561 }
 562
 563 static int hist_browser__title(char *bf, size_t size, const char *input_name,
 564                                const struct dso *dso, const struct thread *thread)
 565 {
 566         int printed = 0;
 567
 568         if (thread)
 569                 printed += snprintf(bf + printed, size - printed,
 570                                     "Thread: %s(%d)",
 571                                     (thread->comm_set ?  thread->comm : ""),
 572                                     thread->pid);
 573         if (dso)
 574                 printed += snprintf(bf + printed, size - printed,
 575                                     "%sDSO: %s", thread ? " " : "",
 576                                     dso->short_name);
 577         return printed ?: snprintf(bf, size, "Report: %s", input_name);
 578 }
 579
 580 int perf_session__browse_hists(struct rb_root *hists, u64 nr_hists,
 581                                u64 session_total, const char *helpline,
 582                                const char *input_name)
 583 {
 584         struct hist_browser *browser = hist_browser__new();
 585         const struct thread *thread_filter = NULL;
 586         const struct dso *dso_filter = NULL;
 587         struct newtExitStruct es;
 588         char msg[160];
 589         int err = -1;
 590
 591         if (browser == NULL)
 592                 return -1;
 593
 594         newtPushHelpLine(helpline);
 595
 596         hist_browser__title(msg, sizeof(msg), input_name,
 597                             dso_filter, thread_filter);
 598         if (hist_browser__populate(browser, hists, nr_hists, session_total, msg) < 0)
 599                 goto out;
 600
 601         while (1) {
 602                 const struct thread *thread;
 603                 const struct dso *dso;
 604                 char *options[16];
 605                 int nr_options = 0, choice = 0, i,
 606                     annotate = -2, zoom_dso = -2, zoom_thread = -2;
 607
 608                 newtFormRun(browser->form, &es);
 609                 if (es.reason == NEWT_EXIT_HOTKEY) {
 610                         if (toupper(es.u.key) == 'A')
 611                                 goto do_annotate;
 612                         if (es.u.key == NEWT_KEY_ESCAPE ||
 613                             toupper(es.u.key) == 'Q' ||
 614                             es.u.key == CTRL('c')) {
 615                                 if (dialog_yesno("Do you really want to exit?"))
 616                                         break;
 617                                 else
 618                                         continue;
 619                         }
 620                 }
 621
 622                 if (browser->selection->sym != NULL &&
 623                     asprintf(&options[nr_options], "Annotate %s",
 624                              browser->selection->sym->name) > 0)
 625                         annotate = nr_options++;
 626
 627                 thread = hist_browser__selected_thread(browser);
 628                 if (thread != NULL &&
 629                     asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
 630                              (thread_filter ? "out of" : "into"),
 631                              (thread->comm_set ? thread->comm : ""),
 632                              thread->pid) > 0)
 633                         zoom_thread = nr_options++;
 634
 635                 dso = browser->selection->map ? browser->selection->map->dso : NULL;
 636                 if (dso != NULL &&
 637                     asprintf(&options[nr_options], "Zoom %s %s DSO",
 638                              (dso_filter ? "out of" : "into"),
 639                              (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
 640                         zoom_dso = nr_options++;
 641
 642                 options[nr_options++] = (char *)"Exit";
 643
 644                 choice = popup_menu(nr_options, options);
 645
 646                 for (i = 0; i < nr_options - 1; ++i)
 647                         free(options[i]);
 648
 649                 if (choice == nr_options - 1)
 650                         break;
 651
 652                 if (choice == -1)
 653                         continue;
 654 do_annotate:
 655                 if (choice == annotate) {
 656                         if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
 657                                 newtPopHelpLine();
 658                                 newtPushHelpLine("No vmlinux file found, can't "
 659                                                  "annotate with just a "
 660                                                  "kallsyms file");
 661                                 continue;
 662                         }
 663                         map_symbol__annotate_browser(browser->selection, input_name);
 664                 } else if (choice == zoom_dso) {
 665                         if (dso_filter) {
 666                                 newtPopHelpLine();
 667                                 dso_filter = NULL;
 668                         } else {
 669                                 snprintf(msg, sizeof(msg),
 670                                          "To zoom out press -> + \"Zoom out of %s DSO\"",
 671                                          dso->kernel ? "the Kernel" : dso->short_name);
 672                                 newtPushHelpLine(msg);
 673                                 dso_filter = dso;
 674                         }
 675                         nr_hists = hists__filter_by_dso(hists, dso_filter, &session_total);
 676                         hist_browser__title(msg, sizeof(msg), input_name,
 677                                             dso_filter, thread_filter);
 678                         if (hist_browser__populate(browser, hists, nr_hists, session_total, msg) < 0)
 679                                 goto out;
 680                 } else if (choice == zoom_thread) {
 681                         if (thread_filter) {
 682                                 newtPopHelpLine();
 683                                 thread_filter = NULL;
 684                         } else {
 685                                 snprintf(msg, sizeof(msg),
 686                                          "To zoom out press -> + \"Zoom out of %s(%d) thread\"",
 687                                          (thread->comm_set ? thread->comm : ""),
 688                                          thread->pid);
 689                                 newtPushHelpLine(msg);
 690                                 thread_filter = thread;
 691                         }
 692                         nr_hists = hists__filter_by_thread(hists, thread_filter, &session_total);
 693                         hist_browser__title(msg, sizeof(msg), input_name,
 694                                             dso_filter, thread_filter);
 695                         if (hist_browser__populate(browser, hists, nr_hists, session_total, msg) < 0)
 696                                 goto out;
 697                 }
 698         }
 699         err = 0;
 700 out:
 701         hist_browser__delete(browser);
 702         return err;
 703 }
 704
 705 void setup_browser(void)
 706 {
 707         if (!isatty(1))
 708                 return;
 709
 710         use_browser = true;
 711         newtInit();
 712         newtCls();
 713         newtPushHelpLine(" ");
 714 }
 715
 716 void exit_browser(bool wait_for_ok)
 717 {
 718         if (use_browser) {
 719                 if (wait_for_ok) {
 720                         char title[] = "Fatal Error", ok[] = "Ok";
 721                         newtWinMessage(title, ok, browser__last_msg);
 722                 }
 723                 newtFinished();
 724         }
 725 }