Quelle  setup.c   Sprache: C

#include <errno.h>
#include <signal.h>
#include <stdbool.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
#include <linux/kernel.h>
#ifdef HAVE_BACKTRACE_SUPPORT
#include <execinfo.h>
#endif

#include "../../util/color.h"
#include "../../util/debug.h"
#include "../browser.h"
#include "../helpline.h"
#include "../ui.h"
#include "../util.h"
#include "../libslang.h"
#include "../keysyms.h"
#include "tui.h"

static volatile int ui__need_resize;

extern struct perf_error_ops perf_tui_eops;
extern bool tui_helpline__set;

extern void hist_browser__init_hpp(void);

void ui__refresh_dimensions(bool force)
{
 if (force || ui__need_resize) {
  ui__need_resize = 0;
  mutex_lock(&ui__lock);
  SLtt_get_screen_size();
  SLsmg_reinit_smg();
  mutex_unlock(&ui__lock);
 }
}

static void ui__sigwinch(int sig __maybe_unused)
{
 ui__need_resize = 1;
}

static void ui__setup_sigwinch(void)
{
 static bool done;

 if (done)
  return;

 done = true;
 pthread__unblock_sigwinch();
 signal(SIGWINCH, ui__sigwinch);
}

int ui__getch(int delay_secs)
{
 struct timeval timeout, *ptimeout = delay_secs ? &timeout : NULL;
 fd_set read_set;
 int err, key;

 ui__setup_sigwinch();

 FD_ZERO(&read_set);
 FD_SET(0, &read_set);

 if (delay_secs) {
  timeout.tv_sec = delay_secs;
  timeout.tv_usec = 0;
 }

        err = select(1, &read_set, NULL, NULL, ptimeout);

 if (err == 0)
  return K_TIMER;

 if (err == -1) {
  if (errno == EINTR)
   return K_RESIZE;
  return K_ERROR;
 }

 key = SLang_getkey();
 if (key != K_ESC)
  return key;

 FD_ZERO(&read_set);
 FD_SET(0, &read_set);
 timeout.tv_sec = 0;
 timeout.tv_usec = 20;
        err = select(1, &read_set, NULL, NULL, &timeout);
 if (err == 0)
  return K_ESC;

 SLang_ungetkey(key);
 return SLkp_getkey();
}

#ifdef HAVE_BACKTRACE_SUPPORT
static void ui__signal_backtrace(int sig)
{
 void *stackdump[32];
 size_t size;

 ui__exit(false);
 psignal(sig, "perf");

 printf("-------- backtrace --------\n");
 size = backtrace(stackdump, ARRAY_SIZE(stackdump));
 __dump_stack(stdout, stackdump, size);

 exit(0);
}
#else
# define ui__signal_backtrace  ui__signal
#endif

static void ui__signal(int sig)
{
 ui__exit(false);
 psignal(sig, "perf");
 exit(0);
}

static void ui__sigcont(int sig)
{
 static struct termios tty;

 if (sig == SIGTSTP) {
  while (tcgetattr(SLang_TT_Read_FD, &tty) == -1 && errno == EINTR)
   ;
  while (write(SLang_TT_Read_FD, PERF_COLOR_RESET, sizeof(PERF_COLOR_RESET) - 1) == -1 && errno == EINTR)
   ;
  raise(SIGSTOP);
 } else {
  while (tcsetattr(SLang_TT_Read_FD, TCSADRAIN, &tty) == -1 && errno == EINTR)
   ;
  raise(SIGWINCH);
 }
}

int ui__init(void)
{
 int err;

 SLutf8_enable(-1);
 SLtt_get_terminfo();
 SLtt_get_screen_size();

 err = SLsmg_init_smg();
 if (err < 0)
  goto out;
 err = SLang_init_tty(-1, 0, 0);
 if (err < 0)
  goto out;
 SLtty_set_suspend_state(true);

 err = SLkp_init();
 if (err < 0) {
  pr_err("TUI initialization failed.\n");
  goto out;
 }

 SLkp_define_keysym("^(kB)", SL_KEY_UNTAB);

 signal(SIGSEGV, ui__signal_backtrace);
 signal(SIGFPE, ui__signal_backtrace);
 signal(SIGINT, ui__signal);
 signal(SIGQUIT, ui__signal);
 signal(SIGTERM, ui__signal);
 signal(SIGTSTP, ui__sigcont);
 signal(SIGCONT, ui__sigcont);

 perf_error__register(&perf_tui_eops);

 ui_helpline__init();
 ui_browser__init();
 tui_progress__init();

 hist_browser__init_hpp();
out:
 return err;
}

void ui__exit(bool wait_for_ok)
{
 if (wait_for_ok && tui_helpline__set)
  ui__question_window("Fatal Error",
        ui_helpline__last_msg,
        "Press any key...", 0);

 SLtt_set_cursor_visibility(1);
 if (mutex_trylock(&ui__lock)) {
  SLsmg_refresh();
  SLsmg_reset_smg();
  mutex_unlock(&ui__lock);
 }
 SLang_reset_tty();
 perf_error__unregister(&perf_tui_eops);
}