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