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_check watcher around to be able to enable and disable it
39 * temporarily for drag_pointer(). */
40 static struct ev_check *xcb_check;
46 xcb_connection_t *conn;
47 /* The screen (0 when you are using DISPLAY=:0) of the connection 'conn' */
50 /* Display handle for libstartup-notification */
53 /* The last timestamp we got from X11 (timestamps are included in some events
54 * and are used for some things, like determining a unique ID in startup
56 xcb_timestamp_t last_timestamp = XCB_CURRENT_TIME;
58 xcb_screen_t *root_screen;
61 /* Color depth, visual id and colormap to use when creating windows and
62 * pixmaps. Will use 32 bit depth and an appropriate visual, if available,
63 * otherwise the root window’s default (usually 24 bit TrueColor). */
65 xcb_visualtype_t *visual_type;
66 xcb_colormap_t colormap;
68 struct ev_loop *main_loop;
70 xcb_key_symbols_t *keysyms;
72 /* Default shmlog size if not set by user. */
73 const int default_shmlog_size = 25 * 1024 * 1024;
75 /* The list of key bindings */
76 struct bindings_head *bindings;
78 /* The list of exec-lines */
79 struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts);
81 /* The list of exec_always lines */
82 struct autostarts_always_head autostarts_always = TAILQ_HEAD_INITIALIZER(autostarts_always);
84 /* The list of assignments */
85 struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments);
87 /* The list of workspace assignments (which workspace should end up on which
89 struct ws_assignments_head ws_assignments = TAILQ_HEAD_INITIALIZER(ws_assignments);
91 /* We hope that those are supported and set them to true */
92 bool xcursor_supported = true;
93 bool xkb_supported = true;
95 bool force_xinerama = false;
98 * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
99 * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
102 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
103 /* empty, because xcb_prepare_cb and xcb_check_cb are used */
107 * Flush before blocking (and waiting for new events)
110 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
115 * Instead of polling the X connection socket we leave this to
116 * xcb_poll_for_event() which knows better than we can ever know.
119 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
120 xcb_generic_event_t *event;
122 while ((event = xcb_poll_for_event(conn)) != NULL) {
123 if (event->response_type == 0) {
124 if (event_is_ignored(event->sequence, 0))
125 DLOG("Expected X11 Error received for sequence %x\n", event->sequence);
127 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
128 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
129 error->sequence, error->error_code);
135 /* Strip off the highest bit (set if the event is generated) */
136 int type = (event->response_type & 0x7F);
138 handle_event(type, event);
145 * Enable or disable the main X11 event handling function.
146 * This is used by drag_pointer() which has its own, modal event handler, which
147 * takes precedence over the normal event handler.
150 void main_set_x11_cb(bool enable) {
151 DLOG("Setting main X11 callback to enabled=%d\n", enable);
153 ev_check_start(main_loop, xcb_check);
154 /* Trigger the watcher explicitly to handle all remaining X11 events.
155 * drag_pointer()’s event handler exits in the middle of the loop. */
156 ev_feed_event(main_loop, xcb_check, 0);
158 ev_check_stop(main_loop, xcb_check);
163 * Exit handler which destroys the main_loop. Will trigger cleanup handlers.
166 static void i3_exit(void) {
167 /* We need ev >= 4 for the following code. Since it is not *that* important (it
168 * only makes sure that there are no i3-nagbar instances left behind) we still
169 * support old systems with libev 3. */
170 #if EV_VERSION_MAJOR >= 4
171 ev_loop_destroy(main_loop);
174 if (*shmlogname != '\0') {
175 fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
177 shm_unlink(shmlogname);
182 * (One-shot) Handler for all signals with default action "Term", see signal(7)
184 * Unlinks the SHM log and re-raises the signal.
187 static void handle_signal(int sig, siginfo_t *info, void *data) {
188 if (*shmlogname != '\0') {
189 shm_unlink(shmlogname);
194 int main(int argc, char *argv[]) {
195 /* Keep a symbol pointing to the I3_VERSION string constant so that we have
196 * it in gdb backtraces. */
197 static const char *_i3_version __attribute__((used)) = I3_VERSION;
198 char *override_configpath = NULL;
199 bool autostart = true;
200 char *layout_path = NULL;
201 bool delete_layout_path = false;
202 bool disable_randr15 = false;
203 char *fake_outputs = NULL;
204 bool disable_signalhandler = false;
205 bool only_check_config = false;
206 static struct option long_options[] = {
207 {"no-autostart", no_argument, 0, 'a'},
208 {"config", required_argument, 0, 'c'},
209 {"version", no_argument, 0, 'v'},
210 {"moreversion", no_argument, 0, 'm'},
211 {"more-version", no_argument, 0, 'm'},
212 {"more_version", no_argument, 0, 'm'},
213 {"help", no_argument, 0, 'h'},
214 {"layout", required_argument, 0, 'L'},
215 {"restart", required_argument, 0, 0},
216 {"force-xinerama", no_argument, 0, 0},
217 {"force_xinerama", no_argument, 0, 0},
218 {"disable-randr15", no_argument, 0, 0},
219 {"disable_randr15", no_argument, 0, 0},
220 {"disable-signalhandler", no_argument, 0, 0},
221 {"shmlog-size", required_argument, 0, 0},
222 {"shmlog_size", required_argument, 0, 0},
223 {"get-socketpath", no_argument, 0, 0},
224 {"get_socketpath", no_argument, 0, 0},
225 {"fake_outputs", required_argument, 0, 0},
226 {"fake-outputs", required_argument, 0, 0},
227 {"force-old-config-parser-v4.4-only", no_argument, 0, 0},
229 int option_index = 0, opt;
231 setlocale(LC_ALL, "");
233 /* Get the RLIMIT_CORE limit at startup time to restore this before
234 * starting processes. */
235 getrlimit(RLIMIT_CORE, &original_rlimit_core);
237 /* Disable output buffering to make redirects in .xsession actually useful for debugging */
238 if (!isatty(fileno(stdout)))
239 setbuf(stdout, NULL);
243 /* Init logging *before* initializing debug_build to guarantee early
247 /* On release builds, disable SHM logging by default. */
248 shmlog_size = (is_debug_build() || strstr(argv[0], "i3-with-shmlog") != NULL ? default_shmlog_size : 0);
252 while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
255 LOG("Autostart disabled using -a\n");
260 layout_path = sstrdup(optarg);
261 delete_layout_path = false;
264 FREE(override_configpath);
265 override_configpath = sstrdup(optarg);
268 LOG("Checking configuration file only (-C)\n");
269 only_check_config = true;
272 printf("i3 version %s © 2009 Michael Stapelberg and contributors\n", i3_version);
276 printf("Binary i3 version: %s © 2009 Michael Stapelberg and contributors\n", i3_version);
277 display_running_version();
284 LOG("Enabling debug logging\n");
285 set_debug_logging(true);
288 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
291 if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
292 strcmp(long_options[option_index].name, "force_xinerama") == 0) {
293 force_xinerama = true;
294 ELOG("Using Xinerama instead of RandR. This option should be "
295 "avoided at all cost because it does not refresh the list "
296 "of screens, so you cannot configure displays at runtime. "
297 "Please check if your driver really does not support RandR "
298 "and disable this option as soon as you can.\n");
300 } else if (strcmp(long_options[option_index].name, "disable-randr15") == 0 ||
301 strcmp(long_options[option_index].name, "disable_randr15") == 0) {
302 disable_randr15 = true;
304 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
305 disable_signalhandler = true;
307 } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
308 strcmp(long_options[option_index].name, "get_socketpath") == 0) {
309 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
311 printf("%s\n", socket_path);
316 } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
317 strcmp(long_options[option_index].name, "shmlog_size") == 0) {
318 shmlog_size = atoi(optarg);
319 /* Re-initialize logging immediately to get as many
320 * logmessages as possible into the SHM log. */
322 LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
324 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
326 layout_path = sstrdup(optarg);
327 delete_layout_path = true;
329 } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
330 strcmp(long_options[option_index].name, "fake_outputs") == 0) {
331 LOG("Initializing fake outputs: %s\n", optarg);
332 fake_outputs = sstrdup(optarg);
334 } else if (strcmp(long_options[option_index].name, "force-old-config-parser-v4.4-only") == 0) {
335 ELOG("You are passing --force-old-config-parser-v4.4-only, but that flag was removed by now.\n");
340 fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
341 fprintf(stderr, "\n");
342 fprintf(stderr, "\t-a disable autostart ('exec' lines in config)\n");
343 fprintf(stderr, "\t-c <file> use the provided configfile instead\n");
344 fprintf(stderr, "\t-C validate configuration file and exit\n");
345 fprintf(stderr, "\t-d all enable debug output\n");
346 fprintf(stderr, "\t-L <file> path to the serialized layout during restarts\n");
347 fprintf(stderr, "\t-v display version and exit\n");
348 fprintf(stderr, "\t-V enable verbose mode\n");
349 fprintf(stderr, "\n");
350 fprintf(stderr, "\t--force-xinerama\n"
351 "\tUse Xinerama instead of RandR.\n"
352 "\tThis option should only be used if you are stuck with the\n"
353 "\told nVidia closed source driver (older than 302.17), which does\n"
354 "\tnot support RandR.\n");
355 fprintf(stderr, "\n");
356 fprintf(stderr, "\t--get-socketpath\n"
357 "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
358 fprintf(stderr, "\n");
359 fprintf(stderr, "\t--shmlog-size <limit>\n"
360 "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
361 "\tto 0 disables SHM logging entirely.\n"
362 "\tThe default is %d bytes.\n",
364 fprintf(stderr, "\n");
365 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
366 "to send to a currently running i3 (like i3-msg). This allows you to\n"
367 "use nice and logical commands, such as:\n"
370 "\ti3 floating toggle\n"
377 if (only_check_config) {
378 exit(parse_configuration(override_configpath, false) ? 0 : 1);
381 /* If the user passes more arguments, we act like i3-msg would: Just send
382 * the arguments as an IPC message to i3. This allows for nice semantic
383 * commands such as 'i3 border none'. */
385 /* We enable verbose mode so that the user knows what’s going on.
386 * This should make it easier to find mistakes when the user passes
387 * arguments by mistake. */
390 LOG("Additional arguments passed. Sending them as a command to i3.\n");
391 char *payload = NULL;
392 while (optind < argc) {
394 payload = sstrdup(argv[optind]);
397 sasprintf(&both, "%s %s", payload, argv[optind]);
403 DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
404 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
406 ELOG("Could not get i3 IPC socket path\n");
410 int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
412 err(EXIT_FAILURE, "Could not create socket");
414 struct sockaddr_un addr;
415 memset(&addr, 0, sizeof(struct sockaddr_un));
416 addr.sun_family = AF_LOCAL;
417 strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
419 if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
420 err(EXIT_FAILURE, "Could not connect to i3");
422 if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_RUN_COMMAND,
423 (uint8_t *)payload) == -1)
424 err(EXIT_FAILURE, "IPC: write()");
427 uint32_t reply_length;
431 if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
433 err(EXIT_FAILURE, "IPC: read()");
436 if (reply_type != I3_IPC_REPLY_TYPE_COMMAND)
437 errx(EXIT_FAILURE, "IPC: received reply of type %d but expected %d (COMMAND)", reply_type, I3_IPC_REPLY_TYPE_COMMAND);
438 printf("%.*s\n", reply_length, reply);
443 /* Enable logging to handle the case when the user did not specify --shmlog-size */
446 /* Try to enable core dumps by default when running a debug build */
447 if (is_debug_build()) {
448 struct rlimit limit = {RLIM_INFINITY, RLIM_INFINITY};
449 setrlimit(RLIMIT_CORE, &limit);
451 /* The following code is helpful, but not required. We thus don’t pay
452 * much attention to error handling, non-linux or other edge cases. */
453 LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
454 size_t cwd_size = 1024;
455 char *cwd = smalloc(cwd_size);
457 while ((cwd_ret = getcwd(cwd, cwd_size)) == NULL && errno == ERANGE) {
458 cwd_size = cwd_size * 2;
459 cwd = srealloc(cwd, cwd_size);
462 LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
464 if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
465 memset(cwd, '\0', cwd_size);
466 if (read(patternfd, cwd, cwd_size) > 0)
467 /* a trailing newline is included in cwd */
468 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
474 LOG("i3 %s starting\n", i3_version);
476 conn = xcb_connect(NULL, &conn_screen);
477 if (xcb_connection_has_error(conn))
478 errx(EXIT_FAILURE, "Cannot open display\n");
480 sndisplay = sn_xcb_display_new(conn, NULL, NULL);
482 /* Initialize the libev event loop. This needs to be done before loading
483 * the config file because the parser will install an ev_child watcher
484 * for the nagbar when config errors are found. */
485 main_loop = EV_DEFAULT;
486 if (main_loop == NULL)
487 die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
489 root_screen = xcb_aux_get_screen(conn, conn_screen);
490 root = root_screen->root;
492 /* Place requests for the atoms we need as soon as possible */
493 #define xmacro(atom) \
494 xcb_intern_atom_cookie_t atom##_cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
495 #include "atoms.xmacro"
498 root_depth = root_screen->root_depth;
499 colormap = root_screen->default_colormap;
500 visual_type = xcb_aux_find_visual_by_attrs(root_screen, -1, 32);
501 if (visual_type != NULL) {
502 root_depth = xcb_aux_get_depth_of_visual(root_screen, visual_type->visual_id);
503 colormap = xcb_generate_id(conn);
505 xcb_void_cookie_t cm_cookie = xcb_create_colormap_checked(conn,
506 XCB_COLORMAP_ALLOC_NONE,
509 visual_type->visual_id);
511 xcb_generic_error_t *error = xcb_request_check(conn, cm_cookie);
513 ELOG("Could not create colormap. Error code: %d\n", error->error_code);
517 visual_type = get_visualtype(root_screen);
522 DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_type->visual_id);
523 DLOG("root_screen->height_in_pixels = %d, root_screen->height_in_millimeters = %d\n",
524 root_screen->height_in_pixels, root_screen->height_in_millimeters);
525 DLOG("One logical pixel corresponds to %d physical pixels on this display.\n", logical_px(1));
527 xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
528 xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
530 /* Setup NetWM atoms */
531 #define xmacro(name) \
533 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name##_cookie, NULL); \
535 ELOG("Could not get atom " #name "\n"); \
538 A_##name = reply->atom; \
541 #include "atoms.xmacro"
544 load_configuration(conn, override_configpath, false);
546 if (config.ipc_socket_path == NULL) {
547 /* Fall back to a file name in /tmp/ based on the PID */
548 if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
549 config.ipc_socket_path = get_process_filename("ipc-socket");
551 config.ipc_socket_path = sstrdup(config.ipc_socket_path);
554 if (config.force_xinerama) {
555 force_xinerama = true;
558 xcb_void_cookie_t cookie;
559 cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ROOT_EVENT_MASK});
560 xcb_generic_error_t *error = xcb_request_check(conn, cookie);
562 ELOG("Another window manager seems to be running (X error %d)\n", error->error_code);
563 #ifdef I3_ASAN_ENABLED
564 __lsan_do_leak_check();
569 xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
570 if (greply == NULL) {
571 ELOG("Could not get geometry of the root window, exiting\n");
574 DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
576 xcursor_load_cursors();
578 /* Set a cursor for the root window (otherwise the root window will show no
579 cursor until the first client is launched). */
580 if (xcursor_supported)
581 xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
583 xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
585 const xcb_query_extension_reply_t *extreply;
586 extreply = xcb_get_extension_data(conn, &xcb_xkb_id);
587 xkb_supported = extreply->present;
588 if (!extreply->present) {
589 DLOG("xkb is not present on this server\n");
591 DLOG("initializing xcb-xkb\n");
592 xcb_xkb_use_extension(conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
593 xcb_xkb_select_events(conn,
594 XCB_XKB_ID_USE_CORE_KBD,
595 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
597 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
602 /* Setting both, XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE and
603 * XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED, will lead to the
604 * X server sending us the full XKB state in KeyPress and KeyRelease:
605 * https://sources.debian.net/src/xorg-server/2:1.17.2-1.1/xkb/xkbEvents.c/?hl=927#L927
607 xcb_xkb_per_client_flags_reply_t *pcf_reply;
608 /* The last three parameters are unset because they are only relevant
609 * when using a feature called “automatic reset of boolean controls”:
610 * https://www.x.org/releases/X11R7.7/doc/kbproto/xkbproto.html#Automatic_Reset_of_Boolean_Controls
612 pcf_reply = xcb_xkb_per_client_flags_reply(
614 xcb_xkb_per_client_flags(
616 XCB_XKB_ID_USE_CORE_KBD,
617 XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE | XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED,
618 XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE | XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED,
619 0 /* uint32_t ctrlsToChange */,
620 0 /* uint32_t autoCtrls */,
621 0 /* uint32_t autoCtrlsValues */),
623 if (pcf_reply == NULL ||
624 !(pcf_reply->value & XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE)) {
625 ELOG("Could not set XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE\n");
627 if (pcf_reply == NULL ||
628 !(pcf_reply->value & XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED)) {
629 ELOG("Could not set XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED\n");
632 xkb_base = extreply->first_event;
637 property_handlers_init();
641 keysyms = xcb_key_symbols_alloc(conn);
643 xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
646 die("Could not load keymap\n");
651 bool needs_tree_init = true;
652 if (layout_path != NULL) {
653 LOG("Trying to restore the layout from \"%s\".\n", layout_path);
654 needs_tree_init = !tree_restore(layout_path, greply);
655 if (delete_layout_path) {
657 const char *dir = dirname(layout_path);
658 /* possibly fails with ENOTEMPTY if there are files (or
668 /* Setup fake outputs for testing */
669 if (fake_outputs == NULL && config.fake_outputs != NULL)
670 fake_outputs = config.fake_outputs;
672 if (fake_outputs != NULL) {
673 fake_outputs_init(fake_outputs);
675 config.fake_outputs = NULL;
676 } else if (force_xinerama) {
677 /* Force Xinerama (for drivers which don't support RandR yet, esp. the
678 * nVidia binary graphics driver), when specified either in the config
679 * file or on command-line */
682 DLOG("Checking for XRandR...\n");
683 randr_init(&randr_base, disable_randr15 || config.disable_randr15);
686 /* We need to force disabling outputs which have been loaded from the
687 * layout file but are no longer active. This can happen if the output has
688 * been disabled in the short time between writing the restart layout file
689 * and restarting i3. See #2326. */
690 if (layout_path != NULL && randr_base > -1) {
692 TAILQ_FOREACH(con, &(croot->nodes_head), nodes) {
694 TAILQ_FOREACH(output, &outputs, outputs) {
695 if (output->active || strcmp(con->name, output_primary_name(output)) != 0)
698 /* This will correctly correlate the output with its content
699 * container. We need to make the connection to properly
700 * disable the output. */
701 if (output->con == NULL) {
702 output_init_con(output);
703 output->changed = false;
706 output->to_be_disabled = true;
707 randr_disable_output(output);
713 scratchpad_fix_resolution();
715 xcb_query_pointer_reply_t *pointerreply;
716 Output *output = NULL;
717 if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
718 ELOG("Could not query pointer position, using first screen\n");
720 DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
721 output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
723 ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
724 pointerreply->root_x, pointerreply->root_y);
725 output = get_first_output();
728 con_focus(con_descend_focused(output_get_content(output->con)));
734 /* Create the UNIX domain socket for IPC */
735 int ipc_socket = ipc_create_socket(config.ipc_socket_path);
736 if (ipc_socket == -1) {
737 ELOG("Could not create the IPC socket, IPC disabled\n");
739 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
740 ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
741 ev_io_start(main_loop, ipc_io);
744 /* Also handle the UNIX domain sockets passed via socket activation. The
745 * parameter 1 means "remove the environment variables", we don’t want to
746 * pass these to child processes. */
747 listen_fds = sd_listen_fds(0);
749 ELOG("socket activation: Error in sd_listen_fds\n");
750 else if (listen_fds == 0)
751 DLOG("socket activation: no sockets passed\n");
754 for (int fd = SD_LISTEN_FDS_START;
755 fd < (SD_LISTEN_FDS_START + listen_fds);
757 DLOG("socket activation: also listening on fd %d\n", fd);
759 /* sd_listen_fds() enables FD_CLOEXEC by default.
760 * However, we need to keep the file descriptors open for in-place
761 * restarting, therefore we explicitly disable FD_CLOEXEC. */
762 if ((flags = fcntl(fd, F_GETFD)) < 0 ||
763 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
764 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
767 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
768 ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
769 ev_io_start(main_loop, ipc_io);
773 /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
775 ewmh_update_workarea();
777 /* Set the ewmh desktop properties. */
778 ewmh_update_current_desktop();
779 ewmh_update_number_of_desktops();
780 ewmh_update_desktop_names();
781 ewmh_update_desktop_viewport();
783 struct ev_io *xcb_watcher = scalloc(1, sizeof(struct ev_io));
784 xcb_check = scalloc(1, sizeof(struct ev_check));
785 struct ev_prepare *xcb_prepare = scalloc(1, sizeof(struct ev_prepare));
787 ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
788 ev_io_start(main_loop, xcb_watcher);
790 ev_check_init(xcb_check, xcb_check_cb);
791 ev_check_start(main_loop, xcb_check);
793 ev_prepare_init(xcb_prepare, xcb_prepare_cb);
794 ev_prepare_start(main_loop, xcb_prepare);
798 /* What follows is a fugly consequence of X11 protocol race conditions like
799 * the following: In an i3 in-place restart, i3 will reparent all windows
800 * to the root window, then exec() itself. In the new process, it calls
801 * manage_existing_windows. However, in case any application sent a
802 * generated UnmapNotify message to the WM (as GIMP does), this message
803 * will be handled by i3 *after* managing the window, thus i3 thinks the
804 * window just closed itself. In reality, the message was sent in the time
805 * period where i3 wasn’t running yet.
807 * To prevent this, we grab the server (disables processing of any other
808 * connections), then discard all pending events (since we didn’t do
809 * anything, there cannot be any meaningful responses), then ungrab the
811 xcb_grab_server(conn);
814 xcb_generic_event_t *event;
815 while ((event = xcb_poll_for_event(conn)) != NULL) {
816 if (event->response_type == 0) {
821 /* Strip off the highest bit (set if the event is generated) */
822 int type = (event->response_type & 0x7F);
824 /* We still need to handle MapRequests which are sent in the
825 * timespan starting from when we register as a window manager and
826 * this piece of code which drops events. */
827 if (type == XCB_MAP_REQUEST)
828 handle_event(type, event);
832 manage_existing_windows(root);
834 xcb_ungrab_server(conn);
837 LOG("This is not an in-place restart, copying root window contents to a pixmap\n");
838 xcb_screen_t *root = xcb_aux_get_screen(conn, conn_screen);
839 uint16_t width = root->width_in_pixels;
840 uint16_t height = root->height_in_pixels;
841 xcb_pixmap_t pixmap = xcb_generate_id(conn);
842 xcb_gcontext_t gc = xcb_generate_id(conn);
844 xcb_create_pixmap(conn, root->root_depth, pixmap, root->root, width, height);
846 xcb_create_gc(conn, gc, root->root,
847 XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
848 (uint32_t[]){XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS});
850 xcb_copy_area(conn, root->root, pixmap, gc, 0, 0, 0, 0, width, height);
851 xcb_change_window_attributes(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]){pixmap});
853 xcb_free_gc(conn, gc);
854 xcb_free_pixmap(conn, pixmap);
857 #if defined(__OpenBSD__)
858 if (pledge("stdio rpath wpath cpath proc exec unix", NULL) == -1)
859 err(EXIT_FAILURE, "pledge");
862 struct sigaction action;
864 action.sa_sigaction = handle_signal;
865 action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
866 sigemptyset(&action.sa_mask);
868 if (!disable_signalhandler)
869 setup_signal_handler();
871 /* Catch all signals with default action "Core", see signal(7) */
872 if (sigaction(SIGQUIT, &action, NULL) == -1 ||
873 sigaction(SIGILL, &action, NULL) == -1 ||
874 sigaction(SIGABRT, &action, NULL) == -1 ||
875 sigaction(SIGFPE, &action, NULL) == -1 ||
876 sigaction(SIGSEGV, &action, NULL) == -1)
877 ELOG("Could not setup signal handler.\n");
880 /* Catch all signals with default action "Term", see signal(7) */
881 if (sigaction(SIGHUP, &action, NULL) == -1 ||
882 sigaction(SIGINT, &action, NULL) == -1 ||
883 sigaction(SIGALRM, &action, NULL) == -1 ||
884 sigaction(SIGUSR1, &action, NULL) == -1 ||
885 sigaction(SIGUSR2, &action, NULL) == -1)
886 ELOG("Could not setup signal handler.\n");
888 /* Ignore SIGPIPE to survive errors when an IPC client disconnects
889 * while we are sending them a message */
890 signal(SIGPIPE, SIG_IGN);
892 /* Autostarting exec-lines */
894 while (!TAILQ_EMPTY(&autostarts)) {
895 struct Autostart *exec = TAILQ_FIRST(&autostarts);
897 LOG("auto-starting %s\n", exec->command);
898 start_application(exec->command, exec->no_startup_id);
901 TAILQ_REMOVE(&autostarts, exec, autostarts);
906 /* Autostarting exec_always-lines */
907 while (!TAILQ_EMPTY(&autostarts_always)) {
908 struct Autostart *exec_always = TAILQ_FIRST(&autostarts_always);
910 LOG("auto-starting (always!) %s\n", exec_always->command);
911 start_application(exec_always->command, exec_always->no_startup_id);
913 FREE(exec_always->command);
914 TAILQ_REMOVE(&autostarts_always, exec_always, autostarts_always);
918 /* Start i3bar processes for all configured bars */
919 Barconfig *barconfig;
920 TAILQ_FOREACH(barconfig, &barconfigs, configs) {
921 char *command = NULL;
922 sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
923 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
924 barconfig->id, current_socketpath);
925 LOG("Starting bar process: %s\n", command);
926 start_application(command, true);
930 /* Make sure to destroy the event loop to invoke the cleeanup callbacks
931 * when calling exit() */
934 ev_loop(main_loop, 0);