2 * vim:ts=4:sw=4:expandtab
4 * i3 - an improved dynamic tiling window manager
5 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
7 * main.c: Initialization, main loop
14 #include <sys/types.h>
15 #include <sys/socket.h>
18 #include <sys/resource.h>
24 #ifdef I3_ASAN_ENABLED
25 #include <sanitizer/lsan_interface.h>
28 #include "sd-daemon.h"
30 /* The original value of RLIMIT_CORE when i3 was started. We need to restore
31 * this before starting any other process, since we set RLIMIT_CORE to
32 * RLIM_INFINITY for i3 debugging versions. */
33 struct rlimit original_rlimit_core;
35 /* The number of file descriptors passed via socket activation. */
38 /* We keep the xcb_prepare watcher around to be able to enable and disable it
39 * temporarily for drag_pointer(). */
40 static struct ev_prepare *xcb_prepare;
44 xcb_connection_t *conn;
45 /* The screen (0 when you are using DISPLAY=:0) of the connection 'conn' */
48 /* Display handle for libstartup-notification */
51 /* The last timestamp we got from X11 (timestamps are included in some events
52 * and are used for some things, like determining a unique ID in startup
54 xcb_timestamp_t last_timestamp = XCB_CURRENT_TIME;
56 xcb_screen_t *root_screen;
59 /* Color depth, visual id and colormap to use when creating windows and
60 * pixmaps. Will use 32 bit depth and an appropriate visual, if available,
61 * otherwise the root window’s default (usually 24 bit TrueColor). */
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;
93 bool force_xinerama = false;
96 * This callback is only a dummy, see xcb_prepare_cb.
97 * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
100 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
101 /* empty, because xcb_prepare_cb are used */
105 * Called just before the event loop sleeps. Ensures xcb’s incoming and outgoing
106 * queues are empty so that any activity will trigger another event loop
107 * iteration, and hence another xcb_prepare_cb invocation.
110 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
111 /* Process all queued (and possibly new) events before the event loop
113 xcb_generic_event_t *event;
115 while ((event = xcb_poll_for_event(conn)) != NULL) {
116 if (event->response_type == 0) {
117 if (event_is_ignored(event->sequence, 0))
118 DLOG("Expected X11 Error received for sequence %x\n", event->sequence);
120 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
121 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
122 error->sequence, error->error_code);
128 /* Strip off the highest bit (set if the event is generated) */
129 int type = (event->response_type & 0x7F);
131 handle_event(type, event);
136 /* Flush all queued events to X11. */
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_prepare_start(main_loop, xcb_prepare);
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_prepare, 0);
154 ev_prepare_stop(main_loop, xcb_prepare);
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);
175 ipc_shutdown(SHUTDOWN_REASON_EXIT);
176 unlink(config.ipc_socket_path);
180 * (One-shot) Handler for all signals with default action "Core", see signal(7)
182 * Unlinks the SHM log and re-raises the signal.
185 static void handle_core_signal(int sig, siginfo_t *info, void *data) {
186 if (*shmlogname != '\0') {
187 shm_unlink(shmlogname);
193 * (One-shot) Handler for all signals with default action "Term", see signal(7)
195 * Exits the program gracefully.
198 static void handle_term_signal(struct ev_loop *loop, ev_signal *signal, int revents) {
199 /* We exit gracefully here in the sense that cleanup handlers
200 * installed via atexit are invoked. */
201 exit(128 + signal->signum);
205 * Set up handlers for all signals with default action "Term", see signal(7)
208 static void setup_term_handlers(void) {
209 static struct ev_signal signal_watchers[6];
210 size_t num_watchers = sizeof(signal_watchers) / sizeof(signal_watchers[0]);
212 /* We have to rely on libev functionality here and should not use
213 * sigaction handlers because we need to invoke the exit handlers
214 * and cannot do so from an asynchronous signal handling context as
215 * not all code triggered during exit is signal safe (and exiting
216 * the main loop from said handler is not easily possible). libev's
217 * signal handlers does not impose such a constraint on us. */
218 ev_signal_init(&signal_watchers[0], handle_term_signal, SIGHUP);
219 ev_signal_init(&signal_watchers[1], handle_term_signal, SIGINT);
220 ev_signal_init(&signal_watchers[2], handle_term_signal, SIGALRM);
221 ev_signal_init(&signal_watchers[3], handle_term_signal, SIGTERM);
222 ev_signal_init(&signal_watchers[4], handle_term_signal, SIGUSR1);
223 ev_signal_init(&signal_watchers[5], handle_term_signal, SIGUSR1);
224 for (size_t i = 0; i < num_watchers; i++) {
225 ev_signal_start(main_loop, &signal_watchers[i]);
226 /* The signal handlers should not block ev_run from returning
227 * and so none of the signal handlers should hold a reference to
233 int main(int argc, char *argv[]) {
234 /* Keep a symbol pointing to the I3_VERSION string constant so that we have
235 * it in gdb backtraces. */
236 static const char *_i3_version __attribute__((used)) = I3_VERSION;
237 char *override_configpath = NULL;
238 bool autostart = true;
239 char *layout_path = NULL;
240 bool delete_layout_path = false;
241 bool disable_randr15 = false;
242 char *fake_outputs = NULL;
243 bool disable_signalhandler = false;
244 bool only_check_config = false;
245 static struct option long_options[] = {
246 {"no-autostart", no_argument, 0, 'a'},
247 {"config", required_argument, 0, 'c'},
248 {"version", no_argument, 0, 'v'},
249 {"moreversion", no_argument, 0, 'm'},
250 {"more-version", no_argument, 0, 'm'},
251 {"more_version", no_argument, 0, 'm'},
252 {"help", no_argument, 0, 'h'},
253 {"layout", required_argument, 0, 'L'},
254 {"restart", required_argument, 0, 0},
255 {"force-xinerama", no_argument, 0, 0},
256 {"force_xinerama", no_argument, 0, 0},
257 {"disable-randr15", no_argument, 0, 0},
258 {"disable_randr15", no_argument, 0, 0},
259 {"disable-signalhandler", no_argument, 0, 0},
260 {"shmlog-size", required_argument, 0, 0},
261 {"shmlog_size", required_argument, 0, 0},
262 {"get-socketpath", no_argument, 0, 0},
263 {"get_socketpath", no_argument, 0, 0},
264 {"fake_outputs", required_argument, 0, 0},
265 {"fake-outputs", required_argument, 0, 0},
266 {"force-old-config-parser-v4.4-only", no_argument, 0, 0},
268 int option_index = 0, opt;
270 setlocale(LC_ALL, "");
272 /* Get the RLIMIT_CORE limit at startup time to restore this before
273 * starting processes. */
274 getrlimit(RLIMIT_CORE, &original_rlimit_core);
276 /* Disable output buffering to make redirects in .xsession actually useful for debugging */
277 if (!isatty(fileno(stdout)))
278 setbuf(stdout, NULL);
282 /* Init logging *before* initializing debug_build to guarantee early
286 /* On release builds, disable SHM logging by default. */
287 shmlog_size = (is_debug_build() || strstr(argv[0], "i3-with-shmlog") != NULL ? default_shmlog_size : 0);
291 while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
294 LOG("Autostart disabled using -a\n");
299 layout_path = sstrdup(optarg);
300 delete_layout_path = false;
303 FREE(override_configpath);
304 override_configpath = sstrdup(optarg);
307 LOG("Checking configuration file only (-C)\n");
308 only_check_config = true;
311 printf("i3 version %s © 2009 Michael Stapelberg and contributors\n", i3_version);
315 printf("Binary i3 version: %s © 2009 Michael Stapelberg and contributors\n", i3_version);
316 display_running_version();
323 LOG("Enabling debug logging\n");
324 set_debug_logging(true);
327 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
330 if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
331 strcmp(long_options[option_index].name, "force_xinerama") == 0) {
332 force_xinerama = true;
333 ELOG("Using Xinerama instead of RandR. This option should be "
334 "avoided at all cost because it does not refresh the list "
335 "of screens, so you cannot configure displays at runtime. "
336 "Please check if your driver really does not support RandR "
337 "and disable this option as soon as you can.\n");
339 } else if (strcmp(long_options[option_index].name, "disable-randr15") == 0 ||
340 strcmp(long_options[option_index].name, "disable_randr15") == 0) {
341 disable_randr15 = true;
343 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
344 disable_signalhandler = true;
346 } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
347 strcmp(long_options[option_index].name, "get_socketpath") == 0) {
348 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
350 printf("%s\n", socket_path);
355 } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
356 strcmp(long_options[option_index].name, "shmlog_size") == 0) {
357 shmlog_size = atoi(optarg);
358 /* Re-initialize logging immediately to get as many
359 * logmessages as possible into the SHM log. */
361 LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
363 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
365 layout_path = sstrdup(optarg);
366 delete_layout_path = true;
368 } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
369 strcmp(long_options[option_index].name, "fake_outputs") == 0) {
370 LOG("Initializing fake outputs: %s\n", optarg);
371 fake_outputs = sstrdup(optarg);
373 } else if (strcmp(long_options[option_index].name, "force-old-config-parser-v4.4-only") == 0) {
374 ELOG("You are passing --force-old-config-parser-v4.4-only, but that flag was removed by now.\n");
379 fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
380 fprintf(stderr, "\n");
381 fprintf(stderr, "\t-a disable autostart ('exec' lines in config)\n");
382 fprintf(stderr, "\t-c <file> use the provided configfile instead\n");
383 fprintf(stderr, "\t-C validate configuration file and exit\n");
384 fprintf(stderr, "\t-d all enable debug output\n");
385 fprintf(stderr, "\t-L <file> path to the serialized layout during restarts\n");
386 fprintf(stderr, "\t-v display version and exit\n");
387 fprintf(stderr, "\t-V enable verbose mode\n");
388 fprintf(stderr, "\n");
389 fprintf(stderr, "\t--force-xinerama\n"
390 "\tUse Xinerama instead of RandR.\n"
391 "\tThis option should only be used if you are stuck with the\n"
392 "\told nVidia closed source driver (older than 302.17), which does\n"
393 "\tnot support RandR.\n");
394 fprintf(stderr, "\n");
395 fprintf(stderr, "\t--get-socketpath\n"
396 "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
397 fprintf(stderr, "\n");
398 fprintf(stderr, "\t--shmlog-size <limit>\n"
399 "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
400 "\tto 0 disables SHM logging entirely.\n"
401 "\tThe default is %d bytes.\n",
403 fprintf(stderr, "\n");
404 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
405 "to send to a currently running i3 (like i3-msg). This allows you to\n"
406 "use nice and logical commands, such as:\n"
409 "\ti3 floating toggle\n"
416 if (only_check_config) {
417 exit(parse_configuration(override_configpath, false) ? 0 : 1);
420 /* If the user passes more arguments, we act like i3-msg would: Just send
421 * the arguments as an IPC message to i3. This allows for nice semantic
422 * commands such as 'i3 border none'. */
424 /* We enable verbose mode so that the user knows what’s going on.
425 * This should make it easier to find mistakes when the user passes
426 * arguments by mistake. */
429 LOG("Additional arguments passed. Sending them as a command to i3.\n");
430 char *payload = NULL;
431 while (optind < argc) {
433 payload = sstrdup(argv[optind]);
436 sasprintf(&both, "%s %s", payload, argv[optind]);
442 DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
443 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
445 ELOG("Could not get i3 IPC socket path\n");
449 int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
451 err(EXIT_FAILURE, "Could not create socket");
453 struct sockaddr_un addr;
454 memset(&addr, 0, sizeof(struct sockaddr_un));
455 addr.sun_family = AF_LOCAL;
456 strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
458 if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
459 err(EXIT_FAILURE, "Could not connect to i3");
461 if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_RUN_COMMAND,
462 (uint8_t *)payload) == -1)
463 err(EXIT_FAILURE, "IPC: write()");
466 uint32_t reply_length;
470 if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
472 err(EXIT_FAILURE, "IPC: read()");
475 if (reply_type != I3_IPC_REPLY_TYPE_COMMAND)
476 errx(EXIT_FAILURE, "IPC: received reply of type %d but expected %d (COMMAND)", reply_type, I3_IPC_REPLY_TYPE_COMMAND);
477 printf("%.*s\n", reply_length, reply);
482 /* Enable logging to handle the case when the user did not specify --shmlog-size */
485 /* Try to enable core dumps by default when running a debug build */
486 if (is_debug_build()) {
487 struct rlimit limit = {RLIM_INFINITY, RLIM_INFINITY};
488 setrlimit(RLIMIT_CORE, &limit);
490 /* The following code is helpful, but not required. We thus don’t pay
491 * much attention to error handling, non-linux or other edge cases. */
492 LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
493 size_t cwd_size = 1024;
494 char *cwd = smalloc(cwd_size);
496 while ((cwd_ret = getcwd(cwd, cwd_size)) == NULL && errno == ERANGE) {
497 cwd_size = cwd_size * 2;
498 cwd = srealloc(cwd, cwd_size);
501 LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
503 if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
504 memset(cwd, '\0', cwd_size);
505 if (read(patternfd, cwd, cwd_size) > 0)
506 /* a trailing newline is included in cwd */
507 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
513 LOG("i3 %s starting\n", i3_version);
515 conn = xcb_connect(NULL, &conn_screen);
516 if (xcb_connection_has_error(conn))
517 errx(EXIT_FAILURE, "Cannot open display\n");
519 sndisplay = sn_xcb_display_new(conn, NULL, NULL);
521 /* Initialize the libev event loop. This needs to be done before loading
522 * the config file because the parser will install an ev_child watcher
523 * for the nagbar when config errors are found. */
524 main_loop = EV_DEFAULT;
525 if (main_loop == NULL)
526 die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
528 root_screen = xcb_aux_get_screen(conn, conn_screen);
529 root = root_screen->root;
531 /* Place requests for the atoms we need as soon as possible */
532 #define xmacro(atom) \
533 xcb_intern_atom_cookie_t atom##_cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
534 #include "atoms.xmacro"
537 root_depth = root_screen->root_depth;
538 colormap = root_screen->default_colormap;
539 visual_type = xcb_aux_find_visual_by_attrs(root_screen, -1, 32);
540 if (visual_type != NULL) {
541 root_depth = xcb_aux_get_depth_of_visual(root_screen, visual_type->visual_id);
542 colormap = xcb_generate_id(conn);
544 xcb_void_cookie_t cm_cookie = xcb_create_colormap_checked(conn,
545 XCB_COLORMAP_ALLOC_NONE,
548 visual_type->visual_id);
550 xcb_generic_error_t *error = xcb_request_check(conn, cm_cookie);
552 ELOG("Could not create colormap. Error code: %d\n", error->error_code);
556 visual_type = get_visualtype(root_screen);
561 DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_type->visual_id);
562 DLOG("root_screen->height_in_pixels = %d, root_screen->height_in_millimeters = %d\n",
563 root_screen->height_in_pixels, root_screen->height_in_millimeters);
564 DLOG("One logical pixel corresponds to %d physical pixels on this display.\n", logical_px(1));
566 xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
567 xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
569 /* Setup NetWM atoms */
570 #define xmacro(name) \
572 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name##_cookie, NULL); \
574 ELOG("Could not get atom " #name "\n"); \
577 A_##name = reply->atom; \
580 #include "atoms.xmacro"
583 load_configuration(conn, override_configpath, false);
585 if (config.ipc_socket_path == NULL) {
586 /* Fall back to a file name in /tmp/ based on the PID */
587 if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
588 config.ipc_socket_path = get_process_filename("ipc-socket");
590 config.ipc_socket_path = sstrdup(config.ipc_socket_path);
593 if (config.force_xinerama) {
594 force_xinerama = true;
597 xcb_void_cookie_t cookie;
598 cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ROOT_EVENT_MASK});
599 xcb_generic_error_t *error = xcb_request_check(conn, cookie);
601 ELOG("Another window manager seems to be running (X error %d)\n", error->error_code);
602 #ifdef I3_ASAN_ENABLED
603 __lsan_do_leak_check();
608 xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
609 if (greply == NULL) {
610 ELOG("Could not get geometry of the root window, exiting\n");
613 DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
615 xcursor_load_cursors();
617 /* Set a cursor for the root window (otherwise the root window will show no
618 cursor until the first client is launched). */
619 if (xcursor_supported)
620 xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
622 xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
624 const xcb_query_extension_reply_t *extreply;
625 extreply = xcb_get_extension_data(conn, &xcb_xkb_id);
626 xkb_supported = extreply->present;
627 if (!extreply->present) {
628 DLOG("xkb is not present on this server\n");
630 DLOG("initializing xcb-xkb\n");
631 xcb_xkb_use_extension(conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
632 xcb_xkb_select_events(conn,
633 XCB_XKB_ID_USE_CORE_KBD,
634 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
636 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
641 /* Setting both, XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE and
642 * XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED, will lead to the
643 * X server sending us the full XKB state in KeyPress and KeyRelease:
644 * https://cgit.freedesktop.org/xorg/xserver/tree/xkb/xkbEvents.c?h=xorg-server-1.20.0#n927
646 * XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT enable detectable autorepeat:
647 * https://www.x.org/releases/current/doc/kbproto/xkbproto.html#Detectable_Autorepeat
648 * This affects bindings using the --release flag: instead of getting multiple KeyRelease
649 * events we get only one event when the key is physically released by the user.
651 const uint32_t mask = XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE |
652 XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED |
653 XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT;
654 xcb_xkb_per_client_flags_reply_t *pcf_reply;
655 /* The last three parameters are unset because they are only relevant
656 * when using a feature called “automatic reset of boolean controls”:
657 * https://www.x.org/releases/X11R7.7/doc/kbproto/xkbproto.html#Automatic_Reset_of_Boolean_Controls
659 pcf_reply = xcb_xkb_per_client_flags_reply(
661 xcb_xkb_per_client_flags(
663 XCB_XKB_ID_USE_CORE_KBD,
666 0 /* uint32_t ctrlsToChange */,
667 0 /* uint32_t autoCtrls */,
668 0 /* uint32_t autoCtrlsValues */),
671 #define PCF_REPLY_ERROR(_value) \
673 if (pcf_reply == NULL || !(pcf_reply->value & (_value))) { \
674 ELOG("Could not set " #_value "\n"); \
678 PCF_REPLY_ERROR(XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE);
679 PCF_REPLY_ERROR(XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED);
680 PCF_REPLY_ERROR(XCB_XKB_PER_CLIENT_FLAG_DETECTABLE_AUTO_REPEAT);
683 xkb_base = extreply->first_event;
688 property_handlers_init();
692 keysyms = xcb_key_symbols_alloc(conn);
694 xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
697 die("Could not load keymap\n");
702 bool needs_tree_init = true;
703 if (layout_path != NULL) {
704 LOG("Trying to restore the layout from \"%s\".\n", layout_path);
705 needs_tree_init = !tree_restore(layout_path, greply);
706 if (delete_layout_path) {
708 const char *dir = dirname(layout_path);
709 /* possibly fails with ENOTEMPTY if there are files (or
719 /* Setup fake outputs for testing */
720 if (fake_outputs == NULL && config.fake_outputs != NULL)
721 fake_outputs = config.fake_outputs;
723 if (fake_outputs != NULL) {
724 fake_outputs_init(fake_outputs);
726 config.fake_outputs = NULL;
727 } else if (force_xinerama) {
728 /* Force Xinerama (for drivers which don't support RandR yet, esp. the
729 * nVidia binary graphics driver), when specified either in the config
730 * file or on command-line */
733 DLOG("Checking for XRandR...\n");
734 randr_init(&randr_base, disable_randr15 || config.disable_randr15);
737 /* We need to force disabling outputs which have been loaded from the
738 * layout file but are no longer active. This can happen if the output has
739 * been disabled in the short time between writing the restart layout file
740 * and restarting i3. See #2326. */
741 if (layout_path != NULL && randr_base > -1) {
743 TAILQ_FOREACH(con, &(croot->nodes_head), nodes) {
745 TAILQ_FOREACH(output, &outputs, outputs) {
746 if (output->active || strcmp(con->name, output_primary_name(output)) != 0)
749 /* This will correctly correlate the output with its content
750 * container. We need to make the connection to properly
751 * disable the output. */
752 if (output->con == NULL) {
753 output_init_con(output);
754 output->changed = false;
757 output->to_be_disabled = true;
758 randr_disable_output(output);
764 scratchpad_fix_resolution();
766 xcb_query_pointer_reply_t *pointerreply;
767 Output *output = NULL;
768 if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
769 ELOG("Could not query pointer position, using first screen\n");
771 DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
772 output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
774 ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
775 pointerreply->root_x, pointerreply->root_y);
776 output = get_first_output();
779 con_activate(con_descend_focused(output_get_content(output->con)));
785 /* Create the UNIX domain socket for IPC */
786 int ipc_socket = ipc_create_socket(config.ipc_socket_path);
787 if (ipc_socket == -1) {
788 ELOG("Could not create the IPC socket, IPC disabled\n");
790 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
791 ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
792 ev_io_start(main_loop, ipc_io);
795 /* Also handle the UNIX domain sockets passed via socket activation. The
796 * parameter 1 means "remove the environment variables", we don’t want to
797 * pass these to child processes. */
798 listen_fds = sd_listen_fds(0);
800 ELOG("socket activation: Error in sd_listen_fds\n");
801 else if (listen_fds == 0)
802 DLOG("socket activation: no sockets passed\n");
805 for (int fd = SD_LISTEN_FDS_START;
806 fd < (SD_LISTEN_FDS_START + listen_fds);
808 DLOG("socket activation: also listening on fd %d\n", fd);
810 /* sd_listen_fds() enables FD_CLOEXEC by default.
811 * However, we need to keep the file descriptors open for in-place
812 * restarting, therefore we explicitly disable FD_CLOEXEC. */
813 if ((flags = fcntl(fd, F_GETFD)) < 0 ||
814 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
815 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
818 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
819 ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
820 ev_io_start(main_loop, ipc_io);
824 /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
826 ewmh_update_workarea();
828 /* Set the ewmh desktop properties. */
829 ewmh_update_current_desktop();
830 ewmh_update_number_of_desktops();
831 ewmh_update_desktop_names();
832 ewmh_update_desktop_viewport();
834 struct ev_io *xcb_watcher = scalloc(1, sizeof(struct ev_io));
835 xcb_prepare = scalloc(1, sizeof(struct ev_prepare));
837 ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
838 ev_io_start(main_loop, xcb_watcher);
840 ev_prepare_init(xcb_prepare, xcb_prepare_cb);
841 ev_prepare_start(main_loop, xcb_prepare);
845 /* What follows is a fugly consequence of X11 protocol race conditions like
846 * the following: In an i3 in-place restart, i3 will reparent all windows
847 * to the root window, then exec() itself. In the new process, it calls
848 * manage_existing_windows. However, in case any application sent a
849 * generated UnmapNotify message to the WM (as GIMP does), this message
850 * will be handled by i3 *after* managing the window, thus i3 thinks the
851 * window just closed itself. In reality, the message was sent in the time
852 * period where i3 wasn’t running yet.
854 * To prevent this, we grab the server (disables processing of any other
855 * connections), then discard all pending events (since we didn’t do
856 * anything, there cannot be any meaningful responses), then ungrab the
858 xcb_grab_server(conn);
861 xcb_generic_event_t *event;
862 while ((event = xcb_poll_for_event(conn)) != NULL) {
863 if (event->response_type == 0) {
868 /* Strip off the highest bit (set if the event is generated) */
869 int type = (event->response_type & 0x7F);
871 /* We still need to handle MapRequests which are sent in the
872 * timespan starting from when we register as a window manager and
873 * this piece of code which drops events. */
874 if (type == XCB_MAP_REQUEST)
875 handle_event(type, event);
879 manage_existing_windows(root);
881 xcb_ungrab_server(conn);
884 LOG("This is not an in-place restart, copying root window contents to a pixmap\n");
885 xcb_screen_t *root = xcb_aux_get_screen(conn, conn_screen);
886 uint16_t width = root->width_in_pixels;
887 uint16_t height = root->height_in_pixels;
888 xcb_pixmap_t pixmap = xcb_generate_id(conn);
889 xcb_gcontext_t gc = xcb_generate_id(conn);
891 xcb_create_pixmap(conn, root->root_depth, pixmap, root->root, width, height);
893 xcb_create_gc(conn, gc, root->root,
894 XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
895 (uint32_t[]){XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS});
897 xcb_copy_area(conn, root->root, pixmap, gc, 0, 0, 0, 0, width, height);
898 xcb_change_window_attributes(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]){pixmap});
900 xcb_free_gc(conn, gc);
901 xcb_free_pixmap(conn, pixmap);
904 #if defined(__OpenBSD__)
905 if (pledge("stdio rpath wpath cpath proc exec unix", NULL) == -1)
906 err(EXIT_FAILURE, "pledge");
909 if (!disable_signalhandler)
910 setup_signal_handler();
912 struct sigaction action;
914 action.sa_sigaction = handle_core_signal;
915 action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
916 sigemptyset(&action.sa_mask);
918 /* Catch all signals with default action "Core", see signal(7) */
919 if (sigaction(SIGQUIT, &action, NULL) == -1 ||
920 sigaction(SIGILL, &action, NULL) == -1 ||
921 sigaction(SIGABRT, &action, NULL) == -1 ||
922 sigaction(SIGFPE, &action, NULL) == -1 ||
923 sigaction(SIGSEGV, &action, NULL) == -1)
924 ELOG("Could not setup signal handler.\n");
927 setup_term_handlers();
928 /* Ignore SIGPIPE to survive errors when an IPC client disconnects
929 * while we are sending them a message */
930 signal(SIGPIPE, SIG_IGN);
932 /* Autostarting exec-lines */
934 while (!TAILQ_EMPTY(&autostarts)) {
935 struct Autostart *exec = TAILQ_FIRST(&autostarts);
937 LOG("auto-starting %s\n", exec->command);
938 start_application(exec->command, exec->no_startup_id);
941 TAILQ_REMOVE(&autostarts, exec, autostarts);
946 /* Autostarting exec_always-lines */
947 while (!TAILQ_EMPTY(&autostarts_always)) {
948 struct Autostart *exec_always = TAILQ_FIRST(&autostarts_always);
950 LOG("auto-starting (always!) %s\n", exec_always->command);
951 start_application(exec_always->command, exec_always->no_startup_id);
953 FREE(exec_always->command);
954 TAILQ_REMOVE(&autostarts_always, exec_always, autostarts_always);
958 /* Start i3bar processes for all configured bars */
959 Barconfig *barconfig;
960 TAILQ_FOREACH(barconfig, &barconfigs, configs) {
961 char *command = NULL;
962 sasprintf(&command, "%s %s --bar_id=%s --socket=\"%s\"",
963 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
964 barconfig->verbose ? "-V" : "",
965 barconfig->id, current_socketpath);
966 LOG("Starting bar process: %s\n", command);
967 start_application(command, true);
971 /* Make sure to destroy the event loop to invoke the cleanup callbacks
972 * when calling exit() */
975 ev_loop(main_loop, 0);