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