2 #define I3__FILE__ "main.c"
4 * vim:ts=4:sw=4:expandtab
6 * i3 - an improved dynamic tiling window manager
7 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
9 * main.c: Initialization, main loop
14 #include <sys/types.h>
15 #include <sys/socket.h>
18 #include <sys/resource.h>
25 #include "sd-daemon.h"
27 /* The original value of RLIMIT_CORE when i3 was started. We need to restore
28 * this before starting any other process, since we set RLIMIT_CORE to
29 * RLIM_INFINITY for i3 debugging versions. */
30 struct rlimit original_rlimit_core;
32 /** The number of file descriptors passed via socket activation. */
35 /* We keep the xcb_check watcher around to be able to enable and disable it
36 * temporarily for drag_pointer(). */
37 static struct ev_check *xcb_check;
43 xcb_connection_t *conn;
44 /* The screen (0 when you are using DISPLAY=:0) of the connection 'conn' */
47 /* Display handle for libstartup-notification */
50 /* The last timestamp we got from X11 (timestamps are included in some events
51 * and are used for some things, like determining a unique ID in startup
53 xcb_timestamp_t last_timestamp = XCB_CURRENT_TIME;
55 xcb_screen_t *root_screen;
58 /* Color depth, visual id and colormap to use when creating windows and
59 * pixmaps. Will use 32 bit depth and an appropriate visual, if available,
60 * otherwise the root window’s default (usually 24 bit TrueColor). */
62 xcb_visualid_t visual_id;
63 xcb_visualtype_t *visual_type;
64 xcb_colormap_t colormap;
66 struct ev_loop *main_loop;
68 xcb_key_symbols_t *keysyms;
70 /* Default shmlog size if not set by user. */
71 const int default_shmlog_size = 25 * 1024 * 1024;
73 /* The list of key bindings */
74 struct bindings_head *bindings;
76 /* The list of exec-lines */
77 struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts);
79 /* The list of exec_always lines */
80 struct autostarts_always_head autostarts_always = TAILQ_HEAD_INITIALIZER(autostarts_always);
82 /* The list of assignments */
83 struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments);
85 /* The list of workspace assignments (which workspace should end up on which
87 struct ws_assignments_head ws_assignments = TAILQ_HEAD_INITIALIZER(ws_assignments);
89 /* We hope that those are supported and set them to true */
90 bool xcursor_supported = true;
91 bool xkb_supported = true;
94 * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
95 * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
98 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
99 /* empty, because xcb_prepare_cb and xcb_check_cb are used */
103 * Flush before blocking (and waiting for new events)
106 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
111 * Instead of polling the X connection socket we leave this to
112 * xcb_poll_for_event() which knows better than we can ever know.
115 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
116 xcb_generic_event_t *event;
118 while ((event = xcb_poll_for_event(conn)) != NULL) {
119 if (event->response_type == 0) {
120 if (event_is_ignored(event->sequence, 0))
121 DLOG("Expected X11 Error received for sequence %x\n", event->sequence);
123 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
124 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
125 error->sequence, error->error_code);
131 /* Strip off the highest bit (set if the event is generated) */
132 int type = (event->response_type & 0x7F);
134 handle_event(type, event);
141 * Enable or disable the main X11 event handling function.
142 * This is used by drag_pointer() which has its own, modal event handler, which
143 * takes precedence over the normal event handler.
146 void main_set_x11_cb(bool enable) {
147 DLOG("Setting main X11 callback to enabled=%d\n", enable);
149 ev_check_start(main_loop, xcb_check);
150 /* Trigger the watcher explicitly to handle all remaining X11 events.
151 * drag_pointer()’s event handler exits in the middle of the loop. */
152 ev_feed_event(main_loop, xcb_check, 0);
154 ev_check_stop(main_loop, xcb_check);
159 * Exit handler which destroys the main_loop. Will trigger cleanup handlers.
162 static void i3_exit(void) {
163 /* We need ev >= 4 for the following code. Since it is not *that* important (it
164 * only makes sure that there are no i3-nagbar instances left behind) we still
165 * support old systems with libev 3. */
166 #if EV_VERSION_MAJOR >= 4
167 ev_loop_destroy(main_loop);
170 if (*shmlogname != '\0') {
171 fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
173 shm_unlink(shmlogname);
178 * (One-shot) Handler for all signals with default action "Term", see signal(7)
180 * Unlinks the SHM log and re-raises the signal.
183 static void handle_signal(int sig, siginfo_t *info, void *data) {
184 if (*shmlogname != '\0') {
185 shm_unlink(shmlogname);
190 int main(int argc, char *argv[]) {
191 /* Keep a symbol pointing to the I3_VERSION string constant so that we have
192 * it in gdb backtraces. */
193 const char *_i3_version __attribute__((unused)) = i3_version;
194 char *override_configpath = NULL;
195 bool autostart = true;
196 char *layout_path = NULL;
197 bool delete_layout_path = false;
198 bool force_xinerama = false;
199 char *fake_outputs = NULL;
200 bool disable_signalhandler = false;
201 bool only_check_config = false;
202 static struct option long_options[] = {
203 {"no-autostart", no_argument, 0, 'a'},
204 {"config", required_argument, 0, 'c'},
205 {"version", no_argument, 0, 'v'},
206 {"moreversion", no_argument, 0, 'm'},
207 {"more-version", no_argument, 0, 'm'},
208 {"more_version", no_argument, 0, 'm'},
209 {"help", no_argument, 0, 'h'},
210 {"layout", required_argument, 0, 'L'},
211 {"restart", required_argument, 0, 0},
212 {"force-xinerama", no_argument, 0, 0},
213 {"force_xinerama", no_argument, 0, 0},
214 {"disable-signalhandler", no_argument, 0, 0},
215 {"shmlog-size", required_argument, 0, 0},
216 {"shmlog_size", required_argument, 0, 0},
217 {"get-socketpath", no_argument, 0, 0},
218 {"get_socketpath", no_argument, 0, 0},
219 {"fake_outputs", required_argument, 0, 0},
220 {"fake-outputs", required_argument, 0, 0},
221 {"force-old-config-parser-v4.4-only", no_argument, 0, 0},
223 int option_index = 0, opt;
225 setlocale(LC_ALL, "");
227 /* Get the RLIMIT_CORE limit at startup time to restore this before
228 * starting processes. */
229 getrlimit(RLIMIT_CORE, &original_rlimit_core);
231 /* Disable output buffering to make redirects in .xsession actually useful for debugging */
232 if (!isatty(fileno(stdout)))
233 setbuf(stdout, NULL);
237 /* Init logging *before* initializing debug_build to guarantee early
241 /* On release builds, disable SHM logging by default. */
242 shmlog_size = (is_debug_build() || strstr(argv[0], "i3-with-shmlog") != NULL ? default_shmlog_size : 0);
246 while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
249 LOG("Autostart disabled using -a\n");
254 layout_path = sstrdup(optarg);
255 delete_layout_path = false;
258 FREE(override_configpath);
259 override_configpath = sstrdup(optarg);
262 LOG("Checking configuration file only (-C)\n");
263 only_check_config = true;
266 printf("i3 version %s © 2009 Michael Stapelberg and contributors\n", i3_version);
270 printf("Binary i3 version: %s © 2009 Michael Stapelberg and contributors\n", i3_version);
271 display_running_version();
278 LOG("Enabling debug logging\n");
279 set_debug_logging(true);
282 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
285 if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
286 strcmp(long_options[option_index].name, "force_xinerama") == 0) {
287 force_xinerama = true;
288 ELOG("Using Xinerama instead of RandR. This option should be "
289 "avoided at all cost because it does not refresh the list "
290 "of screens, so you cannot configure displays at runtime. "
291 "Please check if your driver really does not support RandR "
292 "and disable this option as soon as you can.\n");
294 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
295 disable_signalhandler = true;
297 } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
298 strcmp(long_options[option_index].name, "get_socketpath") == 0) {
299 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
301 printf("%s\n", socket_path);
306 } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
307 strcmp(long_options[option_index].name, "shmlog_size") == 0) {
308 shmlog_size = atoi(optarg);
309 /* Re-initialize logging immediately to get as many
310 * logmessages as possible into the SHM log. */
312 LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
314 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
316 layout_path = sstrdup(optarg);
317 delete_layout_path = true;
319 } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
320 strcmp(long_options[option_index].name, "fake_outputs") == 0) {
321 LOG("Initializing fake outputs: %s\n", optarg);
322 fake_outputs = sstrdup(optarg);
324 } else if (strcmp(long_options[option_index].name, "force-old-config-parser-v4.4-only") == 0) {
325 ELOG("You are passing --force-old-config-parser-v4.4-only, but that flag was removed by now.\n");
330 fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
331 fprintf(stderr, "\n");
332 fprintf(stderr, "\t-a disable autostart ('exec' lines in config)\n");
333 fprintf(stderr, "\t-c <file> use the provided configfile instead\n");
334 fprintf(stderr, "\t-C validate configuration file and exit\n");
335 fprintf(stderr, "\t-d all enable debug output\n");
336 fprintf(stderr, "\t-L <file> path to the serialized layout during restarts\n");
337 fprintf(stderr, "\t-v display version and exit\n");
338 fprintf(stderr, "\t-V enable verbose mode\n");
339 fprintf(stderr, "\n");
340 fprintf(stderr, "\t--force-xinerama\n"
341 "\tUse Xinerama instead of RandR.\n"
342 "\tThis option should only be used if you are stuck with the\n"
343 "\told nVidia closed source driver (older than 302.17), which does\n"
344 "\tnot support RandR.\n");
345 fprintf(stderr, "\n");
346 fprintf(stderr, "\t--get-socketpath\n"
347 "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
348 fprintf(stderr, "\n");
349 fprintf(stderr, "\t--shmlog-size <limit>\n"
350 "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
351 "\tto 0 disables SHM logging entirely.\n"
352 "\tThe default is %d bytes.\n",
354 fprintf(stderr, "\n");
355 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
356 "to send to a currently running i3 (like i3-msg). This allows you to\n"
357 "use nice and logical commands, such as:\n"
360 "\ti3 floating toggle\n"
367 if (only_check_config) {
368 exit(parse_configuration(override_configpath, false) ? 0 : 1);
371 /* If the user passes more arguments, we act like i3-msg would: Just send
372 * the arguments as an IPC message to i3. This allows for nice semantic
373 * commands such as 'i3 border none'. */
375 /* We enable verbose mode so that the user knows what’s going on.
376 * This should make it easier to find mistakes when the user passes
377 * arguments by mistake. */
380 LOG("Additional arguments passed. Sending them as a command to i3.\n");
381 char *payload = NULL;
382 while (optind < argc) {
384 payload = sstrdup(argv[optind]);
387 sasprintf(&both, "%s %s", payload, argv[optind]);
393 DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
394 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
396 ELOG("Could not get i3 IPC socket path\n");
400 int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
402 err(EXIT_FAILURE, "Could not create socket");
404 struct sockaddr_un addr;
405 memset(&addr, 0, sizeof(struct sockaddr_un));
406 addr.sun_family = AF_LOCAL;
407 strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
408 if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
409 err(EXIT_FAILURE, "Could not connect to i3");
411 if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
412 (uint8_t *)payload) == -1)
413 err(EXIT_FAILURE, "IPC: write()");
415 uint32_t reply_length;
419 if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
421 err(EXIT_FAILURE, "IPC: read()");
424 if (reply_type != I3_IPC_MESSAGE_TYPE_COMMAND)
425 errx(EXIT_FAILURE, "IPC: received reply of type %d but expected %d (COMMAND)", reply_type, I3_IPC_MESSAGE_TYPE_COMMAND);
426 printf("%.*s\n", reply_length, reply);
430 /* Enable logging to handle the case when the user did not specify --shmlog-size */
433 /* Try to enable core dumps by default when running a debug build */
434 if (is_debug_build()) {
435 struct rlimit limit = {RLIM_INFINITY, RLIM_INFINITY};
436 setrlimit(RLIMIT_CORE, &limit);
438 /* The following code is helpful, but not required. We thus don’t pay
439 * much attention to error handling, non-linux or other edge cases. */
440 LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
441 size_t cwd_size = 1024;
442 char *cwd = smalloc(cwd_size);
444 while ((cwd_ret = getcwd(cwd, cwd_size)) == NULL && errno == ERANGE) {
445 cwd_size = cwd_size * 2;
446 cwd = srealloc(cwd, cwd_size);
449 LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
451 if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
452 memset(cwd, '\0', cwd_size);
453 if (read(patternfd, cwd, cwd_size) > 0)
454 /* a trailing newline is included in cwd */
455 LOG("CORE DUMPS: Your core_pattern is: \"%s\".\n", cwd);
461 LOG("i3 %s starting\n", i3_version);
463 conn = xcb_connect(NULL, &conn_screen);
464 if (xcb_connection_has_error(conn))
465 errx(EXIT_FAILURE, "Cannot open display\n");
467 sndisplay = sn_xcb_display_new(conn, NULL, NULL);
469 /* Initialize the libev event loop. This needs to be done before loading
470 * the config file because the parser will install an ev_child watcher
471 * for the nagbar when config errors are found. */
472 main_loop = EV_DEFAULT;
473 if (main_loop == NULL)
474 die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
476 root_screen = xcb_aux_get_screen(conn, conn_screen);
477 root = root_screen->root;
479 /* Place requests for the atoms we need as soon as possible */
480 #define xmacro(atom) \
481 xcb_intern_atom_cookie_t atom##_cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
482 #include "atoms.xmacro"
485 /* By default, we use the same depth and visual as the root window, which
486 * usually is TrueColor (24 bit depth) and the corresponding visual.
487 * However, we also check if a 32 bit depth and visual are available (for
488 * transparency) and use it if so. */
489 root_depth = root_screen->root_depth;
490 visual_id = root_screen->root_visual;
491 visual_type = get_visualtype(root_screen);
492 colormap = root_screen->default_colormap;
494 DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
495 DLOG("root_screen->height_in_pixels = %d, root_screen->height_in_millimeters = %d, dpi = %d\n",
496 root_screen->height_in_pixels, root_screen->height_in_millimeters,
497 (int)((double)root_screen->height_in_pixels * 25.4 / (double)root_screen->height_in_millimeters));
498 DLOG("One logical pixel corresponds to %d physical pixels on this display.\n", logical_px(1));
500 xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
501 xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
503 /* Setup NetWM atoms */
504 #define xmacro(name) \
506 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name##_cookie, NULL); \
508 ELOG("Could not get atom " #name "\n"); \
511 A_##name = reply->atom; \
514 #include "atoms.xmacro"
517 load_configuration(conn, override_configpath, false);
519 if (config.ipc_socket_path == NULL) {
520 /* Fall back to a file name in /tmp/ based on the PID */
521 if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
522 config.ipc_socket_path = get_process_filename("ipc-socket");
524 config.ipc_socket_path = sstrdup(config.ipc_socket_path);
527 xcb_void_cookie_t cookie;
528 cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ROOT_EVENT_MASK});
529 check_error(conn, cookie, "Another window manager seems to be running");
531 xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
532 if (greply == NULL) {
533 ELOG("Could not get geometry of the root window, exiting\n");
536 DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
538 xcursor_load_cursors();
540 /* Set a cursor for the root window (otherwise the root window will show no
541 cursor until the first client is launched). */
542 if (xcursor_supported)
543 xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
545 xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
547 const xcb_query_extension_reply_t *extreply;
548 extreply = xcb_get_extension_data(conn, &xcb_xkb_id);
549 xkb_supported = extreply->present;
550 if (!extreply->present) {
551 DLOG("xkb is not present on this server\n");
553 DLOG("initializing xcb-xkb\n");
554 xcb_xkb_use_extension(conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
555 xcb_xkb_select_events(conn,
556 XCB_XKB_ID_USE_CORE_KBD,
557 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
559 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
564 /* Setting both, XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE and
565 * XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED, will lead to the
566 * X server sending us the full XKB state in KeyPress and KeyRelease:
567 * https://sources.debian.net/src/xorg-server/2:1.17.2-1.1/xkb/xkbEvents.c/?hl=927#L927
569 xcb_xkb_per_client_flags_reply_t *pcf_reply;
570 /* The last three parameters are unset because they are only relevant
571 * when using a feature called “automatic reset of boolean controls”:
572 * http://www.x.org/releases/X11R7.7/doc/kbproto/xkbproto.html#Automatic_Reset_of_Boolean_Controls
574 pcf_reply = xcb_xkb_per_client_flags_reply(
576 xcb_xkb_per_client_flags(
578 XCB_XKB_ID_USE_CORE_KBD,
579 XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE | XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED,
580 XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE | XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED,
581 0 /* uint32_t ctrlsToChange */,
582 0 /* uint32_t autoCtrls */,
583 0 /* uint32_t autoCtrlsValues */),
585 if (pcf_reply == NULL ||
586 !(pcf_reply->value & XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE)) {
587 ELOG("Could not set XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE\n");
589 if (pcf_reply == NULL ||
590 !(pcf_reply->value & XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED)) {
591 ELOG("Could not set XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED\n");
594 xkb_base = extreply->first_event;
599 property_handlers_init();
603 keysyms = xcb_key_symbols_alloc(conn);
605 xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
608 die("Could not load keymap\n");
613 bool needs_tree_init = true;
615 LOG("Trying to restore the layout from \"%s\".\n", layout_path);
616 needs_tree_init = !tree_restore(layout_path, greply);
617 if (delete_layout_path) {
619 const char *dir = dirname(layout_path);
620 /* possibly fails with ENOTEMPTY if there are files (or
631 /* Setup fake outputs for testing */
632 if (fake_outputs == NULL && config.fake_outputs != NULL)
633 fake_outputs = config.fake_outputs;
635 if (fake_outputs != NULL) {
636 fake_outputs_init(fake_outputs);
638 config.fake_outputs = NULL;
639 } else if (force_xinerama || config.force_xinerama) {
640 /* Force Xinerama (for drivers which don't support RandR yet, esp. the
641 * nVidia binary graphics driver), when specified either in the config
642 * file or on command-line */
645 DLOG("Checking for XRandR...\n");
646 randr_init(&randr_base);
649 scratchpad_fix_resolution();
651 xcb_query_pointer_reply_t *pointerreply;
652 Output *output = NULL;
653 if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
654 ELOG("Could not query pointer position, using first screen\n");
656 DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
657 output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
659 ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
660 pointerreply->root_x, pointerreply->root_y);
661 output = get_first_output();
664 con_focus(con_descend_focused(output_get_content(output->con)));
669 /* Create the UNIX domain socket for IPC */
670 int ipc_socket = ipc_create_socket(config.ipc_socket_path);
671 if (ipc_socket == -1) {
672 ELOG("Could not create the IPC socket, IPC disabled\n");
674 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
675 ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
676 ev_io_start(main_loop, ipc_io);
679 /* Also handle the UNIX domain sockets passed via socket activation. The
680 * parameter 1 means "remove the environment variables", we don’t want to
681 * pass these to child processes. */
682 listen_fds = sd_listen_fds(0);
684 ELOG("socket activation: Error in sd_listen_fds\n");
685 else if (listen_fds == 0)
686 DLOG("socket activation: no sockets passed\n");
689 for (int fd = SD_LISTEN_FDS_START;
690 fd < (SD_LISTEN_FDS_START + listen_fds);
692 DLOG("socket activation: also listening on fd %d\n", fd);
694 /* sd_listen_fds() enables FD_CLOEXEC by default.
695 * However, we need to keep the file descriptors open for in-place
696 * restarting, therefore we explicitly disable FD_CLOEXEC. */
697 if ((flags = fcntl(fd, F_GETFD)) < 0 ||
698 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
699 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
702 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
703 ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
704 ev_io_start(main_loop, ipc_io);
708 /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
710 ewmh_update_workarea();
712 /* Set the ewmh desktop properties. */
713 ewmh_update_current_desktop();
714 ewmh_update_number_of_desktops();
715 ewmh_update_desktop_names();
716 ewmh_update_desktop_viewport();
718 struct ev_io *xcb_watcher = scalloc(1, sizeof(struct ev_io));
719 xcb_check = scalloc(1, sizeof(struct ev_check));
720 struct ev_prepare *xcb_prepare = scalloc(1, sizeof(struct ev_prepare));
722 ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
723 ev_io_start(main_loop, xcb_watcher);
725 ev_check_init(xcb_check, xcb_check_cb);
726 ev_check_start(main_loop, xcb_check);
728 ev_prepare_init(xcb_prepare, xcb_prepare_cb);
729 ev_prepare_start(main_loop, xcb_prepare);
733 /* What follows is a fugly consequence of X11 protocol race conditions like
734 * the following: In an i3 in-place restart, i3 will reparent all windows
735 * to the root window, then exec() itself. In the new process, it calls
736 * manage_existing_windows. However, in case any application sent a
737 * generated UnmapNotify message to the WM (as GIMP does), this message
738 * will be handled by i3 *after* managing the window, thus i3 thinks the
739 * window just closed itself. In reality, the message was sent in the time
740 * period where i3 wasn’t running yet.
742 * To prevent this, we grab the server (disables processing of any other
743 * connections), then discard all pending events (since we didn’t do
744 * anything, there cannot be any meaningful responses), then ungrab the
746 xcb_grab_server(conn);
749 xcb_generic_event_t *event;
750 while ((event = xcb_poll_for_event(conn)) != NULL) {
751 if (event->response_type == 0) {
756 /* Strip off the highest bit (set if the event is generated) */
757 int type = (event->response_type & 0x7F);
759 /* We still need to handle MapRequests which are sent in the
760 * timespan starting from when we register as a window manager and
761 * this piece of code which drops events. */
762 if (type == XCB_MAP_REQUEST)
763 handle_event(type, event);
767 manage_existing_windows(root);
769 xcb_ungrab_server(conn);
772 LOG("This is not an in-place restart, copying root window contents to a pixmap\n");
773 xcb_screen_t *root = xcb_aux_get_screen(conn, conn_screen);
774 uint16_t width = root->width_in_pixels;
775 uint16_t height = root->height_in_pixels;
776 xcb_pixmap_t pixmap = xcb_generate_id(conn);
777 xcb_gcontext_t gc = xcb_generate_id(conn);
779 xcb_create_pixmap(conn, root->root_depth, pixmap, root->root, width, height);
781 xcb_create_gc(conn, gc, root->root,
782 XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
783 (uint32_t[]){XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS});
785 xcb_copy_area(conn, root->root, pixmap, gc, 0, 0, 0, 0, width, height);
786 xcb_change_window_attributes_checked(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]){pixmap});
788 xcb_free_gc(conn, gc);
789 xcb_free_pixmap(conn, pixmap);
792 struct sigaction action;
794 action.sa_sigaction = handle_signal;
795 action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
796 sigemptyset(&action.sa_mask);
798 if (!disable_signalhandler)
799 setup_signal_handler();
801 /* Catch all signals with default action "Core", see signal(7) */
802 if (sigaction(SIGQUIT, &action, NULL) == -1 ||
803 sigaction(SIGILL, &action, NULL) == -1 ||
804 sigaction(SIGABRT, &action, NULL) == -1 ||
805 sigaction(SIGFPE, &action, NULL) == -1 ||
806 sigaction(SIGSEGV, &action, NULL) == -1)
807 ELOG("Could not setup signal handler.\n");
810 /* Catch all signals with default action "Term", see signal(7) */
811 if (sigaction(SIGHUP, &action, NULL) == -1 ||
812 sigaction(SIGINT, &action, NULL) == -1 ||
813 sigaction(SIGALRM, &action, NULL) == -1 ||
814 sigaction(SIGUSR1, &action, NULL) == -1 ||
815 sigaction(SIGUSR2, &action, NULL) == -1)
816 ELOG("Could not setup signal handler.\n");
818 /* Ignore SIGPIPE to survive errors when an IPC client disconnects
819 * while we are sending them a message */
820 signal(SIGPIPE, SIG_IGN);
822 /* Autostarting exec-lines */
824 while (!TAILQ_EMPTY(&autostarts)) {
825 struct Autostart *exec = TAILQ_FIRST(&autostarts);
827 LOG("auto-starting %s\n", exec->command);
828 start_application(exec->command, exec->no_startup_id);
831 TAILQ_REMOVE(&autostarts, exec, autostarts);
836 /* Autostarting exec_always-lines */
837 while (!TAILQ_EMPTY(&autostarts_always)) {
838 struct Autostart *exec_always = TAILQ_FIRST(&autostarts_always);
840 LOG("auto-starting (always!) %s\n", exec_always->command);
841 start_application(exec_always->command, exec_always->no_startup_id);
843 FREE(exec_always->command);
844 TAILQ_REMOVE(&autostarts_always, exec_always, autostarts_always);
848 /* Start i3bar processes for all configured bars */
849 Barconfig *barconfig;
850 TAILQ_FOREACH(barconfig, &barconfigs, configs) {
851 char *command = NULL;
852 sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
853 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
854 barconfig->id, current_socketpath);
855 LOG("Starting bar process: %s\n", command);
856 start_application(command, true);
860 /* Make sure to destroy the event loop to invoke the cleeanup callbacks
861 * when calling exit() */
864 ev_loop(main_loop, 0);