Loading...
1// SPDX-License-Identifier: GPL-2.0
2#include <errno.h>
3#include <signal.h>
4#include <stdbool.h>
5#include <linux/kernel.h>
6#ifdef HAVE_BACKTRACE_SUPPORT
7#include <execinfo.h>
8#endif
9
10#include "../../util/cache.h"
11#include "../../util/debug.h"
12#include "../../util/util.h"
13#include "../browser.h"
14#include "../helpline.h"
15#include "../ui.h"
16#include "../util.h"
17#include "../libslang.h"
18#include "../keysyms.h"
19#include "tui.h"
20
21static volatile int ui__need_resize;
22
23extern struct perf_error_ops perf_tui_eops;
24extern bool tui_helpline__set;
25
26extern void hist_browser__init_hpp(void);
27
28void ui__refresh_dimensions(bool force)
29{
30 if (force || ui__need_resize) {
31 ui__need_resize = 0;
32 pthread_mutex_lock(&ui__lock);
33 SLtt_get_screen_size();
34 SLsmg_reinit_smg();
35 pthread_mutex_unlock(&ui__lock);
36 }
37}
38
39static void ui__sigwinch(int sig __maybe_unused)
40{
41 ui__need_resize = 1;
42}
43
44static void ui__setup_sigwinch(void)
45{
46 static bool done;
47
48 if (done)
49 return;
50
51 done = true;
52 pthread__unblock_sigwinch();
53 signal(SIGWINCH, ui__sigwinch);
54}
55
56int ui__getch(int delay_secs)
57{
58 struct timeval timeout, *ptimeout = delay_secs ? &timeout : NULL;
59 fd_set read_set;
60 int err, key;
61
62 ui__setup_sigwinch();
63
64 FD_ZERO(&read_set);
65 FD_SET(0, &read_set);
66
67 if (delay_secs) {
68 timeout.tv_sec = delay_secs;
69 timeout.tv_usec = 0;
70 }
71
72 err = select(1, &read_set, NULL, NULL, ptimeout);
73
74 if (err == 0)
75 return K_TIMER;
76
77 if (err == -1) {
78 if (errno == EINTR)
79 return K_RESIZE;
80 return K_ERROR;
81 }
82
83 key = SLang_getkey();
84 if (key != K_ESC)
85 return key;
86
87 FD_ZERO(&read_set);
88 FD_SET(0, &read_set);
89 timeout.tv_sec = 0;
90 timeout.tv_usec = 20;
91 err = select(1, &read_set, NULL, NULL, &timeout);
92 if (err == 0)
93 return K_ESC;
94
95 SLang_ungetkey(key);
96 return SLkp_getkey();
97}
98
99#ifdef HAVE_BACKTRACE_SUPPORT
100static void ui__signal_backtrace(int sig)
101{
102 void *stackdump[32];
103 size_t size;
104
105 ui__exit(false);
106 psignal(sig, "perf");
107
108 printf("-------- backtrace --------\n");
109 size = backtrace(stackdump, ARRAY_SIZE(stackdump));
110 backtrace_symbols_fd(stackdump, size, STDOUT_FILENO);
111
112 exit(0);
113}
114#else
115# define ui__signal_backtrace ui__signal
116#endif
117
118static void ui__signal(int sig)
119{
120 ui__exit(false);
121 psignal(sig, "perf");
122 exit(0);
123}
124
125int ui__init(void)
126{
127 int err;
128
129 SLutf8_enable(-1);
130 SLtt_get_terminfo();
131 SLtt_get_screen_size();
132
133 err = SLsmg_init_smg();
134 if (err < 0)
135 goto out;
136 err = SLang_init_tty(-1, 0, 0);
137 if (err < 0)
138 goto out;
139
140 err = SLkp_init();
141 if (err < 0) {
142 pr_err("TUI initialization failed.\n");
143 goto out;
144 }
145
146 SLkp_define_keysym((char *)"^(kB)", SL_KEY_UNTAB);
147
148 signal(SIGSEGV, ui__signal_backtrace);
149 signal(SIGFPE, ui__signal_backtrace);
150 signal(SIGINT, ui__signal);
151 signal(SIGQUIT, ui__signal);
152 signal(SIGTERM, ui__signal);
153
154 perf_error__register(&perf_tui_eops);
155
156 ui_helpline__init();
157 ui_browser__init();
158 tui_progress__init();
159
160 hist_browser__init_hpp();
161out:
162 return err;
163}
164
165void ui__exit(bool wait_for_ok)
166{
167 if (wait_for_ok && tui_helpline__set)
168 ui__question_window("Fatal Error",
169 ui_helpline__last_msg,
170 "Press any key...", 0);
171
172 SLtt_set_cursor_visibility(1);
173 SLsmg_refresh();
174 SLsmg_reset_smg();
175 SLang_reset_tty();
176
177 perf_error__unregister(&perf_tui_eops);
178}
1#include <errno.h>
2#include <signal.h>
3#include <stdbool.h>
4#include <stdlib.h>
5#include <termios.h>
6#include <unistd.h>
7#include <linux/kernel.h>
8#ifdef HAVE_BACKTRACE_SUPPORT
9#include <execinfo.h>
10#endif
11
12#include "../../util/color.h"
13#include "../../util/debug.h"
14#include "../browser.h"
15#include "../helpline.h"
16#include "../ui.h"
17#include "../util.h"
18#include "../libslang.h"
19#include "../keysyms.h"
20#include "tui.h"
21
22static volatile int ui__need_resize;
23
24extern struct perf_error_ops perf_tui_eops;
25extern bool tui_helpline__set;
26
27extern void hist_browser__init_hpp(void);
28
29void ui__refresh_dimensions(bool force)
30{
31 if (force || ui__need_resize) {
32 ui__need_resize = 0;
33 mutex_lock(&ui__lock);
34 SLtt_get_screen_size();
35 SLsmg_reinit_smg();
36 mutex_unlock(&ui__lock);
37 }
38}
39
40static void ui__sigwinch(int sig __maybe_unused)
41{
42 ui__need_resize = 1;
43}
44
45static void ui__setup_sigwinch(void)
46{
47 static bool done;
48
49 if (done)
50 return;
51
52 done = true;
53 pthread__unblock_sigwinch();
54 signal(SIGWINCH, ui__sigwinch);
55}
56
57int ui__getch(int delay_secs)
58{
59 struct timeval timeout, *ptimeout = delay_secs ? &timeout : NULL;
60 fd_set read_set;
61 int err, key;
62
63 ui__setup_sigwinch();
64
65 FD_ZERO(&read_set);
66 FD_SET(0, &read_set);
67
68 if (delay_secs) {
69 timeout.tv_sec = delay_secs;
70 timeout.tv_usec = 0;
71 }
72
73 err = select(1, &read_set, NULL, NULL, ptimeout);
74
75 if (err == 0)
76 return K_TIMER;
77
78 if (err == -1) {
79 if (errno == EINTR)
80 return K_RESIZE;
81 return K_ERROR;
82 }
83
84 key = SLang_getkey();
85 if (key != K_ESC)
86 return key;
87
88 FD_ZERO(&read_set);
89 FD_SET(0, &read_set);
90 timeout.tv_sec = 0;
91 timeout.tv_usec = 20;
92 err = select(1, &read_set, NULL, NULL, &timeout);
93 if (err == 0)
94 return K_ESC;
95
96 SLang_ungetkey(key);
97 return SLkp_getkey();
98}
99
100#ifdef HAVE_BACKTRACE_SUPPORT
101static void ui__signal_backtrace(int sig)
102{
103 void *stackdump[32];
104 size_t size;
105
106 ui__exit(false);
107 psignal(sig, "perf");
108
109 printf("-------- backtrace --------\n");
110 size = backtrace(stackdump, ARRAY_SIZE(stackdump));
111 backtrace_symbols_fd(stackdump, size, STDOUT_FILENO);
112
113 exit(0);
114}
115#else
116# define ui__signal_backtrace ui__signal
117#endif
118
119static void ui__signal(int sig)
120{
121 ui__exit(false);
122 psignal(sig, "perf");
123 exit(0);
124}
125
126static void ui__sigcont(int sig)
127{
128 static struct termios tty;
129
130 if (sig == SIGTSTP) {
131 while (tcgetattr(SLang_TT_Read_FD, &tty) == -1 && errno == EINTR)
132 ;
133 while (write(SLang_TT_Read_FD, PERF_COLOR_RESET, sizeof(PERF_COLOR_RESET) - 1) == -1 && errno == EINTR)
134 ;
135 raise(SIGSTOP);
136 } else {
137 while (tcsetattr(SLang_TT_Read_FD, TCSADRAIN, &tty) == -1 && errno == EINTR)
138 ;
139 raise(SIGWINCH);
140 }
141}
142
143int ui__init(void)
144{
145 int err;
146
147 SLutf8_enable(-1);
148 SLtt_get_terminfo();
149 SLtt_get_screen_size();
150
151 err = SLsmg_init_smg();
152 if (err < 0)
153 goto out;
154 err = SLang_init_tty(-1, 0, 0);
155 if (err < 0)
156 goto out;
157 SLtty_set_suspend_state(true);
158
159 err = SLkp_init();
160 if (err < 0) {
161 pr_err("TUI initialization failed.\n");
162 goto out;
163 }
164
165 SLkp_define_keysym("^(kB)", SL_KEY_UNTAB);
166
167 signal(SIGSEGV, ui__signal_backtrace);
168 signal(SIGFPE, ui__signal_backtrace);
169 signal(SIGINT, ui__signal);
170 signal(SIGQUIT, ui__signal);
171 signal(SIGTERM, ui__signal);
172 signal(SIGTSTP, ui__sigcont);
173 signal(SIGCONT, ui__sigcont);
174
175 perf_error__register(&perf_tui_eops);
176
177 ui_helpline__init();
178 ui_browser__init();
179 tui_progress__init();
180
181 hist_browser__init_hpp();
182out:
183 return err;
184}
185
186void ui__exit(bool wait_for_ok)
187{
188 if (wait_for_ok && tui_helpline__set)
189 ui__question_window("Fatal Error",
190 ui_helpline__last_msg,
191 "Press any key...", 0);
192
193 SLtt_set_cursor_visibility(1);
194 if (mutex_trylock(&ui__lock)) {
195 SLsmg_refresh();
196 SLsmg_reset_smg();
197 mutex_unlock(&ui__lock);
198 }
199 SLang_reset_tty();
200 perf_error__unregister(&perf_tui_eops);
201}