/* * Copyright © 2011-2014 Intel Corporation * * Permission to use, copy, modify, distribute, and sell this software * and its documentation for any purpose is hereby granted without * fee, provided that the above copyright notice appear in all copies * and that both that copyright notice and this permission notice * appear in supporting documentation, and that the name of the * copyright holders not be used in advertising or publicity * pertaining to distribution of the software without specific, * written prior permission. The copyright holders make no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied * warranty. * * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS * SOFTWARE. */ #include "xwayland.h" #include #include #include #include #include #include #include #include #include #include #include #ifdef XF86VIDMODE #include _X_EXPORT Bool noXFree86VidModeExtension; #endif void ddxGiveUp(enum ExitCode error) { } void OsVendorInit(void) { if (serverGeneration == 1) ForceClockId(CLOCK_MONOTONIC); } void OsVendorFatalError(const char *f, va_list args) { } #if defined(DDXBEFORERESET) void ddxBeforeReset(void) { return; } #endif #if INPUTTHREAD /** This function is called in Xserver/os/inputthread.c when starting the input thread. */ void ddxInputThreadInit(void) { } #endif _X_NORETURN static void _X_ATTRIBUTE_PRINTF(1, 2) xwl_give_up(const char *f, ...) { va_list args; va_start(args, f); VErrorFSigSafe(f, args); va_end(args); CloseWellKnownConnections(); OsCleanup(TRUE); fflush(stderr); exit(1); } void ddxUseMsg(void) { ErrorF("-rootless run rootless, requires wm support\n"); ErrorF("-wm fd create X client for wm on given fd\n"); ErrorF("-initfd fd add given fd as a listen socket for initialization clients\n"); ErrorF("-listenfd fd add given fd as a listen socket\n"); ErrorF("-listen fd deprecated, use \"-listenfd\" instead\n"); ErrorF("-eglstream use eglstream backend for nvidia GPUs\n"); } static int init_fd = -1; static int wm_fd = -1; static int listen_fds[5] = { -1, -1, -1, -1, -1 }; static int listen_fd_count = 0; static void xwl_add_listen_fd(int argc, char *argv[], int i) { NoListenAll = TRUE; if (listen_fd_count == ARRAY_SIZE(listen_fds)) FatalError("Too many -listen arguments given, max is %zu\n", ARRAY_SIZE(listen_fds)); listen_fds[listen_fd_count++] = atoi(argv[i + 1]); } int ddxProcessArgument(int argc, char *argv[], int i) { if (strcmp(argv[i], "-rootless") == 0) { return 1; } else if (strcmp(argv[i], "-listen") == 0) { CHECK_FOR_REQUIRED_ARGUMENTS(1); /* Not an FD */ if (!isdigit(*argv[i + 1])) return 0; LogMessage(X_WARNING, "Option \"-listen\" for file descriptors is deprecated\n" "Please use \"-listenfd\" instead.\n"); xwl_add_listen_fd (argc, argv, i); return 2; } else if (strcmp(argv[i], "-listenfd") == 0) { CHECK_FOR_REQUIRED_ARGUMENTS(1); xwl_add_listen_fd (argc, argv, i); return 2; } else if (strcmp(argv[i], "-wm") == 0) { CHECK_FOR_REQUIRED_ARGUMENTS(1); wm_fd = atoi(argv[i + 1]); return 2; } else if (strcmp(argv[i], "-initfd") == 0) { CHECK_FOR_REQUIRED_ARGUMENTS(1); init_fd = atoi(argv[i + 1]); return 2; } else if (strcmp(argv[i], "-shm") == 0) { return 1; } else if (strcmp(argv[i], "-eglstream") == 0) { return 1; } return 0; } static DevPrivateKeyRec xwl_client_private_key; static DevPrivateKeyRec xwl_window_private_key; static DevPrivateKeyRec xwl_screen_private_key; static DevPrivateKeyRec xwl_pixmap_private_key; static DevPrivateKeyRec xwl_pixmap_cb_private_key; static DevPrivateKeyRec xwl_damage_private_key; struct xwl_client * xwl_client_get(ClientPtr client) { return dixLookupPrivate(&client->devPrivates, &xwl_client_private_key); } static struct xwl_window * xwl_window_get(WindowPtr window) { return dixLookupPrivate(&window->devPrivates, &xwl_window_private_key); } struct xwl_screen * xwl_screen_get(ScreenPtr screen) { return dixLookupPrivate(&screen->devPrivates, &xwl_screen_private_key); } static Bool xwl_screen_has_viewport_support(struct xwl_screen *xwl_screen) { return wl_compositor_get_version(xwl_screen->compositor) >= WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION && xwl_screen->viewporter != NULL; } Bool xwl_screen_has_resolution_change_emulation(struct xwl_screen *xwl_screen) { /* Resolution change emulation is only supported in rootless mode and * it requires viewport support. */ return xwl_screen->rootless && xwl_screen_has_viewport_support(xwl_screen); } /* Return the output @ 0x0, falling back to the first output in the list */ struct xwl_output * xwl_screen_get_first_output(struct xwl_screen *xwl_screen) { struct xwl_output *xwl_output; xorg_list_for_each_entry(xwl_output, &xwl_screen->output_list, link) { if (xwl_output->x == 0 && xwl_output->y == 0) return xwl_output; } if (xorg_list_is_empty(&xwl_screen->output_list)) return NULL; return xorg_list_first_entry(&xwl_screen->output_list, struct xwl_output, link); } static void xwl_window_set_allow_commits(struct xwl_window *xwl_window, Bool allow, const char *debug_msg) { xwl_window->allow_commits = allow; DebugF("xwayland: win %d allow_commits = %d (%s)\n", xwl_window->window->drawable.id, allow, debug_msg); } static void xwl_window_set_allow_commits_from_property(struct xwl_window *xwl_window, PropertyPtr prop) { static Bool warned = FALSE; CARD32 *propdata; if (prop->propertyName != xwl_window->xwl_screen->allow_commits_prop) FatalError("Xwayland internal error: prop mismatch in %s.\n", __func__); if (prop->type != XA_CARDINAL || prop->format != 32 || prop->size != 1) { /* Not properly set, so fall back to safe and glitchy */ xwl_window_set_allow_commits(xwl_window, TRUE, "WM fault"); if (!warned) { LogMessage(X_WARNING, "Window manager is misusing property %s.\n", NameForAtom(prop->propertyName)); warned = TRUE; } return; } propdata = prop->data; xwl_window_set_allow_commits(xwl_window, !!propdata[0], "from property"); } static void xwl_window_property_allow_commits(struct xwl_window *xwl_window, PropertyStateRec *propstate) { switch (propstate->state) { case PropertyNewValue: xwl_window_set_allow_commits_from_property(xwl_window, propstate->prop); break; case PropertyDelete: xwl_window_set_allow_commits(xwl_window, TRUE, "property deleted"); break; default: break; } } static void xwl_property_callback(CallbackListPtr *pcbl, void *closure, void *calldata) { ScreenPtr screen = closure; PropertyStateRec *rec = calldata; struct xwl_screen *xwl_screen; struct xwl_window *xwl_window; if (rec->win->drawable.pScreen != screen) return; xwl_window = xwl_window_get(rec->win); if (!xwl_window) return; xwl_screen = xwl_screen_get(screen); if (rec->prop->propertyName == xwl_screen->allow_commits_prop) xwl_window_property_allow_commits(xwl_window, rec); } struct xwl_pixmap_buffer_release_cb { xwl_pixmap_cb callback; void *data; }; Bool xwl_pixmap_set_buffer_release_cb(PixmapPtr pixmap, xwl_pixmap_cb func, void *data) { struct xwl_pixmap_buffer_release_cb *xwl_pixmap_buffer_release_cb; xwl_pixmap_buffer_release_cb = dixLookupPrivate(&pixmap->devPrivates, &xwl_pixmap_cb_private_key); if (xwl_pixmap_buffer_release_cb == NULL) { xwl_pixmap_buffer_release_cb = calloc(1, sizeof (struct xwl_pixmap_buffer_release_cb)); if (xwl_pixmap_buffer_release_cb == NULL) { ErrorF("Failed to allocate pixmap callback data\n"); return FALSE; } dixSetPrivate(&pixmap->devPrivates, &xwl_pixmap_cb_private_key, xwl_pixmap_buffer_release_cb); } xwl_pixmap_buffer_release_cb->callback = func; xwl_pixmap_buffer_release_cb->data = data; return TRUE; } void xwl_pixmap_del_buffer_release_cb(PixmapPtr pixmap) { struct xwl_pixmap_buffer_release_cb *xwl_pixmap_buffer_release_cb; xwl_pixmap_buffer_release_cb = dixLookupPrivate(&pixmap->devPrivates, &xwl_pixmap_cb_private_key); if (xwl_pixmap_buffer_release_cb) { dixSetPrivate(&pixmap->devPrivates, &xwl_pixmap_cb_private_key, NULL); free(xwl_pixmap_buffer_release_cb); } } void xwl_pixmap_buffer_release_cb(void *data, struct wl_buffer *wl_buffer) { PixmapPtr pixmap = data; struct xwl_pixmap_buffer_release_cb *xwl_pixmap_buffer_release_cb; xwl_pixmap_buffer_release_cb = dixLookupPrivate(&pixmap->devPrivates, &xwl_pixmap_cb_private_key); if (xwl_pixmap_buffer_release_cb) (*xwl_pixmap_buffer_release_cb->callback) (pixmap, xwl_pixmap_buffer_release_cb->data); } static Bool xwl_close_screen(ScreenPtr screen) { struct xwl_screen *xwl_screen = xwl_screen_get(screen); struct xwl_output *xwl_output, *next_xwl_output; struct xwl_seat *xwl_seat, *next_xwl_seat; DeleteCallback(&PropertyStateCallback, xwl_property_callback, screen); xorg_list_for_each_entry_safe(xwl_output, next_xwl_output, &xwl_screen->output_list, link) xwl_output_destroy(xwl_output); xorg_list_for_each_entry_safe(xwl_seat, next_xwl_seat, &xwl_screen->seat_list, link) xwl_seat_destroy(xwl_seat); xwl_screen_release_tablet_manager(xwl_screen); RemoveNotifyFd(xwl_screen->wayland_fd); wl_display_disconnect(xwl_screen->display); screen->CloseScreen = xwl_screen->CloseScreen; free(xwl_screen); return screen->CloseScreen(screen); } struct xwl_window * xwl_window_from_window(WindowPtr window) { struct xwl_window *xwl_window; while (window) { xwl_window = xwl_window_get(window); if (xwl_window) return xwl_window; window = window->parent; } return NULL; } static struct xwl_seat * xwl_screen_get_default_seat(struct xwl_screen *xwl_screen) { if (xorg_list_is_empty(&xwl_screen->seat_list)) return NULL; return container_of(xwl_screen->seat_list.prev, struct xwl_seat, link); } static void xwl_cursor_warped_to(DeviceIntPtr device, ScreenPtr screen, ClientPtr client, WindowPtr window, SpritePtr sprite, int x, int y) { struct xwl_screen *xwl_screen = xwl_screen_get(screen); struct xwl_seat *xwl_seat = device->public.devicePrivate; struct xwl_window *xwl_window; WindowPtr focus; if (!xwl_seat) xwl_seat = xwl_screen_get_default_seat(xwl_screen); if (!window) window = XYToWindow(sprite, x, y); xwl_window = xwl_window_from_window(window); if (!xwl_window && xwl_seat->focus_window) { focus = xwl_seat->focus_window->window; /* Warps on non wl_surface backed Windows are only allowed * as long as the pointer stays within the focus window. */ if (x >= focus->drawable.x && y >= focus->drawable.y && x < focus->drawable.x + focus->drawable.width && y < focus->drawable.y + focus->drawable.height) { if (!window) { DebugF("Warp relative to pointer, assuming pointer focus\n"); xwl_window = xwl_seat->focus_window; } else if (window == screen->root) { DebugF("Warp on root window, assuming pointer focus\n"); xwl_window = xwl_seat->focus_window; } } } if (!xwl_window) return; xwl_seat_emulate_pointer_warp(xwl_seat, xwl_window, sprite, x, y); } static void xwl_cursor_confined_to(DeviceIntPtr device, ScreenPtr screen, WindowPtr window) { struct xwl_screen *xwl_screen = xwl_screen_get(screen); struct xwl_seat *xwl_seat = device->public.devicePrivate; struct xwl_window *xwl_window; if (!xwl_seat) xwl_seat = xwl_screen_get_default_seat(xwl_screen); /* xwl_seat hasn't been setup yet, don't do anything just yet */ if (!xwl_seat) return; if (window == screen->root) { xwl_seat_unconfine_pointer(xwl_seat); return; } xwl_window = xwl_window_from_window(window); if (!xwl_window && xwl_seat->focus_window) { /* Allow confining on InputOnly windows, but only if the geometry * is the same than the focus window. */ if (window->drawable.class == InputOnly) { DebugF("Confine on InputOnly window, assuming pointer focus\n"); xwl_window = xwl_seat->focus_window; } } if (!xwl_window) return; xwl_seat_confine_pointer(xwl_seat, xwl_window); } static void damage_report(DamagePtr pDamage, RegionPtr pRegion, void *data) { WindowPtr window = data; struct xwl_window *xwl_window = xwl_window_get(window); struct xwl_screen *xwl_screen; if (!xwl_window) return; xwl_screen = xwl_window->xwl_screen; #ifdef GLAMOR_HAS_GBM if (xwl_window->present_flipped) { /* This damage is from a Present flip, which already committed a new * buffer for the surface, so we don't need to do anything in response */ RegionEmpty(DamageRegion(pDamage)); xorg_list_del(&xwl_window->link_damage); xwl_window->present_flipped = FALSE; return; } #endif xorg_list_add(&xwl_window->link_damage, &xwl_screen->damage_window_list); } static void damage_destroy(DamagePtr pDamage, void *data) { } static Bool register_damage(WindowPtr window) { DamagePtr damage; damage = DamageCreate(damage_report, damage_destroy, DamageReportNonEmpty, FALSE, window->drawable.pScreen, window); if (damage == NULL) { ErrorF("Failed creating damage\n"); return FALSE; } DamageRegister(&window->drawable, damage); DamageSetReportAfterOp(damage, TRUE); dixSetPrivate(&window->devPrivates, &xwl_damage_private_key, damage); return TRUE; } static void unregister_damage(WindowPtr window) { DamagePtr damage; damage = dixLookupPrivate(&window->devPrivates, &xwl_damage_private_key); if (!damage) return; DamageUnregister(damage); DamageDestroy(damage); dixSetPrivate(&window->devPrivates, &xwl_damage_private_key, NULL); } static DamagePtr window_get_damage(WindowPtr window) { return dixLookupPrivate(&window->devPrivates, &xwl_damage_private_key); } static void shell_surface_ping(void *data, struct wl_shell_surface *shell_surface, uint32_t serial) { wl_shell_surface_pong(shell_surface, serial); } static void shell_surface_configure(void *data, struct wl_shell_surface *wl_shell_surface, uint32_t edges, int32_t width, int32_t height) { } static void shell_surface_popup_done(void *data, struct wl_shell_surface *wl_shell_surface) { } static const struct wl_shell_surface_listener shell_surface_listener = { shell_surface_ping, shell_surface_configure, shell_surface_popup_done }; void xwl_pixmap_set_private(PixmapPtr pixmap, struct xwl_pixmap *xwl_pixmap) { dixSetPrivate(&pixmap->devPrivates, &xwl_pixmap_private_key, xwl_pixmap); } struct xwl_pixmap * xwl_pixmap_get(PixmapPtr pixmap) { return dixLookupPrivate(&pixmap->devPrivates, &xwl_pixmap_private_key); } Bool xwl_window_has_viewport_enabled(struct xwl_window *xwl_window) { return (xwl_window->viewport != NULL); } static void xwl_window_disable_viewport(struct xwl_window *xwl_window) { assert (xwl_window->viewport); DebugF("XWAYLAND: disabling viewport\n"); wp_viewport_destroy(xwl_window->viewport); xwl_window->viewport = NULL; } static void xwl_window_enable_viewport(struct xwl_window *xwl_window, struct xwl_output *xwl_output, struct xwl_emulated_mode *emulated_mode) { /* If necessary disable old viewport to apply new settings */ if (xwl_window_has_viewport_enabled(xwl_window)) xwl_window_disable_viewport(xwl_window); DebugF("XWAYLAND: enabling viewport %dx%d -> %dx%d\n", emulated_mode->width, emulated_mode->height, xwl_output->width, xwl_output->height); xwl_window->viewport = wp_viewporter_get_viewport(xwl_window->xwl_screen->viewporter, xwl_window->surface); wp_viewport_set_source(xwl_window->viewport, wl_fixed_from_int(0), wl_fixed_from_int(0), wl_fixed_from_int(emulated_mode->width), wl_fixed_from_int(emulated_mode->height)); wp_viewport_set_destination(xwl_window->viewport, xwl_output->width, xwl_output->height); xwl_window->scale_x = (float)emulated_mode->width / xwl_output->width; xwl_window->scale_y = (float)emulated_mode->height / xwl_output->height; } static Bool xwl_screen_client_is_window_manager(struct xwl_screen *xwl_screen, ClientPtr client) { WindowPtr root = xwl_screen->screen->root; OtherClients *others; for (others = wOtherClients(root); others; others = others->next) { if (SameClient(others, client)) { if (others->mask & (SubstructureRedirectMask | ResizeRedirectMask)) return TRUE; } } return FALSE; } static ClientPtr xwl_window_get_owner(struct xwl_window *xwl_window) { WindowPtr window = xwl_window->window; ClientPtr client = wClient(window); /* If the toplevel window is owned by the window-manager, then the * actual client toplevel window has been reparented to a window-manager * decoration window. In that case return the client of the * first *and only* child of the toplevel (decoration) window. */ if (xwl_screen_client_is_window_manager(xwl_window->xwl_screen, client)) { if (window->firstChild && window->firstChild == window->lastChild) return wClient(window->firstChild); else return NULL; /* Should never happen, skip resolution emulation */ } return client; } static Bool xwl_window_should_enable_viewport(struct xwl_window *xwl_window, struct xwl_output **xwl_output_ret, struct xwl_emulated_mode **emulated_mode_ret) { struct xwl_screen *xwl_screen = xwl_window->xwl_screen; struct xwl_emulated_mode *emulated_mode; struct xwl_output *xwl_output; ClientPtr owner; if (!xwl_screen_has_resolution_change_emulation(xwl_screen)) return FALSE; owner = xwl_window_get_owner(xwl_window); if (!owner) return FALSE; /* 1. Test if the window matches the emulated mode on one of the outputs * This path gets hit by most games / libs (e.g. SDL, SFML, OGRE) */ xorg_list_for_each_entry(xwl_output, &xwl_screen->output_list, link) { emulated_mode = xwl_output_get_emulated_mode_for_client(xwl_output, owner); if (!emulated_mode) continue; if (xwl_window->x == xwl_output->x && xwl_window->y == xwl_output->y && xwl_window->width == emulated_mode->width && xwl_window->height == emulated_mode->height) { *emulated_mode_ret = emulated_mode; *xwl_output_ret = xwl_output; return TRUE; } } /* 2. Test if the window uses override-redirect + vidmode * and matches (fully covers) the entire screen. * This path gets hit by: allegro4, ClanLib-1.0. */ xwl_output = xwl_screen_get_first_output(xwl_screen); emulated_mode = xwl_output_get_emulated_mode_for_client(xwl_output, owner); if (xwl_output && xwl_window->window->overrideRedirect && emulated_mode && emulated_mode->from_vidmode && xwl_window->x == 0 && xwl_window->y == 0 && xwl_window->width == xwl_screen->width && xwl_window->height == xwl_screen->height) { *emulated_mode_ret = emulated_mode; *xwl_output_ret = xwl_output; return TRUE; } return FALSE; } static void xwl_window_check_resolution_change_emulation(struct xwl_window *xwl_window) { struct xwl_emulated_mode *emulated_mode; struct xwl_output *xwl_output; if (xwl_window_should_enable_viewport(xwl_window, &xwl_output, &emulated_mode)) xwl_window_enable_viewport(xwl_window, xwl_output, emulated_mode); else if (xwl_window_has_viewport_enabled(xwl_window)) xwl_window_disable_viewport(xwl_window); } void xwl_screen_check_resolution_change_emulation(struct xwl_screen *xwl_screen) { struct xwl_window *xwl_window; xorg_list_for_each_entry(xwl_window, &xwl_screen->window_list, link_window) xwl_window_check_resolution_change_emulation(xwl_window); } /* This checks if the passed in Window is a toplevel client window, note this * returns false for window-manager decoration windows and returns true for * the actual client top-level window even if it has been reparented to * a window-manager decoration window. */ Bool xwl_window_is_toplevel(WindowPtr window) { struct xwl_screen *xwl_screen = xwl_screen_get(window->drawable.pScreen); if (xwl_screen_client_is_window_manager(xwl_screen, wClient(window))) return FALSE; /* CSD and override-redirect toplevel windows */ if (window_get_damage(window)) return TRUE; /* Normal toplevel client windows, reparented to decoration window */ return (window->parent && window_get_damage(window->parent)); } static void xwl_window_init_allow_commits(struct xwl_window *xwl_window) { PropertyPtr prop = NULL; int ret; ret = dixLookupProperty(&prop, xwl_window->window, xwl_window->xwl_screen->allow_commits_prop, serverClient, DixReadAccess); if (ret == Success && prop) xwl_window_set_allow_commits_from_property(xwl_window, prop); else xwl_window_set_allow_commits(xwl_window, TRUE, "no property"); } static void send_surface_id_event(struct xwl_window *xwl_window) { static const char atom_name[] = "WL_SURFACE_ID"; static Atom type_atom; DeviceIntPtr dev; xEvent e; if (type_atom == None) type_atom = MakeAtom(atom_name, strlen(atom_name), TRUE); e.u.u.type = ClientMessage; e.u.u.detail = 32; e.u.clientMessage.window = xwl_window->window->drawable.id; e.u.clientMessage.u.l.type = type_atom; e.u.clientMessage.u.l.longs0 = wl_proxy_get_id((struct wl_proxy *) xwl_window->surface); e.u.clientMessage.u.l.longs1 = 0; e.u.clientMessage.u.l.longs2 = 0; e.u.clientMessage.u.l.longs3 = 0; e.u.clientMessage.u.l.longs4 = 0; dev = PickPointer(serverClient); DeliverEventsToWindow(dev, xwl_window->xwl_screen->screen->root, &e, 1, SubstructureRedirectMask, NullGrab); } static Bool ensure_surface_for_window(WindowPtr window) { ScreenPtr screen = window->drawable.pScreen; struct xwl_screen *xwl_screen; struct xwl_window *xwl_window; struct wl_region *region; if (xwl_window_get(window)) return TRUE; xwl_screen = xwl_screen_get(screen); if (xwl_screen->rootless) { if (window->redirectDraw != RedirectDrawManual) return TRUE; } else { if (window->parent) return TRUE; } xwl_window = calloc(1, sizeof *xwl_window); if (xwl_window == NULL) return FALSE; xwl_window->xwl_screen = xwl_screen; xwl_window->window = window; xwl_window->width = window->drawable.width; xwl_window->height = window->drawable.height; xwl_window->surface = wl_compositor_create_surface(xwl_screen->compositor); if (xwl_window->surface == NULL) { ErrorF("wl_display_create_surface failed\n"); goto err; } if (!xwl_screen->rootless) { xwl_window->shell_surface = wl_shell_get_shell_surface(xwl_screen->shell, xwl_window->surface); if (xwl_window->shell_surface == NULL) { ErrorF("Failed creating shell surface\n"); goto err_surf; } wl_shell_surface_add_listener(xwl_window->shell_surface, &shell_surface_listener, xwl_window); wl_shell_surface_set_toplevel(xwl_window->shell_surface); region = wl_compositor_create_region(xwl_screen->compositor); if (region == NULL) { ErrorF("Failed creating region\n"); goto err_surf; } wl_region_add(region, 0, 0, window->drawable.width, window->drawable.height); wl_surface_set_opaque_region(xwl_window->surface, region); wl_region_destroy(region); } wl_display_flush(xwl_screen->display); send_surface_id_event(xwl_window); wl_surface_set_user_data(xwl_window->surface, xwl_window); compRedirectWindow(serverClient, window, CompositeRedirectManual); dixSetPrivate(&window->devPrivates, &xwl_window_private_key, xwl_window); xorg_list_init(&xwl_window->link_damage); xorg_list_add(&xwl_window->link_window, &xwl_screen->window_list); xwl_window_init_allow_commits(xwl_window); return TRUE; err_surf: if (xwl_window->shell_surface) wl_shell_surface_destroy(xwl_window->shell_surface); wl_surface_destroy(xwl_window->surface); err: free(xwl_window); return FALSE; } static Bool xwl_realize_window(WindowPtr window) { ScreenPtr screen = window->drawable.pScreen; struct xwl_screen *xwl_screen; Bool ret; xwl_screen = xwl_screen_get(screen); screen->RealizeWindow = xwl_screen->RealizeWindow; ret = (*screen->RealizeWindow) (window); xwl_screen->RealizeWindow = screen->RealizeWindow; screen->RealizeWindow = xwl_realize_window; if (!ret) return FALSE; if (xwl_screen->rootless && !window->parent) { BoxRec box = { 0, 0, xwl_screen->width, xwl_screen->height }; RegionReset(&window->winSize, &box); RegionNull(&window->clipList); RegionNull(&window->borderClip); } if (xwl_screen->rootless ? (window->drawable.class == InputOutput && window->parent == window->drawable.pScreen->root) : !window->parent) { if (!register_damage(window)) return FALSE; } xwl_output_set_window_randr_emu_props(xwl_screen, window); return ensure_surface_for_window(window); } static Bool xwl_unrealize_window(WindowPtr window) { ScreenPtr screen = window->drawable.pScreen; struct xwl_screen *xwl_screen; struct xwl_window *xwl_window; struct xwl_seat *xwl_seat; Bool ret; xwl_screen = xwl_screen_get(screen); xorg_list_for_each_entry(xwl_seat, &xwl_screen->seat_list, link) { if (xwl_seat->focus_window && xwl_seat->focus_window->window == window) xwl_seat->focus_window = NULL; if (xwl_seat->tablet_focus_window && xwl_seat->tablet_focus_window->window == window) xwl_seat->tablet_focus_window = NULL; if (xwl_seat->last_xwindow == window) xwl_seat->last_xwindow = NullWindow; if (xwl_seat->cursor_confinement_window && xwl_seat->cursor_confinement_window->window == window) xwl_seat_unconfine_pointer(xwl_seat); if (xwl_seat->pointer_warp_emulator && xwl_seat->pointer_warp_emulator->locked_window && xwl_seat->pointer_warp_emulator->locked_window->window == window) xwl_seat_destroy_pointer_warp_emulator(xwl_seat); xwl_seat_clear_touch(xwl_seat, window); } compUnredirectWindow(serverClient, window, CompositeRedirectManual); screen->UnrealizeWindow = xwl_screen->UnrealizeWindow; ret = (*screen->UnrealizeWindow) (window); xwl_screen->UnrealizeWindow = screen->UnrealizeWindow; screen->UnrealizeWindow = xwl_unrealize_window; #ifdef GLAMOR_HAS_GBM if (xwl_screen->present) xwl_present_unrealize_window(window); #endif xwl_window = xwl_window_get(window); if (!xwl_window) return ret; if (xwl_window_has_viewport_enabled(xwl_window)) xwl_window_disable_viewport(xwl_window); wl_surface_destroy(xwl_window->surface); xorg_list_del(&xwl_window->link_damage); xorg_list_del(&xwl_window->link_window); unregister_damage(window); if (xwl_window->frame_callback) wl_callback_destroy(xwl_window->frame_callback); free(xwl_window); dixSetPrivate(&window->devPrivates, &xwl_window_private_key, NULL); return ret; } static void xwl_set_window_pixmap(WindowPtr window, PixmapPtr pixmap) { ScreenPtr screen = window->drawable.pScreen; struct xwl_screen *xwl_screen; xwl_screen = xwl_screen_get(screen); screen->SetWindowPixmap = xwl_screen->SetWindowPixmap; (*screen->SetWindowPixmap) (window, pixmap); xwl_screen->SetWindowPixmap = screen->SetWindowPixmap; screen->SetWindowPixmap = xwl_set_window_pixmap; if (!RegionNotEmpty(&window->winSize)) return; ensure_surface_for_window(window); } static void xwl_resize_window(WindowPtr window, int x, int y, unsigned int width, unsigned int height, WindowPtr sib) { ScreenPtr screen = window->drawable.pScreen; struct xwl_screen *xwl_screen; struct xwl_window *xwl_window; xwl_screen = xwl_screen_get(screen); xwl_window = xwl_window_get(window); screen->ResizeWindow = xwl_screen->ResizeWindow; (*screen->ResizeWindow) (window, x, y, width, height, sib); xwl_screen->ResizeWindow = screen->ResizeWindow; screen->ResizeWindow = xwl_resize_window; if (xwl_window) { xwl_window->x = x; xwl_window->y = y; xwl_window->width = width; xwl_window->height = height; xwl_window_check_resolution_change_emulation(xwl_window); } } static void frame_callback(void *data, struct wl_callback *callback, uint32_t time) { struct xwl_window *xwl_window = data; wl_callback_destroy (xwl_window->frame_callback); xwl_window->frame_callback = NULL; } static const struct wl_callback_listener frame_listener = { frame_callback }; static Bool xwl_destroy_window(WindowPtr window) { ScreenPtr screen = window->drawable.pScreen; struct xwl_screen *xwl_screen = xwl_screen_get(screen); Bool ret; #ifdef GLAMOR_HAS_GBM if (xwl_screen->present) xwl_present_cleanup(window); #endif screen->DestroyWindow = xwl_screen->DestroyWindow; if (screen->DestroyWindow) ret = screen->DestroyWindow (window); else ret = TRUE; xwl_screen->DestroyWindow = screen->DestroyWindow; screen->DestroyWindow = xwl_destroy_window; return ret; } void xwl_surface_damage(struct xwl_screen *xwl_screen, struct wl_surface *surface, int32_t x, int32_t y, int32_t width, int32_t height) { if (wl_surface_get_version(surface) >= WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION) wl_surface_damage_buffer(surface, x, y, width, height); else wl_surface_damage(surface, x, y, width, height); } static void xwl_window_post_damage(struct xwl_window *xwl_window) { struct xwl_screen *xwl_screen = xwl_window->xwl_screen; RegionPtr region; BoxPtr box; struct wl_buffer *buffer; PixmapPtr pixmap; int i; assert(!xwl_window->frame_callback); region = DamageRegion(window_get_damage(xwl_window->window)); pixmap = (*xwl_screen->screen->GetWindowPixmap) (xwl_window->window); #ifdef XWL_HAS_GLAMOR if (xwl_screen->glamor) buffer = xwl_glamor_pixmap_get_wl_buffer(pixmap, NULL); else #endif buffer = xwl_shm_pixmap_get_wl_buffer(pixmap); #ifdef XWL_HAS_GLAMOR if (xwl_screen->glamor) xwl_glamor_post_damage(xwl_window, pixmap, region); #endif wl_surface_attach(xwl_window->surface, buffer, 0, 0); /* Arbitrary limit to try to avoid flooding the Wayland * connection. If we flood it too much anyway, this could * abort in libwayland-client. */ if (RegionNumRects(region) > 256) { box = RegionExtents(region); xwl_surface_damage(xwl_screen, xwl_window->surface, box->x1, box->y1, box->x2 - box->x1, box->y2 - box->y1); } else { box = RegionRects(region); for (i = 0; i < RegionNumRects(region); i++, box++) { xwl_surface_damage(xwl_screen, xwl_window->surface, box->x1, box->y1, box->x2 - box->x1, box->y2 - box->y1); } } xwl_window->frame_callback = wl_surface_frame(xwl_window->surface); wl_callback_add_listener(xwl_window->frame_callback, &frame_listener, xwl_window); wl_surface_commit(xwl_window->surface); DamageEmpty(window_get_damage(xwl_window->window)); xorg_list_del(&xwl_window->link_damage); } static void xwl_screen_post_damage(struct xwl_screen *xwl_screen) { struct xwl_window *xwl_window, *next_xwl_window; xorg_list_for_each_entry_safe(xwl_window, next_xwl_window, &xwl_screen->damage_window_list, link_damage) { /* If we're waiting on a frame callback from the server, * don't attach a new buffer. */ if (xwl_window->frame_callback) continue; if (!xwl_window->allow_commits) continue; #ifdef XWL_HAS_GLAMOR if (xwl_screen->glamor && !xwl_glamor_allow_commits(xwl_window)) continue; #endif xwl_window_post_damage(xwl_window); } } static void registry_global(void *data, struct wl_registry *registry, uint32_t id, const char *interface, uint32_t version) { struct xwl_screen *xwl_screen = data; if (strcmp(interface, "wl_compositor") == 0) { uint32_t request_version = 1; if (version >= WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION) request_version = WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION; xwl_screen->compositor = wl_registry_bind(registry, id, &wl_compositor_interface, request_version); } else if (strcmp(interface, "wl_shm") == 0) { xwl_screen->shm = wl_registry_bind(registry, id, &wl_shm_interface, 1); } else if (strcmp(interface, "wl_shell") == 0) { xwl_screen->shell = wl_registry_bind(registry, id, &wl_shell_interface, 1); } else if (strcmp(interface, "wl_output") == 0 && version >= 2) { if (xwl_output_create(xwl_screen, id)) xwl_screen->expecting_event++; } else if (strcmp(interface, "zxdg_output_manager_v1") == 0) { /* We support xdg-output from version 1 to version 3 */ version = min(version, 3); xwl_screen->xdg_output_manager = wl_registry_bind(registry, id, &zxdg_output_manager_v1_interface, version); xwl_screen_init_xdg_output(xwl_screen); } else if (strcmp(interface, "wp_viewporter") == 0) { xwl_screen->viewporter = wl_registry_bind(registry, id, &wp_viewporter_interface, 1); } #ifdef XWL_HAS_GLAMOR else if (xwl_screen->glamor) { xwl_glamor_init_wl_registry(xwl_screen, registry, id, interface, version); } #endif } static void global_remove(void *data, struct wl_registry *registry, uint32_t name) { struct xwl_screen *xwl_screen = data; struct xwl_output *xwl_output, *tmp_xwl_output; xorg_list_for_each_entry_safe(xwl_output, tmp_xwl_output, &xwl_screen->output_list, link) { if (xwl_output->server_output_id == name) { xwl_output_remove(xwl_output); break; } } } static const struct wl_registry_listener registry_listener = { registry_global, global_remove }; static void xwl_read_events (struct xwl_screen *xwl_screen) { int ret; if (xwl_screen->wait_flush) return; ret = wl_display_read_events(xwl_screen->display); if (ret == -1) xwl_give_up("failed to read Wayland events: %s\n", strerror(errno)); xwl_screen->prepare_read = 0; ret = wl_display_dispatch_pending(xwl_screen->display); if (ret == -1) xwl_give_up("failed to dispatch Wayland events: %s\n", strerror(errno)); } static int xwl_display_pollout (struct xwl_screen *xwl_screen, int timeout) { struct pollfd poll_fd; poll_fd.fd = wl_display_get_fd(xwl_screen->display); poll_fd.events = POLLOUT; return xserver_poll(&poll_fd, 1, timeout); } static void xwl_dispatch_events (struct xwl_screen *xwl_screen) { int ret = 0; int ready; if (xwl_screen->wait_flush) goto pollout; while (xwl_screen->prepare_read == 0 && wl_display_prepare_read(xwl_screen->display) == -1) { ret = wl_display_dispatch_pending(xwl_screen->display); if (ret == -1) xwl_give_up("failed to dispatch Wayland events: %s\n", strerror(errno)); } xwl_screen->prepare_read = 1; pollout: ready = xwl_display_pollout(xwl_screen, 5); if (ready == -1 && errno != EINTR) xwl_give_up("error polling on XWayland fd: %s\n", strerror(errno)); if (ready > 0) ret = wl_display_flush(xwl_screen->display); if (ret == -1 && errno != EAGAIN) xwl_give_up("failed to write to XWayland fd: %s\n", strerror(errno)); xwl_screen->wait_flush = (ready == 0 || ready == -1 || ret == -1); } static void socket_handler(int fd, int ready, void *data) { struct xwl_screen *xwl_screen = data; xwl_read_events (xwl_screen); } static void wakeup_handler(void *data, int err) { } static void block_handler(void *data, void *timeout) { struct xwl_screen *xwl_screen = data; xwl_screen_post_damage(xwl_screen); xwl_dispatch_events (xwl_screen); } void xwl_sync_events (struct xwl_screen *xwl_screen) { xwl_dispatch_events (xwl_screen); xwl_read_events (xwl_screen); } static CARD32 add_client_fd(OsTimerPtr timer, CARD32 time, void *arg) { if (!AddClientOnOpenFD(wm_fd)) FatalError("Failed to add wm client\n"); TimerFree(timer); return 0; } static void listen_on_fds(void) { int i; for (i = 0; i < listen_fd_count; i++) ListenOnOpenFD(listen_fds[i], FALSE); } static void wm_selection_callback(CallbackListPtr *p, void *data, void *arg) { SelectionInfoRec *info = arg; struct xwl_screen *xwl_screen = data; static const char atom_name[] = "WM_S0"; static Atom atom_wm_s0; if (atom_wm_s0 == None) atom_wm_s0 = MakeAtom(atom_name, strlen(atom_name), TRUE); if (info->selection->selection != atom_wm_s0 || info->kind != SelectionSetOwner) return; listen_on_fds(); DeleteCallback(&SelectionCallback, wm_selection_callback, xwl_screen); } static Bool xwl_screen_init(ScreenPtr pScreen, int argc, char **argv) { static const char allow_commits[] = "_XWAYLAND_ALLOW_COMMITS"; struct xwl_screen *xwl_screen; Pixel red_mask, blue_mask, green_mask; int ret, bpc, green_bpc, i; #ifdef XWL_HAS_GLAMOR Bool use_eglstreams = FALSE; #endif xwl_screen = calloc(1, sizeof *xwl_screen); if (xwl_screen == NULL) return FALSE; if (!dixRegisterPrivateKey(&xwl_screen_private_key, PRIVATE_SCREEN, 0)) return FALSE; if (!dixRegisterPrivateKey(&xwl_window_private_key, PRIVATE_WINDOW, 0)) return FALSE; if (!dixRegisterPrivateKey(&xwl_pixmap_private_key, PRIVATE_PIXMAP, 0)) return FALSE; if (!dixRegisterPrivateKey(&xwl_pixmap_cb_private_key, PRIVATE_PIXMAP, 0)) return FALSE; if (!dixRegisterPrivateKey(&xwl_damage_private_key, PRIVATE_WINDOW, 0)) return FALSE; /* There are no easy to use new / delete client hooks, we could use a * ClientStateCallback, but it is easier to let the dix code manage the * memory for us. This will zero fill the initial xwl_client data. */ if (!dixRegisterPrivateKey(&xwl_client_private_key, PRIVATE_CLIENT, sizeof(struct xwl_client))) return FALSE; dixSetPrivate(&pScreen->devPrivates, &xwl_screen_private_key, xwl_screen); xwl_screen->screen = pScreen; #ifdef XWL_HAS_GLAMOR xwl_screen->glamor = 1; #endif for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-rootless") == 0) { xwl_screen->rootless = 1; } else if (strcmp(argv[i], "-shm") == 0) { xwl_screen->glamor = 0; } else if (strcmp(argv[i], "-eglstream") == 0) { #ifdef XWL_HAS_EGLSTREAM use_eglstreams = TRUE; #else ErrorF("xwayland glamor: this build does not have EGLStream support\n"); #endif } } #ifdef XWL_HAS_GLAMOR if (xwl_screen->glamor) xwl_glamor_init_backends(xwl_screen, use_eglstreams); #endif /* In rootless mode, we don't have any screen storage, and the only * rendering should be to redirected mode. */ if (xwl_screen->rootless) xwl_screen->root_clip_mode = ROOT_CLIP_INPUT_ONLY; else xwl_screen->root_clip_mode = ROOT_CLIP_FULL; xorg_list_init(&xwl_screen->output_list); xorg_list_init(&xwl_screen->seat_list); xorg_list_init(&xwl_screen->damage_window_list); xorg_list_init(&xwl_screen->window_list); xwl_screen->depth = 24; xwl_screen->display = wl_display_connect(NULL); if (xwl_screen->display == NULL) { ErrorF("could not connect to wayland server\n"); return FALSE; } if (!xwl_screen_init_output(xwl_screen)) return FALSE; xwl_screen->expecting_event = 0; xwl_screen->registry = wl_display_get_registry(xwl_screen->display); wl_registry_add_listener(xwl_screen->registry, ®istry_listener, xwl_screen); ret = wl_display_roundtrip(xwl_screen->display); if (ret == -1) { ErrorF("could not connect to wayland server\n"); return FALSE; } while (xwl_screen->expecting_event > 0) wl_display_roundtrip(xwl_screen->display); bpc = xwl_screen->depth / 3; green_bpc = xwl_screen->depth - 2 * bpc; blue_mask = (1 << bpc) - 1; green_mask = ((1 << green_bpc) - 1) << bpc; red_mask = blue_mask << (green_bpc + bpc); miSetVisualTypesAndMasks(xwl_screen->depth, ((1 << TrueColor) | (1 << DirectColor)), green_bpc, TrueColor, red_mask, green_mask, blue_mask); miSetPixmapDepths(); ret = fbScreenInit(pScreen, NULL, xwl_screen->width, xwl_screen->height, 96, 96, 0, BitsPerPixel(xwl_screen->depth)); if (!ret) return FALSE; fbPictureInit(pScreen, 0, 0); #ifdef HAVE_XSHMFENCE if (!miSyncShmScreenInit(pScreen)) return FALSE; #endif xwl_screen->wayland_fd = wl_display_get_fd(xwl_screen->display); SetNotifyFd(xwl_screen->wayland_fd, socket_handler, X_NOTIFY_READ, xwl_screen); RegisterBlockAndWakeupHandlers(block_handler, wakeup_handler, xwl_screen); pScreen->blackPixel = 0; pScreen->whitePixel = 1; ret = fbCreateDefColormap(pScreen); if (!xwl_screen_init_cursor(xwl_screen)) return FALSE; #ifdef XWL_HAS_GLAMOR if (xwl_screen->glamor) { xwl_glamor_select_backend(xwl_screen, use_eglstreams); if (xwl_screen->egl_backend == NULL || !xwl_glamor_init(xwl_screen)) { ErrorF("Failed to initialize glamor, falling back to sw\n"); xwl_screen->glamor = 0; } } if (xwl_screen->glamor && xwl_screen->rootless) xwl_screen->present = xwl_present_init(pScreen); #endif if (!xwl_screen->glamor) { xwl_screen->CreateScreenResources = pScreen->CreateScreenResources; pScreen->CreateScreenResources = xwl_shm_create_screen_resources; pScreen->CreatePixmap = xwl_shm_create_pixmap; pScreen->DestroyPixmap = xwl_shm_destroy_pixmap; } xwl_screen->RealizeWindow = pScreen->RealizeWindow; pScreen->RealizeWindow = xwl_realize_window; xwl_screen->UnrealizeWindow = pScreen->UnrealizeWindow; pScreen->UnrealizeWindow = xwl_unrealize_window; xwl_screen->DestroyWindow = pScreen->DestroyWindow; pScreen->DestroyWindow = xwl_destroy_window; xwl_screen->CloseScreen = pScreen->CloseScreen; pScreen->CloseScreen = xwl_close_screen; xwl_screen->ResizeWindow = pScreen->ResizeWindow; pScreen->ResizeWindow = xwl_resize_window; if (xwl_screen->rootless) { xwl_screen->SetWindowPixmap = pScreen->SetWindowPixmap; pScreen->SetWindowPixmap = xwl_set_window_pixmap; } pScreen->CursorWarpedTo = xwl_cursor_warped_to; pScreen->CursorConfinedTo = xwl_cursor_confined_to; xwl_screen->allow_commits_prop = MakeAtom(allow_commits, strlen(allow_commits), TRUE); if (xwl_screen->allow_commits_prop == BAD_RESOURCE) return FALSE; AddCallback(&PropertyStateCallback, xwl_property_callback, pScreen); wl_display_roundtrip(xwl_screen->display); while (xwl_screen->expecting_event) wl_display_roundtrip(xwl_screen->display); return ret; } _X_NORETURN static void _X_ATTRIBUTE_PRINTF(1, 0) xwl_log_handler(const char *format, va_list args) { char msg[256]; vsnprintf(msg, sizeof msg, format, args); FatalError("%s", msg); } static const ExtensionModule xwayland_extensions[] = { #ifdef XF86VIDMODE { xwlVidModeExtensionInit, XF86VIDMODENAME, &noXFree86VidModeExtension }, #endif }; void InitOutput(ScreenInfo * screen_info, int argc, char **argv) { int depths[] = { 1, 4, 8, 15, 16, 24, 32 }; int bpp[] = { 1, 8, 8, 16, 16, 32, 32 }; int i; for (i = 0; i < ARRAY_SIZE(depths); i++) { screen_info->formats[i].depth = depths[i]; screen_info->formats[i].bitsPerPixel = bpp[i]; screen_info->formats[i].scanlinePad = BITMAP_SCANLINE_PAD; } screen_info->imageByteOrder = IMAGE_BYTE_ORDER; screen_info->bitmapScanlineUnit = BITMAP_SCANLINE_UNIT; screen_info->bitmapScanlinePad = BITMAP_SCANLINE_PAD; screen_info->bitmapBitOrder = BITMAP_BIT_ORDER; screen_info->numPixmapFormats = ARRAY_SIZE(depths); if (serverGeneration == 1) LoadExtensionList(xwayland_extensions, ARRAY_SIZE(xwayland_extensions), FALSE); /* Cast away warning from missing printf annotation for * wl_log_func_t. Wayland 1.5 will have the annotation, so we can * remove the cast and require that when it's released. */ wl_log_set_handler_client((void *) xwl_log_handler); if (AddScreen(xwl_screen_init, argc, argv) == -1) { FatalError("Couldn't add screen\n"); } xorgGlxCreateVendor(); LocalAccessScopeUser(); if (wm_fd >= 0 || init_fd >= 0) { if (wm_fd >= 0) TimerSet(NULL, 0, 1, add_client_fd, NULL); if (init_fd >= 0) ListenOnOpenFD(init_fd, FALSE); AddCallback(&SelectionCallback, wm_selection_callback, NULL); } else if (listen_fd_count > 0) { listen_on_fds(); } }