tools/perf/ui/browser.c

   1 #include "../util.h"
   2 #include "../cache.h"
   3 #include "../../perf.h"
   4 #include "libslang.h"
   5 #include "ui.h"
   6 #include "util.h"
   7 #include <linux/compiler.h>
   8 #include <linux/list.h>
   9 #include <linux/rbtree.h>
  10 #include <stdlib.h>
  11 #include <sys/ttydefaults.h>
  12 #include "browser.h"
  13 #include "helpline.h"
  14 #include "keysyms.h"
  15 #include "../color.h"
  16
  17 static int ui_browser__percent_color(struct ui_browser *browser,
  18                                      double percent, bool current)
  19 {
  20         if (current && (!browser->use_navkeypressed || browser->navkeypressed))
  21                 return HE_COLORSET_SELECTED;
  22         if (percent >= MIN_RED)
  23                 return HE_COLORSET_TOP;
  24         if (percent >= MIN_GREEN)
  25                 return HE_COLORSET_MEDIUM;
  26         return HE_COLORSET_NORMAL;
  27 }
  28
  29 int ui_browser__set_color(struct ui_browser *browser, int color)
  30 {
  31         int ret = browser->current_color;
  32         browser->current_color = color;
  33         SLsmg_set_color(color);
  34         return ret;
  35 }
  36
  37 void ui_browser__set_percent_color(struct ui_browser *browser,
  38                                    double percent, bool current)
  39 {
  40          int color = ui_browser__percent_color(browser, percent, current);
  41          ui_browser__set_color(browser, color);
  42 }
  43
  44 void ui_browser__gotorc(struct ui_browser *browser, int y, int x)
  45 {
  46         SLsmg_gotorc(browser->y + y, browser->x + x);
  47 }
  48
  49 void ui_browser__write_nstring(struct ui_browser *browser __maybe_unused, const char *msg,
  50                                unsigned int width)
  51 {
  52         slsmg_write_nstring(msg, width);
  53 }
  54
  55 void ui_browser__printf(struct ui_browser *browser __maybe_unused, const char *fmt, ...)
  56 {
  57         va_list args;
  58
  59         va_start(args, fmt);
  60         slsmg_vprintf(fmt, args);
  61         va_end(args);
  62 }
  63
  64 static struct list_head *
  65 ui_browser__list_head_filter_entries(struct ui_browser *browser,
  66                                      struct list_head *pos)
  67 {
  68         do {
  69                 if (!browser->filter || !browser->filter(browser, pos))
  70                         return pos;
  71                 pos = pos->next;
  72         } while (pos != browser->entries);
  73
  74         return NULL;
  75 }
  76
  77 static struct list_head *
  78 ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
  79                                           struct list_head *pos)
  80 {
  81         do {
  82                 if (!browser->filter || !browser->filter(browser, pos))
  83                         return pos;
  84                 pos = pos->prev;
  85         } while (pos != browser->entries);
  86
  87         return NULL;
  88 }
  89
  90 void ui_browser__list_head_seek(struct ui_browser *browser, off_t offset, int whence)
  91 {
  92         struct list_head *head = browser->entries;
  93         struct list_head *pos;
  94
  95         if (browser->nr_entries == 0)
  96                 return;
  97
  98         switch (whence) {
  99         case SEEK_SET:
 100                 pos = ui_browser__list_head_filter_entries(browser, head->next);
 101                 break;
 102         case SEEK_CUR:
 103                 pos = browser->top;
 104                 break;
 105         case SEEK_END:
 106                 pos = ui_browser__list_head_filter_prev_entries(browser, head->prev);
 107                 break;
 108         default:
 109                 return;
 110         }
 111
 112         assert(pos != NULL);
 113
 114         if (offset > 0) {
 115                 while (offset-- != 0)
 116                         pos = ui_browser__list_head_filter_entries(browser, pos->next);
 117         } else {
 118                 while (offset++ != 0)
 119                         pos = ui_browser__list_head_filter_prev_entries(browser, pos->prev);
 120         }
 121
 122         browser->top = pos;
 123 }
 124
 125 void ui_browser__rb_tree_seek(struct ui_browser *browser, off_t offset, int whence)
 126 {
 127         struct rb_root *root = browser->entries;
 128         struct rb_node *nd;
 129
 130         switch (whence) {
 131         case SEEK_SET:
 132                 nd = rb_first(root);
 133                 break;
 134         case SEEK_CUR:
 135                 nd = browser->top;
 136                 break;
 137         case SEEK_END:
 138                 nd = rb_last(root);
 139                 break;
 140         default:
 141                 return;
 142         }
 143
 144         if (offset > 0) {
 145                 while (offset-- != 0)
 146                         nd = rb_next(nd);
 147         } else {
 148                 while (offset++ != 0)
 149                         nd = rb_prev(nd);
 150         }
 151
 152         browser->top = nd;
 153 }
 154
 155 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)
 156 {
 157         struct rb_node *nd;
 158         int row = 0;
 159
 160         if (browser->top == NULL)
 161                 browser->top = rb_first(browser->entries);
 162
 163         nd = browser->top;
 164
 165         while (nd != NULL) {
 166                 ui_browser__gotorc(browser, row, 0);
 167                 browser->write(browser, nd, row);
 168                 if (++row == browser->rows)
 169                         break;
 170                 nd = rb_next(nd);
 171         }
 172
 173         return row;
 174 }
 175
 176 bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)
 177 {
 178         return browser->top_idx + row == browser->index;
 179 }
 180
 181 void ui_browser__refresh_dimensions(struct ui_browser *browser)
 182 {
 183         browser->width = SLtt_Screen_Cols - 1;
 184         browser->height = browser->rows = SLtt_Screen_Rows - 2;
 185         browser->y = 1;
 186         browser->x = 0;
 187 }
 188
 189 void ui_browser__handle_resize(struct ui_browser *browser)
 190 {
 191         ui__refresh_dimensions(false);
 192         ui_browser__show(browser, browser->title, ui_helpline__current);
 193         ui_browser__refresh(browser);
 194 }
 195
 196 int ui_browser__warning(struct ui_browser *browser, int timeout,
 197                         const char *format, ...)
 198 {
 199         va_list args;
 200         char *text;
 201         int key = 0, err;
 202
 203         va_start(args, format);
 204         err = vasprintf(&text, format, args);
 205         va_end(args);
 206
 207         if (err < 0) {
 208                 va_start(args, format);
 209                 ui_helpline__vpush(format, args);
 210                 va_end(args);
 211         } else {
 212                 while ((key = ui__question_window("Warning!", text,
 213                                                    "Press any key...",
 214                                                    timeout)) == K_RESIZE)
 215                         ui_browser__handle_resize(browser);
 216                 free(text);
 217         }
 218
 219         return key;
 220 }
 221
 222 int ui_browser__help_window(struct ui_browser *browser, const char *text)
 223 {
 224         int key;
 225
 226         while ((key = ui__help_window(text)) == K_RESIZE)
 227                 ui_browser__handle_resize(browser);
 228
 229         return key;
 230 }
 231
 232 bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text)
 233 {
 234         int key;
 235
 236         while ((key = ui__dialog_yesno(text)) == K_RESIZE)
 237                 ui_browser__handle_resize(browser);
 238
 239         return key == K_ENTER || toupper(key) == 'Y';
 240 }
 241
 242 void ui_browser__reset_index(struct ui_browser *browser)
 243 {
 244         browser->index = browser->top_idx = 0;
 245         browser->seek(browser, 0, SEEK_SET);
 246 }
 247
 248 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
 249 {
 250         SLsmg_gotorc(0, 0);
 251         ui_browser__set_color(browser, HE_COLORSET_ROOT);
 252         ui_browser__write_nstring(browser, title, browser->width + 1);
 253 }
 254
 255 void ui_browser__show_title(struct ui_browser *browser, const char *title)
 256 {
 257         pthread_mutex_lock(&ui__lock);
 258         __ui_browser__show_title(browser, title);
 259         pthread_mutex_unlock(&ui__lock);
 260 }
 261
 262 int ui_browser__show(struct ui_browser *browser, const char *title,
 263                      const char *helpline, ...)
 264 {
 265         int err;
 266         va_list ap;
 267
 268         if (browser->refresh_dimensions == NULL)
 269                 browser->refresh_dimensions = ui_browser__refresh_dimensions;
 270
 271         browser->refresh_dimensions(browser);
 272
 273         pthread_mutex_lock(&ui__lock);
 274         __ui_browser__show_title(browser, title);
 275
 276         browser->title = title;
 277         zfree(&browser->helpline);
 278
 279         va_start(ap, helpline);
 280         err = vasprintf(&browser->helpline, helpline, ap);
 281         va_end(ap);
 282         if (err > 0)
 283                 ui_helpline__push(browser->helpline);
 284         pthread_mutex_unlock(&ui__lock);
 285         return err ? 0 : -1;
 286 }
 287
 288 void ui_browser__hide(struct ui_browser *browser)
 289 {
 290         pthread_mutex_lock(&ui__lock);
 291         ui_helpline__pop();
 292         zfree(&browser->helpline);
 293         pthread_mutex_unlock(&ui__lock);
 294 }
 295
 296 static void ui_browser__scrollbar_set(struct ui_browser *browser)
 297 {
 298         int height = browser->height, h = 0, pct = 0,
 299             col = browser->width,
 300             row = 0;
 301
 302         if (browser->nr_entries > 1) {
 303                 pct = ((browser->index * (browser->height - 1)) /
 304                        (browser->nr_entries - 1));
 305         }
 306
 307         SLsmg_set_char_set(1);
 308
 309         while (h < height) {
 310                 ui_browser__gotorc(browser, row++, col);
 311                 SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
 312                 ++h;
 313         }
 314
 315         SLsmg_set_char_set(0);
 316 }
 317
 318 static int __ui_browser__refresh(struct ui_browser *browser)
 319 {
 320         int row;
 321         int width = browser->width;
 322
 323         row = browser->refresh(browser);
 324         ui_browser__set_color(browser, HE_COLORSET_NORMAL);
 325
 326         if (!browser->use_navkeypressed || browser->navkeypressed)
 327                 ui_browser__scrollbar_set(browser);
 328         else
 329                 width += 1;
 330
 331         SLsmg_fill_region(browser->y + row, browser->x,
 332                           browser->height - row, width, ' ');
 333
 334         return 0;
 335 }
 336
 337 int ui_browser__refresh(struct ui_browser *browser)
 338 {
 339         pthread_mutex_lock(&ui__lock);
 340         __ui_browser__refresh(browser);
 341         pthread_mutex_unlock(&ui__lock);
 342
 343         return 0;
 344 }
 345
 346 /*
 347  * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
 348  * forget about any reference to any entry in the underlying data structure,
 349  * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
 350  * after an output_resort and hist decay.
 351  */
 352 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
 353 {
 354         off_t offset = nr_entries - browser->nr_entries;
 355
 356         browser->nr_entries = nr_entries;
 357
 358         if (offset < 0) {
 359                 if (browser->top_idx < (u64)-offset)
 360                         offset = -browser->top_idx;
 361
 362                 browser->index += offset;
 363                 browser->top_idx += offset;
 364         }
 365
 366         browser->top = NULL;
 367         browser->seek(browser, browser->top_idx, SEEK_SET);
 368 }
 369
 370 int ui_browser__run(struct ui_browser *browser, int delay_secs)
 371 {
 372         int err, key;
 373
 374         while (1) {
 375                 off_t offset;
 376
 377                 pthread_mutex_lock(&ui__lock);
 378                 err = __ui_browser__refresh(browser);
 379                 SLsmg_refresh();
 380                 pthread_mutex_unlock(&ui__lock);
 381                 if (err < 0)
 382                         break;
 383
 384                 key = ui__getch(delay_secs);
 385
 386                 if (key == K_RESIZE) {
 387                         ui__refresh_dimensions(false);
 388                         browser->refresh_dimensions(browser);
 389                         __ui_browser__show_title(browser, browser->title);
 390                         ui_helpline__puts(browser->helpline);
 391                         continue;
 392                 }
 393
 394                 if (browser->use_navkeypressed && !browser->navkeypressed) {
 395                         if (key == K_DOWN || key == K_UP ||
 396                             (browser->columns && (key == K_LEFT || key == K_RIGHT)) ||
 397                             key == K_PGDN || key == K_PGUP ||
 398                             key == K_HOME || key == K_END ||
 399                             key == ' ') {
 400                                 browser->navkeypressed = true;
 401                                 continue;
 402                         } else
 403                                 return key;
 404                 }
 405
 406                 switch (key) {
 407                 case K_DOWN:
 408                         if (browser->index == browser->nr_entries - 1)
 409                                 break;
 410                         ++browser->index;
 411                         if (browser->index == browser->top_idx + browser->rows) {
 412                                 ++browser->top_idx;
 413                                 browser->seek(browser, +1, SEEK_CUR);
 414                         }
 415                         break;
 416                 case K_UP:
 417                         if (browser->index == 0)
 418                                 break;
 419                         --browser->index;
 420                         if (browser->index < browser->top_idx) {
 421                                 --browser->top_idx;
 422                                 browser->seek(browser, -1, SEEK_CUR);
 423                         }
 424                         break;
 425                 case K_RIGHT:
 426                         if (!browser->columns)
 427                                 goto out;
 428                         if (browser->horiz_scroll < browser->columns - 1)
 429                                 ++browser->horiz_scroll;
 430                         break;
 431                 case K_LEFT:
 432                         if (!browser->columns)
 433                                 goto out;
 434                         if (browser->horiz_scroll != 0)
 435                                 --browser->horiz_scroll;
 436                         break;
 437                 case K_PGDN:
 438                 case ' ':
 439                         if (browser->top_idx + browser->rows > browser->nr_entries - 1)
 440                                 break;
 441
 442                         offset = browser->rows;
 443                         if (browser->index + offset > browser->nr_entries - 1)
 444                                 offset = browser->nr_entries - 1 - browser->index;
 445                         browser->index += offset;
 446                         browser->top_idx += offset;
 447                         browser->seek(browser, +offset, SEEK_CUR);
 448                         break;
 449                 case K_PGUP:
 450                         if (browser->top_idx == 0)
 451                                 break;
 452
 453                         if (browser->top_idx < browser->rows)
 454                                 offset = browser->top_idx;
 455                         else
 456                                 offset = browser->rows;
 457
 458                         browser->index -= offset;
 459                         browser->top_idx -= offset;
 460                         browser->seek(browser, -offset, SEEK_CUR);
 461                         break;
 462                 case K_HOME:
 463                         ui_browser__reset_index(browser);
 464                         break;
 465                 case K_END:
 466                         offset = browser->rows - 1;
 467                         if (offset >= browser->nr_entries)
 468                                 offset = browser->nr_entries - 1;
 469
 470                         browser->index = browser->nr_entries - 1;
 471                         browser->top_idx = browser->index - offset;
 472                         browser->seek(browser, -offset, SEEK_END);
 473                         break;
 474                 default:
 475                 out:
 476                         return key;
 477                 }
 478         }
 479         return -1;
 480 }
 481
 482 unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
 483 {
 484         struct list_head *pos;
 485         struct list_head *head = browser->entries;
 486         int row = 0;
 487
 488         if (browser->top == NULL || browser->top == browser->entries)
 489                 browser->top = ui_browser__list_head_filter_entries(browser, head->next);
 490
 491         pos = browser->top;
 492
 493         list_for_each_from(pos, head) {
 494                 if (!browser->filter || !browser->filter(browser, pos)) {
 495                         ui_browser__gotorc(browser, row, 0);
 496                         browser->write(browser, pos, row);
 497                         if (++row == browser->rows)
 498                                 break;
 499                 }
 500         }
 501
 502         return row;
 503 }
 504
 505 static struct ui_browser_colorset {
 506         const char *name, *fg, *bg;
 507         int colorset;
 508 } ui_browser__colorsets[] = {
 509         {
 510                 .colorset = HE_COLORSET_TOP,
 511                 .name     = "top",
 512                 .fg       = "red",
 513                 .bg       = "default",
 514         },
 515         {
 516                 .colorset = HE_COLORSET_MEDIUM,
 517                 .name     = "medium",
 518                 .fg       = "green",
 519                 .bg       = "default",
 520         },
 521         {
 522                 .colorset = HE_COLORSET_NORMAL,
 523                 .name     = "normal",
 524                 .fg       = "default",
 525                 .bg       = "default",
 526         },
 527         {
 528                 .colorset = HE_COLORSET_SELECTED,
 529                 .name     = "selected",
 530                 .fg       = "black",
 531                 .bg       = "yellow",
 532         },
 533         {
 534                 .colorset = HE_COLORSET_JUMP_ARROWS,
 535                 .name     = "jump_arrows",
 536                 .fg       = "blue",
 537                 .bg       = "default",
 538         },
 539         {
 540                 .colorset = HE_COLORSET_ADDR,
 541                 .name     = "addr",
 542                 .fg       = "magenta",
 543                 .bg       = "default",
 544         },
 545         {
 546                 .colorset = HE_COLORSET_ROOT,
 547                 .name     = "root",
 548                 .fg       = "white",
 549                 .bg       = "blue",
 550         },
 551         {
 552                 .name = NULL,
 553         }
 554 };
 555
 556
 557 static int ui_browser__color_config(const char *var, const char *value,
 558                                     void *data __maybe_unused)
 559 {
 560         char *fg = NULL, *bg;
 561         int i;
 562
 563         /* same dir for all commands */
 564         if (prefixcmp(var, "colors.") != 0)
 565                 return 0;
 566
 567         for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
 568                 const char *name = var + 7;
 569
 570                 if (strcmp(ui_browser__colorsets[i].name, name) != 0)
 571                         continue;
 572
 573                 fg = strdup(value);
 574                 if (fg == NULL)
 575                         break;
 576
 577                 bg = strchr(fg, ',');
 578                 if (bg == NULL)
 579                         break;
 580
 581                 *bg = '\0';
 582                 while (isspace(*++bg));
 583                 ui_browser__colorsets[i].bg = bg;
 584                 ui_browser__colorsets[i].fg = fg;
 585                 return 0;
 586         }
 587
 588         free(fg);
 589         return -1;
 590 }
 591
 592 void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence)
 593 {
 594         switch (whence) {
 595         case SEEK_SET:
 596                 browser->top = browser->entries;
 597                 break;
 598         case SEEK_CUR:
 599                 browser->top = browser->top + browser->top_idx + offset;
 600                 break;
 601         case SEEK_END:
 602                 browser->top = browser->top + browser->nr_entries - 1 + offset;
 603                 break;
 604         default:
 605                 return;
 606         }
 607 }
 608
 609 unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
 610 {
 611         unsigned int row = 0, idx = browser->top_idx;
 612         char **pos;
 613
 614         if (browser->top == NULL)
 615                 browser->top = browser->entries;
 616
 617         pos = (char **)browser->top;
 618         while (idx < browser->nr_entries) {
 619                 if (!browser->filter || !browser->filter(browser, *pos)) {
 620                         ui_browser__gotorc(browser, row, 0);
 621                         browser->write(browser, pos, row);
 622                         if (++row == browser->rows)
 623                                 break;
 624                 }
 625
 626                 ++idx;
 627                 ++pos;
 628         }
 629
 630         return row;
 631 }
 632
 633 void __ui_browser__vline(struct ui_browser *browser, unsigned int column,
 634                          u16 start, u16 end)
 635 {
 636         SLsmg_set_char_set(1);
 637         ui_browser__gotorc(browser, start, column);
 638         SLsmg_draw_vline(end - start + 1);
 639         SLsmg_set_char_set(0);
 640 }
 641
 642 void ui_browser__write_graph(struct ui_browser *browser __maybe_unused,
 643                              int graph)
 644 {
 645         SLsmg_set_char_set(1);
 646         SLsmg_write_char(graph);
 647         SLsmg_set_char_set(0);
 648 }
 649
 650 static void __ui_browser__line_arrow_up(struct ui_browser *browser,
 651                                         unsigned int column,
 652                                         u64 start, u64 end)
 653 {
 654         unsigned int row, end_row;
 655
 656         SLsmg_set_char_set(1);
 657
 658         if (start < browser->top_idx + browser->rows) {
 659                 row = start - browser->top_idx;
 660                 ui_browser__gotorc(browser, row, column);
 661                 SLsmg_write_char(SLSMG_LLCORN_CHAR);
 662                 ui_browser__gotorc(browser, row, column + 1);
 663                 SLsmg_draw_hline(2);
 664
 665                 if (row-- == 0)
 666                         goto out;
 667         } else
 668                 row = browser->rows - 1;
 669
 670         if (end > browser->top_idx)
 671                 end_row = end - browser->top_idx;
 672         else
 673                 end_row = 0;
 674
 675         ui_browser__gotorc(browser, end_row, column);
 676         SLsmg_draw_vline(row - end_row + 1);
 677
 678         ui_browser__gotorc(browser, end_row, column);
 679         if (end >= browser->top_idx) {
 680                 SLsmg_write_char(SLSMG_ULCORN_CHAR);
 681                 ui_browser__gotorc(browser, end_row, column + 1);
 682                 SLsmg_write_char(SLSMG_HLINE_CHAR);
 683                 ui_browser__gotorc(browser, end_row, column + 2);
 684                 SLsmg_write_char(SLSMG_RARROW_CHAR);
 685         }
 686 out:
 687         SLsmg_set_char_set(0);
 688 }
 689
 690 static void __ui_browser__line_arrow_down(struct ui_browser *browser,
 691                                           unsigned int column,
 692                                           u64 start, u64 end)
 693 {
 694         unsigned int row, end_row;
 695
 696         SLsmg_set_char_set(1);
 697
 698         if (start >= browser->top_idx) {
 699                 row = start - browser->top_idx;
 700                 ui_browser__gotorc(browser, row, column);
 701                 SLsmg_write_char(SLSMG_ULCORN_CHAR);
 702                 ui_browser__gotorc(browser, row, column + 1);
 703                 SLsmg_draw_hline(2);
 704
 705                 if (row++ == 0)
 706                         goto out;
 707         } else
 708                 row = 0;
 709
 710         if (end >= browser->top_idx + browser->rows)
 711                 end_row = browser->rows - 1;
 712         else
 713                 end_row = end - browser->top_idx;
 714
 715         ui_browser__gotorc(browser, row, column);
 716         SLsmg_draw_vline(end_row - row + 1);
 717
 718         ui_browser__gotorc(browser, end_row, column);
 719         if (end < browser->top_idx + browser->rows) {
 720                 SLsmg_write_char(SLSMG_LLCORN_CHAR);
 721                 ui_browser__gotorc(browser, end_row, column + 1);
 722                 SLsmg_write_char(SLSMG_HLINE_CHAR);
 723                 ui_browser__gotorc(browser, end_row, column + 2);
 724                 SLsmg_write_char(SLSMG_RARROW_CHAR);
 725         }
 726 out:
 727         SLsmg_set_char_set(0);
 728 }
 729
 730 void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
 731                               u64 start, u64 end)
 732 {
 733         if (start > end)
 734                 __ui_browser__line_arrow_up(browser, column, start, end);
 735         else
 736                 __ui_browser__line_arrow_down(browser, column, start, end);
 737 }
 738
 739 void ui_browser__init(void)
 740 {
 741         int i = 0;
 742
 743         perf_config(ui_browser__color_config, NULL);
 744
 745         while (ui_browser__colorsets[i].name) {
 746                 struct ui_browser_colorset *c = &ui_browser__colorsets[i++];
 747                 sltt_set_color(c->colorset, c->name, c->fg, c->bg);
 748         }
 749
 750         annotate_browser__init();
 751 }