perf TUI: Show filters on the title and add help line about how to zoom out
[linux-2.6.git] / 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, 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         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                 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 }