i3
sighandler.c
Go to the documentation of this file.
1 #undef I3__FILE__
2 #define I3__FILE__ "sighandler.c"
3 /*
4  * vim:ts=4:sw=4:expandtab
5  *
6  * i3 - an improved dynamic tiling window manager
7  * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
8  * © 2009-2010 Jan-Erik Rediger
9  *
10  * sighandler.c: Interactive crash dialog upon SIGSEGV/SIGABRT/SIGFPE (offers
11  * to restart inplace).
12  *
13  */
14 #include "all.h"
15 
16 #include <ev.h>
17 #include <iconv.h>
18 #include <signal.h>
19 #include <sys/wait.h>
20 
21 #include <xcb/xcb_event.h>
22 
23 #include <X11/keysym.h>
24 
25 static void open_popups(void);
26 
27 static xcb_gcontext_t pixmap_gc;
28 static xcb_pixmap_t pixmap;
29 static int raised_signal;
30 
31 static char *crash_text[] = {
32  "i3 just crashed.",
33  "To debug this problem, either attach gdb now",
34  "or press",
35  "- 'b' to save a backtrace (needs GDB),",
36  "- 'r' to restart i3 in-place or",
37  "- 'f' to forget the current layout and restart"};
38 static int crash_text_longest = 5;
39 static int backtrace_string_index = 3;
40 static int backtrace_done = 0;
41 
42 /*
43  * Attach gdb to pid_parent and dump a backtrace to i3-backtrace.$pid in the
44  * tmpdir
45  */
46 static int backtrace(void) {
47  char *tmpdir = getenv("TMPDIR");
48  if (tmpdir == NULL)
49  tmpdir = "/tmp";
50 
51  pid_t pid_parent = getpid();
52 
53  char *filename = NULL;
54  int suffix = 0;
55  struct stat bt;
56  /* Find a unique filename for the backtrace (since the PID of i3 stays the
57  * same), so that we don’t overwrite earlier backtraces. */
58  do {
59  FREE(filename);
60  sasprintf(&filename, "%s/i3-backtrace.%d.%d.txt", tmpdir, pid_parent, suffix);
61  suffix++;
62  } while (stat(filename, &bt) == 0);
63 
64  pid_t pid_gdb = fork();
65  if (pid_gdb < 0) {
66  DLOG("Failed to fork for GDB\n");
67  return -1;
68  } else if (pid_gdb == 0) {
69  /* child */
70  int stdin_pipe[2],
71  stdout_pipe[2];
72 
73  pipe(stdin_pipe);
74  pipe(stdout_pipe);
75 
76  /* close standard streams in case i3 is started from a terminal; gdb
77  * needs to run without controlling terminal for it to work properly in
78  * this situation */
79  close(STDIN_FILENO);
80  close(STDOUT_FILENO);
81  close(STDERR_FILENO);
82 
83  /* We provide pipe file descriptors for stdin/stdout because gdb < 7.5
84  * crashes otherwise, see
85  * http://sourceware.org/bugzilla/show_bug.cgi?id=14114 */
86  dup2(stdin_pipe[0], STDIN_FILENO);
87  dup2(stdout_pipe[1], STDOUT_FILENO);
88 
89  char *pid_s, *gdb_log_cmd;
90  sasprintf(&pid_s, "%d", pid_parent);
91  sasprintf(&gdb_log_cmd, "set logging file %s", filename);
92 
93  char *args[] = {
94  "gdb",
95  start_argv[0],
96  "-p",
97  pid_s,
98  "-batch",
99  "-nx",
100  "-ex", gdb_log_cmd,
101  "-ex", "set logging on",
102  "-ex", "bt full",
103  "-ex", "quit",
104  NULL};
105  execvp(args[0], args);
106  DLOG("Failed to exec GDB\n");
107  exit(1);
108  }
109  int status = 0;
110 
111  waitpid(pid_gdb, &status, 0);
112 
113  /* see if the backtrace was succesful or not */
114  if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
115  DLOG("GDB did not run properly\n");
116  return -1;
117  } else if (stat(filename, &bt) == -1) {
118  DLOG("GDB executed successfully, but no backtrace was generated\n");
119  return -1;
120  }
121  return 1;
122 }
123 
124 /*
125  * Draw the window containing the info text
126  *
127  */
128 static int sig_draw_window(xcb_window_t win, int width, int height, int font_height, i3String **crash_text_i3strings) {
129  /* re-draw the background */
130  xcb_rectangle_t border = {0, 0, width, height},
131  inner = {2, 2, width - 4, height - 4};
132  xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]) {get_colorpixel("#FF0000")});
133  xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &border);
134  xcb_change_gc(conn, pixmap_gc, XCB_GC_FOREGROUND, (uint32_t[]) {get_colorpixel("#000000")});
135  xcb_poly_fill_rectangle(conn, pixmap, pixmap_gc, 1, &inner);
136 
137  /* restore font color */
138  set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
139 
140  char *bt_colour = "#FFFFFF";
141  if (backtrace_done < 0)
142  bt_colour = "#AA0000";
143  else if (backtrace_done > 0)
144  bt_colour = "#00AA00";
145 
146  for (int i = 0; crash_text_i3strings[i] != NULL; ++i) {
147  /* fix the colour for the backtrace line when it finished */
148  if (i == backtrace_string_index)
149  set_font_colors(pixmap_gc, get_colorpixel(bt_colour), get_colorpixel("#000000"));
150 
151  draw_text(crash_text_i3strings[i], pixmap, pixmap_gc,
152  8, 5 + i * font_height, width - 16);
153 
154  /* and reset the colour again for other lines */
155  if (i == backtrace_string_index)
156  set_font_colors(pixmap_gc, get_colorpixel("#FFFFFF"), get_colorpixel("#000000"));
157  }
158 
159  /* Copy the contents of the pixmap to the real window */
160  xcb_copy_area(conn, pixmap, win, pixmap_gc, 0, 0, 0, 0, width, height);
161  xcb_flush(conn);
162 
163  return 1;
164 }
165 
166 /*
167  * Handles keypresses of 'b', 'r' and 'f' to get a backtrace or restart i3
168  *
169  */
170 static int sig_handle_key_press(void *ignored, xcb_connection_t *conn, xcb_key_press_event_t *event) {
171  uint16_t state = event->state;
172 
173  /* Apparantly, after activating numlock once, the numlock modifier
174  * stays turned on (use xev(1) to verify). So, to resolve useful
175  * keysyms, we remove the numlock flag from the event state */
176  state &= ~xcb_numlock_mask;
177 
178  xcb_keysym_t sym = xcb_key_press_lookup_keysym(keysyms, event, state);
179 
180  if (sym == 'b') {
181  DLOG("User issued core-dump command.\n");
182 
183  /* fork and exec/attach GDB to the parent to get a backtrace in the
184  * tmpdir */
186 
187  /* re-open the windows to indicate that it's finished */
188  open_popups();
189  }
190 
191  if (sym == 'r')
192  i3_restart(false);
193 
194  if (sym == 'f')
195  i3_restart(true);
196 
197  return 1;
198 }
199 
200 /*
201  * Opens the window we use for input/output and maps it
202  *
203  */
204 static xcb_window_t open_input_window(xcb_connection_t *conn, Rect screen_rect, uint32_t width, uint32_t height) {
205  xcb_window_t win = xcb_generate_id(conn);
206 
207  uint32_t mask = 0;
208  uint32_t values[2];
209 
210  mask |= XCB_CW_BACK_PIXEL;
211  values[0] = 0;
212 
213  mask |= XCB_CW_OVERRIDE_REDIRECT;
214  values[1] = 1;
215 
216  /* center each popup on the specified screen */
217  uint32_t x = screen_rect.x + ((screen_rect.width / 2) - (width / 2)),
218  y = screen_rect.y + ((screen_rect.height / 2) - (height / 2));
219 
220  xcb_create_window(conn,
221  XCB_COPY_FROM_PARENT,
222  win, /* the window id */
223  root, /* parent == root */
224  x, y, width, height, /* dimensions */
225  0, /* border = 0, we draw our own */
226  XCB_WINDOW_CLASS_INPUT_OUTPUT,
227  XCB_WINDOW_CLASS_COPY_FROM_PARENT, /* copy visual from parent */
228  mask,
229  values);
230 
231  /* Map the window (= make it visible) */
232  xcb_map_window(conn, win);
233 
234  return win;
235 }
236 
237 static void open_popups() {
238  /* width and height of the popup window, so that the text fits in */
239  int crash_text_num = sizeof(crash_text) / sizeof(char *);
240  int height = 13 + (crash_text_num * config.font.height);
241 
242  int crash_text_length = sizeof(crash_text) / sizeof(char *);
243  i3String **crash_text_i3strings = smalloc(sizeof(i3String *) * (crash_text_length + 1));
244  /* Pre-compute i3Strings for our text */
245  for (int i = 0; i < crash_text_length; ++i) {
246  crash_text_i3strings[i] = i3string_from_utf8(crash_text[i]);
247  }
248  crash_text_i3strings[crash_text_length] = NULL;
249  /* calculate width for longest text */
250  int font_width = predict_text_width(crash_text_i3strings[crash_text_longest]);
251  int width = font_width + 20;
252 
253  /* Open a popup window on each virtual screen */
254  Output *screen;
255  xcb_window_t win;
256  TAILQ_FOREACH (screen, &outputs, outputs) {
257  if (!screen->active)
258  continue;
259  win = open_input_window(conn, screen->rect, width, height);
260 
261  /* Create pixmap */
262  pixmap = xcb_generate_id(conn);
263  pixmap_gc = xcb_generate_id(conn);
264  xcb_create_pixmap(conn, root_depth, pixmap, win, width, height);
265  xcb_create_gc(conn, pixmap_gc, pixmap, 0, 0);
266 
267  /* Grab the keyboard to get all input */
268  xcb_grab_keyboard(conn, false, win, XCB_CURRENT_TIME, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
269 
270  /* Grab the cursor inside the popup */
271  xcb_grab_pointer(conn, false, win, XCB_NONE, XCB_GRAB_MODE_ASYNC,
272  XCB_GRAB_MODE_ASYNC, win, XCB_NONE, XCB_CURRENT_TIME);
273 
274  sig_draw_window(win, width, height, config.font.height, crash_text_i3strings);
275  xcb_flush(conn);
276  }
277 }
278 
279 /*
280  * Handle signals
281  * It creates a window asking the user to restart in-place
282  * or exit to generate a core dump
283  *
284  */
285 void handle_signal(int sig, siginfo_t *info, void *data) {
286  DLOG("i3 crashed. SIG: %d\n", sig);
287 
288  struct sigaction action;
289  action.sa_handler = SIG_DFL;
290  sigaction(sig, &action, NULL);
291  raised_signal = sig;
292 
293  open_popups();
294 
295  xcb_generic_event_t *event;
296  /* Yay, more own eventhandlers… */
297  while ((event = xcb_wait_for_event(conn))) {
298  /* Strip off the highest bit (set if the event is generated) */
299  int type = (event->response_type & 0x7F);
300  if (type == XCB_KEY_PRESS) {
301  sig_handle_key_press(NULL, conn, (xcb_key_press_event_t *)event);
302  }
303  free(event);
304  }
305 }
306 
307 /*
308  * Setup signal handlers to safely handle SIGSEGV and SIGFPE
309  *
310  */
312  struct sigaction action;
313 
314  action.sa_sigaction = handle_signal;
315  action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
316  sigemptyset(&action.sa_mask);
317 
318  /* Catch all signals with default action "Core", see signal(7) */
319  if (sigaction(SIGQUIT, &action, NULL) == -1 ||
320  sigaction(SIGILL, &action, NULL) == -1 ||
321  sigaction(SIGABRT, &action, NULL) == -1 ||
322  sigaction(SIGFPE, &action, NULL) == -1 ||
323  sigaction(SIGSEGV, &action, NULL) == -1)
324  ELOG("Could not setup signal handler");
325 }
int predict_text_width(i3String *text)
Predict the text width in pixels for the given text.
uint32_t y
Definition: data.h:124
uint32_t height
Definition: data.h:33
Config config
Definition: config.c:19
xcb_connection_t * conn
Definition: main.c:47
char ** start_argv
Definition: main.c:45
i3Font font
Definition: config.h:92
Stores a rectangle, for example the size of a window, the child window etc.
Definition: data.h:122
static int sig_handle_key_press(void *ignored, xcb_connection_t *conn, xcb_key_press_event_t *event)
Definition: sighandler.c:170
Rect rect
x, y, width, height
Definition: data.h:322
uint32_t width
Definition: data.h:32
static int raised_signal
Definition: sighandler.c:29
void handle_signal(int sig, siginfo_t *info, void *data)
Definition: sighandler.c:285
An Output is a physical output on your graphics driver.
Definition: data.h:301
static xcb_gcontext_t pixmap_gc
Definition: sighandler.c:27
i3String * i3string_from_utf8(const char *from_utf8)
Build an i3String from an UTF-8 encoded string.
void i3_restart(bool forget_layout)
Restart i3 in-place appends -a to argument list to disable autostart.
Definition: util.c:294
#define DLOG(fmt,...)
Definition: libi3.h:86
static cmdp_state state
static xcb_pixmap_t pixmap
Definition: sighandler.c:28
int sasprintf(char **strp, const char *fmt,...)
Safe-wrapper around asprintf which exits if it returns -1 (meaning that there is no more memory avail...
static int backtrace(void)
Definition: sighandler.c:46
uint32_t get_colorpixel(const char *hex) __attribute__((const ))
Returns the colorpixel to use for the given hex color (think of HTML).
struct _i3String i3String
Opaque data structure for storing strings.
Definition: libi3.h:28
uint8_t root_depth
Definition: main.c:65
struct outputs_head outputs
Definition: randr.c:28
uint32_t height
Definition: data.h:126
int height
The height of the font, built from font_ascent + font_descent.
Definition: libi3.h:47
void draw_text(i3String *text, xcb_drawable_t drawable, xcb_gcontext_t gc, int x, int y, int max_width)
Draws text onto the specified X drawable (normally a pixmap) at the specified coordinates (from the t...
void setup_signal_handler(void)
Setup signal handlers to safely handle SIGSEGV and SIGFPE.
Definition: sighandler.c:311
static int sig_draw_window(xcb_window_t win, int width, int height, int font_height, i3String **crash_text_i3strings)
Definition: sighandler.c:128
static void open_popups(void)
Definition: sighandler.c:237
bool active
Whether the output is currently active (has a CRTC attached with a valid mode)
Definition: data.h:307
#define ELOG(fmt,...)
Definition: libi3.h:81
static int crash_text_longest
Definition: sighandler.c:38
static int backtrace_string_index
Definition: sighandler.c:39
unsigned int xcb_numlock_mask
Definition: xcb.c:14
uint32_t x
Definition: data.h:123
void set_font_colors(xcb_gcontext_t gc, uint32_t foreground, uint32_t background)
Defines the colors to be used for the forthcoming draw_text calls.
xcb_window_t root
Definition: main.c:60
static char * crash_text[]
Definition: sighandler.c:31
static xcb_window_t open_input_window(xcb_connection_t *conn, Rect screen_rect, uint32_t width, uint32_t height)
Definition: sighandler.c:204
uint32_t y
Definition: data.h:31
void * smalloc(size_t size)
Safe-wrapper around malloc which exits if malloc returns NULL (meaning that there is no more memory a...
xcb_key_symbols_t * keysyms
Definition: main.c:71
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:334
uint32_t x
Definition: data.h:30
#define FREE(pointer)
Definition: util.h:46
static int backtrace_done
Definition: sighandler.c:40
uint32_t width
Definition: data.h:125