diff --git a/Makefile.am b/Makefile.am index cdf82ab43..f1593a235 100644 --- a/Makefile.am +++ b/Makefile.am @@ -182,6 +182,21 @@ nodist_libweston_@LIBWESTON_MAJOR@_la_SOURCES = \ BUILT_SOURCES += $(nodist_libweston_@LIBWESTON_MAJOR@_la_SOURCES) +lib_LTLIBRARIES += libcompositor_launch.la +libcompositor_launch_la_CPPFLAGS = $(AM_CPPFLAGS) -DIN_WESTON \ + -DMODULEDIR='"$(moduledir)"' \ + -DXSERVER_PATH='"@XSERVER_PATH@"' +libcompositor_launch_la_CFLAGS = $(AM_CFLAGS) $(COMPOSITOR_CFLAGS) $(LIBUNWIND_CFLAGS) +libcompositor_launch_la_LIBADD = \ + libweston-@LIBWESTON_MAJOR@.la libshared.la $(DLOPEN_LIBS) \ + $(CLOCK_GETRES_LIBS) -lm + +libcompositor_launch_la_SOURCES = \ + compositor/weston-screenshooter.c \ + compositor/text-backend.c \ + compositor/xwayland.c \ + compositor/compositor_launch.c + bin_PROGRAMS += weston weston_LDFLAGS = -export-dynamic @@ -189,17 +204,13 @@ weston_CPPFLAGS = $(AM_CPPFLAGS) -DIN_WESTON \ -DMODULEDIR='"$(moduledir)"' \ -DXSERVER_PATH='"@XSERVER_PATH@"' weston_CFLAGS = $(AM_CFLAGS) $(COMPOSITOR_CFLAGS) $(LIBUNWIND_CFLAGS) -weston_LDADD = libshared.la libweston-@LIBWESTON_MAJOR@.la \ +weston_LDADD = libshared.la libweston-@LIBWESTON_MAJOR@.la libcompositor_launch.la \ $(COMPOSITOR_LIBS) $(LIBUNWIND_LIBS) \ $(DLOPEN_LIBS) $(LIBINPUT_BACKEND_LIBS) \ $(CLOCK_GETRES_LIBS) \ -lm -weston_SOURCES = \ - compositor/main.c \ - compositor/weston-screenshooter.c \ - compositor/text-backend.c \ - compositor/xwayland.c +weston_SOURCES = compositor/main.c # Track this dependency explicitly instead of using BUILT_SOURCES. We # add BUILT_SOURCES to CLEANFILES, but we want to keep git-version.h @@ -273,7 +284,8 @@ pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = \ libweston/libweston-${LIBWESTON_MAJOR}.pc \ libweston-desktop/libweston-desktop-${LIBWESTON_MAJOR}.pc \ - compositor/weston.pc + compositor/weston.pc \ + compositor/compositor_launch.pc wayland_sessiondir = $(datadir)/wayland-sessions dist_wayland_session_DATA = compositor/weston.desktop @@ -298,6 +310,9 @@ libwestoninclude_HEADERS = \ libwestoninclude_HEADERS += \ libweston-desktop/libweston-desktop.h +libcompositor_launchincludedir = $(includedir)/weston +libcompositor_launchinclude_HEADERS = compositor/compositor_launch.h + westonincludedir = $(includedir)/weston westoninclude_HEADERS = compositor/weston.h diff --git a/compositor/compositor_launch.c b/compositor/compositor_launch.c new file mode 100644 index 000000000..360ce4278 --- /dev/null +++ b/compositor/compositor_launch.c @@ -0,0 +1,2102 @@ +/* + * Copyright © 2010-2011 Intel Corporation + * Copyright © 2008-2011 Kristian Høgsberg + * Copyright © 2012-2015 Collabora, Ltd. + * Copyright © 2010-2011 Benjamin Franzke + * Copyright © 2013 Jason Ekstrand + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "config.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "linux-dmabuf.h" + +#ifdef HAVE_LIBUNWIND +#define UNW_LOCAL_ONLY +#include +#endif + +#include "weston.h" +#include "compositor.h" +#include "../shared/os-compatibility.h" +#include "../shared/helpers.h" +#include "../shared/string-helpers.h" +#include "git-version.h" +#include "version.h" +#include "weston.h" + +#include "compositor-drm.h" +#include "compositor-headless.h" +#include "compositor-rdp.h" +#include "compositor-fbdev.h" +#include "compositor-x11.h" +#include "compositor-wayland.h" +#include "windowed-output-api.h" +#include "compositor_launch.h" + +#define WINDOW_TITLE "Weston Compositor" + +/*Maximum number of nested compositors that can be started in a + * process. Right now it is set to 50. This is also quite a large + * number. */ +#define MAX_COMPS_PER_PROCESS 50 + +#define COMPOSITOR_TERMINATE 1 +#define COMPOSITOR_TERMINATE_COMPLETE 2 + +struct wet_output_config { + int width; + int height; + int32_t scale; + uint32_t transform; +}; + +struct wet_compositor { + struct weston_config *config; + struct wet_output_config *parsed_options; + struct wl_listener pending_output_listener; + bool drm_use_current_mode; +}; + +struct compositor_obj { + struct weston_compositor *ec; + struct weston_config *config; + struct wl_event_source *evt_src_for_deinit; + struct wet_output_config *parsed_options; + struct wet_compositor wet_ec; + pthread_t compo_thread; + int ctx_id; + int deinit_sync_fd; + int ack_fd; + char *config_file; + char *backend; + char *shell; + char *socket_name; + char *option_modules; + char *modules; + bool run_compthred; + bool shut_down; +}; + +static pthread_mutex_t comp_mutex = PTHREAD_MUTEX_INITIALIZER; + +static struct compositor_obj* compositor_ctx_ids[MAX_COMPS_PER_PROCESS] = {NULL}; + +static FILE *weston_logfile = NULL; + +static int cached_tm_mday = -1; + +static struct wl_list child_process_list; + +static int weston_log_timestamp(void) +{ + struct timeval tv; + struct tm *brokendown_time; + char string[128]; + + gettimeofday(&tv, NULL); + + brokendown_time = localtime(&tv.tv_sec); + if (brokendown_time == NULL) + return fprintf(weston_logfile, "[(NULL)localtime] "); + + if (brokendown_time->tm_mday != cached_tm_mday) { + strftime(string, sizeof string, "%Y-%m-%d %Z", brokendown_time); + fprintf(weston_logfile, "Date: %s\n", string); + + cached_tm_mday = brokendown_time->tm_mday; + } + + strftime(string, sizeof string, "%H:%M:%S", brokendown_time); + + return fprintf(weston_logfile, "[%s.%03li] ", string, tv.tv_usec/1000); +} + +static void +custom_handler(const char *fmt, va_list arg) +{ + weston_log_timestamp(); + fprintf(weston_logfile, "libwayland: "); + vfprintf(weston_logfile, fmt, arg); +} + +static void +weston_log_file_open(const char *filename) +{ + wl_log_set_handler_server(custom_handler); + + if (filename != NULL) { + weston_logfile = fopen(filename, "a"); + if (weston_logfile) + os_fd_set_cloexec(fileno(weston_logfile)); + } + + if (weston_logfile == NULL) + weston_logfile = stderr; + else + setvbuf(weston_logfile, NULL, _IOLBF, 256); +} + +static void +weston_log_file_close(void) +{ + if ((weston_logfile != stderr) && (weston_logfile != NULL)) + fclose(weston_logfile); + weston_logfile = stderr; +} + +static int +vlog(const char *fmt, va_list ap) +{ + int l; + + l = weston_log_timestamp(); + l += vfprintf(weston_logfile, fmt, ap); + + return l; +} + +static int +vlog_continue(const char *fmt, va_list argp) +{ + return vfprintf(weston_logfile, fmt, argp); +} + + +static void +child_client_exec(int sockfd, const char *path) +{ + int clientfd; + char s[32]; + sigset_t allsigs; + + /* do not give our signal mask to the new process */ + sigfillset(&allsigs); + sigprocmask(SIG_UNBLOCK, &allsigs, NULL); + + /* Launch clients as the user. Do not lauch clients with wrong euid.*/ + if (seteuid(getuid()) == -1) { + weston_log("compositor: failed seteuid\n"); + return; + } + + /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a + * non-CLOEXEC fd to pass through exec. */ + clientfd = dup(sockfd); + if (clientfd == -1) { + weston_log("compositor: dup failed: %m\n"); + return; + } + + snprintf(s, sizeof s, "%d", clientfd); + setenv("WAYLAND_SOCKET", s, 1); + + if (execl(path, path, NULL) < 0) + weston_log("compositor: executing '%s' failed: %m\n", + path); +} + +WL_EXPORT struct wl_client * +weston_client_launch(struct weston_compositor *compositor, + struct weston_process *proc, + const char *path, + weston_process_cleanup_func_t cleanup) +{ + int sv[2]; + pid_t pid; + struct wl_client *client; + + weston_log("launching '%s'\n", path); + + if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) { + weston_log("weston_client_launch: " + "socketpair failed while launching '%s': %m\n", + path); + return NULL; + } + + pid = fork(); + if (pid == -1) { + close(sv[0]); + close(sv[1]); + weston_log("weston_client_launch: " + "fork failed while launching '%s': %m\n", path); + return NULL; + } + + if (pid == 0) { + child_client_exec(sv[1], path); + _exit(-1); + } + + close(sv[1]); + + client = wl_client_create(compositor->wl_display, sv[0]); + if (!client) { + close(sv[0]); + weston_log("weston_client_launch: " + "wl_client_create failed while launching '%s'.\n", + path); + return NULL; + } + + proc->pid = pid; + proc->cleanup = cleanup; + weston_watch_process(proc); + + return client; +} + +WL_EXPORT void +weston_watch_process(struct weston_process *process) +{ + wl_list_insert(&child_process_list, &process->link); +} + +struct process_info { + struct weston_process proc; + char *path; +}; + +static void +process_handle_sigchld(struct weston_process *process, int status) +{ + struct process_info *pinfo = + container_of(process, struct process_info, proc); + + /* + * There are no guarantees whether this runs before or after + * the wl_client destructor. + */ + + if (WIFEXITED(status)) { + weston_log("%s exited with status %d\n", pinfo->path, + WEXITSTATUS(status)); + } else if (WIFSIGNALED(status)) { + weston_log("%s died on signal %d\n", pinfo->path, + WTERMSIG(status)); + } else { + weston_log("%s disappeared\n", pinfo->path); + } + + free(pinfo->path); + free(pinfo); +} + +WL_EXPORT struct wl_client * +weston_client_start(struct weston_compositor *compositor, const char *path) +{ + struct process_info *pinfo; + struct wl_client *client; + + pinfo = zalloc(sizeof *pinfo); + if (!pinfo) + return NULL; + + pinfo->path = strdup(path); + if (!pinfo->path) + goto out_free; + + client = weston_client_launch(compositor, &pinfo->proc, path, + process_handle_sigchld); + if (!client) + goto out_str; + + return client; + +out_str: + free(pinfo->path); + +out_free: + free(pinfo); + + return NULL; +} + +static void +log_uname(void) +{ + struct utsname usys; + + uname(&usys); + + weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release, + usys.version, usys.machine); +} + +static struct wet_compositor * +to_wet_compositor(struct weston_compositor *compositor) +{ + return weston_compositor_get_user_data(compositor); +} + +static void +wet_set_pending_output_handler(struct weston_compositor *ec, + wl_notify_func_t handler) +{ + struct wet_compositor *compositor = to_wet_compositor(ec); + + compositor->pending_output_listener.notify = handler; + wl_signal_add(&ec->output_pending_signal, &compositor->pending_output_listener); +} + +static struct wet_output_config * +wet_init_parsed_options(struct weston_compositor *ec) +{ + struct wet_compositor *compositor = to_wet_compositor(ec); + struct wet_output_config *config; + + config = zalloc(sizeof *config); + + if (!config) { + perror("out of memory"); + return NULL; + } + + config->width = 0; + config->height = 0; + config->scale = 0; + config->transform = UINT32_MAX; + + compositor->parsed_options = config; + + return config; +} + +WL_EXPORT struct weston_config * +wet_get_config(struct weston_compositor *ec) +{ + struct wet_compositor *compositor = to_wet_compositor(ec); + + return compositor->config; +} + +static const char xdg_error_message[] = + "fatal: environment variable XDG_RUNTIME_DIR is not set.\n"; + +static const char xdg_wrong_message[] = + "fatal: environment variable XDG_RUNTIME_DIR\n" + "is set to \"%s\", which is not a directory.\n"; + +static const char xdg_wrong_mode_message[] = + "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n" + "correctly. Unix access mode must be 0700 (current mode is %o),\n" + "and must be owned by the user (current owner is UID %d).\n"; + +static const char xdg_detail_message[] = + "Refer to your distribution on how to get it, or\n" + "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n" + "on how to implement it.\n"; + +static int +verify_xdg_runtime_dir(void) +{ + int ret = 0; + char *dir = getenv("XDG_RUNTIME_DIR"); + struct stat s; + + if (!dir) { + weston_log(xdg_error_message); + weston_log_continue(xdg_detail_message); + ret = -EINVAL; + } + + if (stat(dir, &s) || !S_ISDIR(s.st_mode)) { + weston_log(xdg_wrong_message, dir); + weston_log_continue(xdg_detail_message); + ret = -EINVAL; + } + + if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) { + weston_log(xdg_wrong_mode_message, + dir, s.st_mode & 0777, s.st_uid); + weston_log_continue(xdg_detail_message); + } + return ret; +} + +static void +usage(void) +{ + fprintf(stderr, + "Usage: weston [OPTIONS]\n\n" + "This is weston version " VERSION ", the Wayland reference compositor.\n" + "Weston supports multiple backends, and depending on which backend is in use\n" + "different options will be accepted.\n\n" + + + "Core options:\n\n" + " --version\t\tPrint weston version\n" + " -B, --backend=MODULE\tBackend module, one of\n" +#if defined(BUILD_DRM_COMPOSITOR) + "\t\t\t\tdrm-backend.so\n" +#endif +#if defined(BUILD_FBDEV_COMPOSITOR) + "\t\t\t\tfbdev-backend.so\n" +#endif +#if defined(BUILD_HEADLESS_COMPOSITOR) + "\t\t\t\theadless-backend.so\n" +#endif +#if defined(BUILD_RDP_COMPOSITOR) + "\t\t\t\trdp-backend.so\n" +#endif +#if defined(BUILD_WAYLAND_COMPOSITOR) + "\t\t\t\twayland-backend.so\n" +#endif +#if defined(BUILD_X11_COMPOSITOR) + "\t\t\t\tx11-backend.so\n" +#endif + " --shell=MODULE\tShell module, defaults to desktop-shell.so\n" + " -S, --socket=NAME\tName of socket to listen on\n" + " -i, --idle-time=SECS\tIdle time in seconds\n" + " --modules\t\tLoad the comma-separated list of modules\n" + " --log=FILE\t\tLog to the given file\n" + " -c, --config=FILE\tConfig file to load, defaults to weston.ini\n" + " --no-config\t\tDo not read weston.ini\n" + " -h, --help\t\tThis help message\n\n"); + +#if defined(BUILD_DRM_COMPOSITOR) + fprintf(stderr, + "Options for drm-backend.so:\n\n" + " --connector=ID\tBring up only this connector\n" + " --seat=SEAT\t\tThe seat that weston should run on\n" + " --tty=TTY\t\tThe tty to use\n" + " --use-pixman\t\tUse the pixman (CPU) renderer\n" + " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n"); +#endif + +#if defined(BUILD_FBDEV_COMPOSITOR) + fprintf(stderr, + "Options for fbdev-backend.so:\n\n" + " --tty=TTY\t\tThe tty to use\n" + " --device=DEVICE\tThe framebuffer device to use\n" + "\n"); +#endif + +#if defined(BUILD_HEADLESS_COMPOSITOR) + fprintf(stderr, + "Options for headless-backend.so:\n\n" + " --width=WIDTH\t\tWidth of memory surface\n" + " --height=HEIGHT\tHeight of memory surface\n" + " --transform=TR\tThe output transformation, TR is one of:\n" + "\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n" + " --use-pixman\t\tUse the pixman (CPU) renderer (default: no rendering)\n" + " --no-outputs\t\tDo not create any virtual outputs\n" + "\n"); +#endif + +#if defined(BUILD_RDP_COMPOSITOR) + fprintf(stderr, + "Options for rdp-backend.so:\n\n" + " --width=WIDTH\t\tWidth of desktop\n" + " --height=HEIGHT\tHeight of desktop\n" + " --env-socket\t\tUse socket defined in RDP_FD env variable as peer connection\n" + " --address=ADDR\tThe address to bind\n" + " --port=PORT\t\tThe port to listen on\n" + " --no-clients-resize\tThe RDP peers will be forced to the size of the desktop\n" + " --rdp4-key=FILE\tThe file containing the key for RDP4 encryption\n" + " --rdp-tls-cert=FILE\tThe file containing the certificate for TLS encryption\n" + " --rdp-tls-key=FILE\tThe file containing the private key for TLS encryption\n" + "\n"); +#endif + +#if defined(BUILD_WAYLAND_COMPOSITOR) + fprintf(stderr, + "Options for wayland-backend.so:\n\n" + " --width=WIDTH\t\tWidth of Wayland surface\n" + " --height=HEIGHT\tHeight of Wayland surface\n" + " --scale=SCALE\t\tScale factor of output\n" + " --fullscreen\t\tRun in fullscreen mode\n" + " --use-pixman\t\tUse the pixman (CPU) renderer\n" + " --output-count=COUNT\tCreate multiple outputs\n" + " --sprawl\t\tCreate one fullscreen output for every parent output\n" + " --display=DISPLAY\tWayland display to connect to\n\n"); +#endif + +#if defined(BUILD_X11_COMPOSITOR) + fprintf(stderr, + "Options for x11-backend.so:\n\n" + " --width=WIDTH\t\tWidth of X window\n" + " --height=HEIGHT\tHeight of X window\n" + " --scale=SCALE\t\tScale factor of output\n" + " --fullscreen\t\tRun in fullscreen mode\n" + " --use-pixman\t\tUse the pixman (CPU) renderer\n" + " --output-count=COUNT\tCreate multiple outputs\n" + " --no-input\t\tDont create input devices\n\n"); +#endif + +} + +static const char * +clock_name(clockid_t clk_id) +{ + static const char *names[] = { + [CLOCK_REALTIME] = "CLOCK_REALTIME", + [CLOCK_MONOTONIC] = "CLOCK_MONOTONIC", + [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW", + [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE", + [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE", +#ifdef CLOCK_BOOTTIME + [CLOCK_BOOTTIME] = "CLOCK_BOOTTIME", +#endif + }; + + if (clk_id < 0 || (unsigned)clk_id >= ARRAY_LENGTH(names)) + return "unknown"; + + return names[clk_id]; +} + +static const struct { + uint32_t bit; /* enum weston_capability */ + const char *desc; +} capability_strings[] = { + { WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" }, + { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" }, +}; + +static void +weston_compositor_log_capabilities(struct weston_compositor *compositor) +{ + unsigned i; + int yes; + struct timespec res; + + weston_log("Compositor capabilities:\n"); + for (i = 0; i < ARRAY_LENGTH(capability_strings); i++) { + yes = compositor->capabilities & capability_strings[i].bit; + weston_log_continue(STAMP_SPACE "%s %s\n", + capability_strings[i].desc, + yes ? "yes" : "no"); + } + + weston_log_continue(STAMP_SPACE "presentation clock: %s, id %d\n", + clock_name(compositor->presentation_clock), + compositor->presentation_clock); + + if (clock_getres(compositor->presentation_clock, &res) == 0) + weston_log_continue(STAMP_SPACE + "presentation clock resolution: %d.%09ld s\n", + (int)res.tv_sec, res.tv_nsec); + else + weston_log_continue(STAMP_SPACE + "presentation clock resolution: N/A\n"); +} + +static void +handle_primary_client_destroyed(struct wl_listener *listener, void *data) +{ + struct wl_client *client = data; + + weston_log("Primary client died. Closing...\n"); + + wl_display_terminate(wl_client_get_display(client)); +} + +static int +weston_create_listening_socket(struct wl_display *display, const char *socket_name) +{ + if (socket_name) { + if (wl_display_add_socket(display, socket_name)) { + weston_log("fatal: failed to add socket: %m\n"); + return -1; + } + } else { + socket_name = wl_display_add_socket_auto(display); + if (!socket_name) { + weston_log("fatal: failed to add socket: %m\n"); + return -1; + } + } + + setenv("WAYLAND_DISPLAY", socket_name, 1); + + return 0; +} + +WL_EXPORT void * +wet_load_module_entrypoint(const char *name, const char *entrypoint) +{ + const char *builddir = getenv("WESTON_BUILD_DIR"); + char path[PATH_MAX]; + void *module, *init; + size_t len; + + if (name == NULL) + return NULL; + + if (name[0] != '/') { + if (builddir) + len = snprintf(path, sizeof path, "%s/.libs/%s", builddir, + name); + else + len = snprintf(path, sizeof path, "%s/%s", MODULEDIR, + name); + } else { + len = snprintf(path, sizeof path, "%s", name); + } + + /* snprintf returns the length of the string it would've written, + * _excluding_ the NUL byte. So even being equal to the size of + * our buffer is an error here. */ + if (len >= sizeof path) + return NULL; + + module = dlopen(path, RTLD_NOW | RTLD_NOLOAD); + if (module) { + weston_log("Module '%s' already loaded\n", path); + dlclose(module); + return NULL; + } + + weston_log("Loading module '%s'\n", path); + module = dlopen(path, RTLD_NOW); + if (!module) { + weston_log("Failed to load module: %s\n", dlerror()); + return NULL; + } + + init = dlsym(module, entrypoint); + if (!init) { + weston_log("Failed to lookup init function: %s\n", dlerror()); + dlclose(module); + return NULL; + } + + return init; +} + + +WL_EXPORT int +wet_load_module(struct weston_compositor *compositor, + const char *name, int *argc, char *argv[]) +{ + int ret = -EINVAL; + int (*module_init)(struct weston_compositor *ec, + int *argc, char *argv[]); + + module_init = wet_load_module_entrypoint(name, "wet_module_init"); + if (module_init) + ret = module_init(compositor, argc, argv); + return ret; +} + +static int +wet_load_shell(struct weston_compositor *compositor, + const char *name, int *argc, char *argv[]) +{ + int (*shell_init)(struct weston_compositor *ec, + int *argc, char *argv[]); + + shell_init = wet_load_module_entrypoint(name, "wet_shell_init"); + if (!shell_init) + return -1; + if (shell_init(compositor, argc, argv) < 0) + return -1; + return 0; +} + +static int +load_modules(struct weston_compositor *ec, const char *modules, + int *argc, char *argv[], int32_t *xwayland) +{ + const char *p, *end; + char buffer[256]; + + if (modules == NULL) + return 0; + + p = modules; + while (*p) { + end = strchrnul(p, ','); + snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p); + + if (strstr(buffer, "xwayland.so")) { + weston_log("Old Xwayland module loading detected: " + "Please use --xwayland command line option " + "or set xwayland=true in the [core] section " + "in weston.ini\n"); + *xwayland = 1; + } else { + if (wet_load_module(ec, buffer, argc, argv) < 0) + return -1; + } + + p = end; + while (*p == ',') + p++; + } + + return 0; +} + +static int +weston_compositor_init_config(struct weston_compositor *ec, + struct weston_config *config) +{ + struct xkb_rule_names xkb_names; + struct weston_config_section *s; + int repaint_msec; + int vt_switching; + + s = weston_config_get_section(config, "keyboard", NULL, NULL); + weston_config_section_get_string(s, "keymap_rules", + (char **) &xkb_names.rules, NULL); + weston_config_section_get_string(s, "keymap_model", + (char **) &xkb_names.model, NULL); + weston_config_section_get_string(s, "keymap_layout", + (char **) &xkb_names.layout, NULL); + weston_config_section_get_string(s, "keymap_variant", + (char **) &xkb_names.variant, NULL); + weston_config_section_get_string(s, "keymap_options", + (char **) &xkb_names.options, NULL); + + if (weston_compositor_set_xkb_rule_names(ec, &xkb_names) < 0) + return -1; + + weston_config_section_get_int(s, "repeat-rate", + &ec->kb_repeat_rate, 40); + weston_config_section_get_int(s, "repeat-delay", + &ec->kb_repeat_delay, 400); + + weston_config_section_get_bool(s, "vt-switching", + &vt_switching, true); + ec->vt_switching = vt_switching; + + s = weston_config_get_section(config, "core", NULL, NULL); + weston_config_section_get_int(s, "repaint-window", &repaint_msec, + ec->repaint_msec); + if (repaint_msec < -10 || repaint_msec > 1000) { + weston_log("Invalid repaint_window value in config: %d\n", + repaint_msec); + } else { + ec->repaint_msec = repaint_msec; + } + weston_log("Output repaint window is %d ms maximum.\n", + ec->repaint_msec); + + return 0; +} + +static char * +weston_choose_default_backend(void) +{ + char *backend = NULL; + + if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET")) + backend = strdup("wayland-backend.so"); + else if (getenv("DISPLAY")) + backend = strdup("x11-backend.so"); + else + backend = strdup(WESTON_NATIVE_BACKEND); + + return backend; +} + +static const struct { const char *name; uint32_t token; } transforms[] = { + { "normal", WL_OUTPUT_TRANSFORM_NORMAL }, + { "90", WL_OUTPUT_TRANSFORM_90 }, + { "180", WL_OUTPUT_TRANSFORM_180 }, + { "270", WL_OUTPUT_TRANSFORM_270 }, + { "flipped", WL_OUTPUT_TRANSFORM_FLIPPED }, + { "flipped-90", WL_OUTPUT_TRANSFORM_FLIPPED_90 }, + { "flipped-180", WL_OUTPUT_TRANSFORM_FLIPPED_180 }, + { "flipped-270", WL_OUTPUT_TRANSFORM_FLIPPED_270 }, +}; + +WL_EXPORT int +weston_parse_transform(const char *transform, uint32_t *out) +{ + unsigned int i; + + for (i = 0; i < ARRAY_LENGTH(transforms); i++) + if (strcmp(transforms[i].name, transform) == 0) { + *out = transforms[i].token; + return 0; + } + + *out = WL_OUTPUT_TRANSFORM_NORMAL; + return -1; +} + +WL_EXPORT const char * +weston_transform_to_string(uint32_t output_transform) +{ + unsigned int i; + + for (i = 0; i < ARRAY_LENGTH(transforms); i++) + if (transforms[i].token == output_transform) + return transforms[i].name; + + return ""; +} + +static int +load_configuration(struct weston_config **config, int32_t noconfig, + const char *config_file) +{ + const char *file = "weston.ini"; + const char *full_path; + + *config = NULL; + + if (config_file) + file = config_file; + + if (noconfig == 0) + *config = weston_config_parse(file); + + if (*config) { + full_path = weston_config_get_full_path(*config); + + weston_log("Using config file '%s'\n", full_path); + setenv(WESTON_CONFIG_FILE_ENV_VAR, full_path, 1); + + return 0; + } + + if (config_file && noconfig == 0) { + weston_log("fatal: error opening or reading config file" + " '%s'.\n", config_file); + + return -1; + } + + weston_log("Starting with no config file.\n"); + setenv(WESTON_CONFIG_FILE_ENV_VAR, "", 1); + + return 0; +} + +static void +handle_exit(struct weston_compositor *c) +{ + wl_display_terminate(c->wl_display); +} + +static void +wet_output_set_scale(struct weston_output *output, + struct weston_config_section *section, + int32_t default_scale, + int32_t parsed_scale) +{ + int32_t scale = default_scale; + + if (section) + weston_config_section_get_int(section, "scale", &scale, default_scale); + + if (parsed_scale) + scale = parsed_scale; + + weston_output_set_scale(output, scale); +} + +/* UINT32_MAX is treated as invalid because 0 is a valid + * enumeration value and the parameter is unsigned + */ +static void +wet_output_set_transform(struct weston_output *output, + struct weston_config_section *section, + uint32_t default_transform, + uint32_t parsed_transform) +{ + char *t; + uint32_t transform = default_transform; + + if (section) { + weston_config_section_get_string(section, + "transform", &t, "normal"); + + if (weston_parse_transform(t, &transform) < 0) { + weston_log("Invalid transform \"%s\" for output %s\n", + t, output->name); + transform = default_transform; + } + free(t); + } + + if (parsed_transform != UINT32_MAX) + transform = parsed_transform; + + weston_output_set_transform(output, transform); +} + +static int +wet_configure_windowed_output_from_config(struct weston_output *output, + struct wet_output_config *defaults) +{ + const struct weston_windowed_output_api *api = + weston_windowed_output_get_api(output->compositor); + + struct weston_config *wc = wet_get_config(output->compositor); + struct weston_config_section *section = NULL; + struct wet_compositor *compositor = to_wet_compositor(output->compositor); + struct wet_output_config *parsed_options = compositor->parsed_options; + int width = defaults->width; + int height = defaults->height; + + assert(parsed_options); + + if (!api) { + weston_log("Cannot use weston_windowed_output_api.\n"); + return -1; + } + + section = weston_config_get_section(wc, "output", "name", output->name); + + if (section) { + char *mode; + + weston_config_section_get_string(section, "mode", &mode, NULL); + if (!mode || sscanf(mode, "%dx%d", &width, + &height) != 2) { + weston_log("Invalid mode for output %s. Using defaults.\n", + output->name); + width = defaults->width; + height = defaults->height; + } + free(mode); + } + + if (parsed_options->width) + width = parsed_options->width; + + if (parsed_options->height) + height = parsed_options->height; + + wet_output_set_scale(output, section, defaults->scale, parsed_options->scale); + wet_output_set_transform(output, section, defaults->transform, parsed_options->transform); + + if (api->output_set_size(output, width, height) < 0) { + weston_log("Cannot configure output \"%s\" using weston_windowed_output_api.\n", + output->name); + return -1; + } + + weston_output_enable(output); + + return 0; +} + +static void +configure_input_device(struct weston_compositor *compositor, + struct libinput_device *device) +{ + struct weston_config_section *s; + struct weston_config *config = wet_get_config(compositor); + int enable_tap; + int enable_tap_default; + + s = weston_config_get_section(config, + "libinput", NULL, NULL); + + if (libinput_device_config_tap_get_finger_count(device) > 0) { + enable_tap_default = + libinput_device_config_tap_get_default_enabled( + device); + weston_config_section_get_bool(s, "enable_tap", + &enable_tap, + enable_tap_default); + libinput_device_config_tap_set_enabled(device, + enable_tap); + } +} + +static void +drm_backend_output_configure(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + struct weston_config *wc = wet_get_config(output->compositor); + struct wet_compositor *wet = to_wet_compositor(output->compositor); + struct weston_config_section *section; + const struct weston_drm_output_api *api = weston_drm_output_get_api(output->compositor); + enum weston_drm_backend_output_mode mode = + WESTON_DRM_BACKEND_OUTPUT_PREFERRED; + + char *s; + char *modeline = NULL; + char *gbm_format = NULL; + char *seat = NULL; + + if (!api) { + weston_log("Cannot use weston_drm_output_api.\n"); + return; + } + + section = weston_config_get_section(wc, "output", "name", output->name); + weston_config_section_get_string(section, "mode", &s, "preferred"); + + if (strcmp(s, "off") == 0) { + weston_output_disable(output); + free(s); + return; + } else if (wet->drm_use_current_mode || strcmp(s, "current") == 0) { + mode = WESTON_DRM_BACKEND_OUTPUT_CURRENT; + } else if (strcmp(s, "preferred") != 0) { + modeline = s; + s = NULL; + } + free(s); + + if (api->set_mode(output, mode, modeline) < 0) { + weston_log("Cannot configure an output using weston_drm_output_api.\n"); + free(modeline); + return; + } + free(modeline); + + wet_output_set_scale(output, section, 1, 0); + wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX); + + weston_config_section_get_string(section, + "gbm-format", &gbm_format, NULL); + + api->set_gbm_format(output, gbm_format); + free(gbm_format); + + weston_config_section_get_string(section, "seat", &seat, ""); + + api->set_seat(output, seat); + free(seat); + + weston_output_enable(output); +} + +static int +load_drm_backend(struct weston_compositor *c, + int *argc, char **argv, struct weston_config *wc) +{ + struct weston_drm_backend_config config = {{ 0, }}; + struct weston_config_section *section; + struct wet_compositor *wet = to_wet_compositor(c); + int ret = 0; + + wet->drm_use_current_mode = false; + + const struct weston_option options[] = { + { WESTON_OPTION_INTEGER, "connector", 0, &config.connector }, + { WESTON_OPTION_STRING, "seat", 0, &config.seat_id }, + { WESTON_OPTION_INTEGER, "tty", 0, &config.tty }, + { WESTON_OPTION_BOOLEAN, "current-mode", 0, &wet->drm_use_current_mode }, + { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, + }; + + parse_options(options, ARRAY_LENGTH(options), argc, argv); + + section = weston_config_get_section(wc, "core", NULL, NULL); + weston_config_section_get_string(section, + "gbm-format", &config.gbm_format, + NULL); + + config.base.struct_version = WESTON_DRM_BACKEND_CONFIG_VERSION; + config.base.struct_size = sizeof(struct weston_drm_backend_config); + config.configure_device = configure_input_device; + + ret = weston_compositor_load_backend(c, WESTON_BACKEND_DRM, + &config.base); + + wet_set_pending_output_handler(c, drm_backend_output_configure); + + free(config.gbm_format); + free(config.seat_id); + + return ret; +} + +static void +headless_backend_output_configure(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + struct wet_output_config defaults = { + .width = 1024, + .height = 640, + .scale = 1, + .transform = WL_OUTPUT_TRANSFORM_NORMAL + }; + + if (wet_configure_windowed_output_from_config(output, &defaults) < 0) + weston_log("Cannot configure output \"%s\".\n", output->name); +} + +static int +load_headless_backend(struct weston_compositor *c, + int *argc, char **argv, struct weston_config *wc) +{ + const struct weston_windowed_output_api *api; + struct weston_headless_backend_config config = {{ 0, }}; + int no_outputs = 0; + int ret = 0; + char *transform = NULL; + + struct wet_output_config *parsed_options = wet_init_parsed_options(c); + if (!parsed_options) + return -1; + + const struct weston_option options[] = { + { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, + { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, + { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, + { WESTON_OPTION_STRING, "transform", 0, &transform }, + { WESTON_OPTION_BOOLEAN, "no-outputs", 0, &no_outputs }, + }; + + parse_options(options, ARRAY_LENGTH(options), argc, argv); + + if (transform) { + if (weston_parse_transform(transform, &parsed_options->transform) < 0) { + weston_log("Invalid transform \"%s\"\n", transform); + parsed_options->transform = UINT32_MAX; + } + free(transform); + } + + config.base.struct_version = WESTON_HEADLESS_BACKEND_CONFIG_VERSION; + config.base.struct_size = sizeof(struct weston_headless_backend_config); + + /* load the actual wayland backend and configure it */ + ret = weston_compositor_load_backend(c, WESTON_BACKEND_HEADLESS, + &config.base); + + if (ret < 0) + return ret; + + wet_set_pending_output_handler(c, headless_backend_output_configure); + + if (!no_outputs) { + api = weston_windowed_output_get_api(c); + + if (!api) { + weston_log("Cannot use weston_windowed_output_api.\n"); + return -1; + } + + if (api->output_create(c, "headless") < 0) + return -1; + } + + return 0; +} + +static void +rdp_backend_output_configure(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + struct wet_compositor *compositor = to_wet_compositor(output->compositor); + struct wet_output_config *parsed_options = compositor->parsed_options; + const struct weston_rdp_output_api *api = weston_rdp_output_get_api(output->compositor); + int width = 640; + int height = 480; + + assert(parsed_options); + + if (!api) { + weston_log("Cannot use weston_rdp_output_api.\n"); + return; + } + + if (parsed_options->width) + width = parsed_options->width; + + if (parsed_options->height) + height = parsed_options->height; + + weston_output_set_scale(output, 1); + weston_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL); + + if (api->output_set_size(output, width, height) < 0) { + weston_log("Cannot configure output \"%s\" using weston_rdp_output_api.\n", + output->name); + return; + } + + weston_output_enable(output); +} + +static void +weston_rdp_backend_config_init(struct weston_rdp_backend_config *config) +{ + config->base.struct_version = WESTON_RDP_BACKEND_CONFIG_VERSION; + config->base.struct_size = sizeof(struct weston_rdp_backend_config); + + config->bind_address = NULL; + config->port = 3389; + config->rdp_key = NULL; + config->server_cert = NULL; + config->server_key = NULL; + config->env_socket = 0; + config->no_clients_resize = 0; +} + +static int +load_rdp_backend(struct weston_compositor *c, + int *argc, char *argv[], struct weston_config *wc) +{ + struct weston_rdp_backend_config config = {{ 0, }}; + int ret = 0; + + struct wet_output_config *parsed_options = wet_init_parsed_options(c); + if (!parsed_options) + return -1; + + weston_rdp_backend_config_init(&config); + + const struct weston_option rdp_options[] = { + { WESTON_OPTION_BOOLEAN, "env-socket", 0, &config.env_socket }, + { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, + { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, + { WESTON_OPTION_STRING, "address", 0, &config.bind_address }, + { WESTON_OPTION_INTEGER, "port", 0, &config.port }, + { WESTON_OPTION_BOOLEAN, "no-clients-resize", 0, &config.no_clients_resize }, + { WESTON_OPTION_STRING, "rdp4-key", 0, &config.rdp_key }, + { WESTON_OPTION_STRING, "rdp-tls-cert", 0, &config.server_cert }, + { WESTON_OPTION_STRING, "rdp-tls-key", 0, &config.server_key } + }; + + parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv); + + ret = weston_compositor_load_backend(c, WESTON_BACKEND_RDP, + &config.base); + + if (ret < 0) + goto out; + + wet_set_pending_output_handler(c, rdp_backend_output_configure); + +out: + free(config.bind_address); + free(config.rdp_key); + free(config.server_cert); + free(config.server_key); + + return ret; +} + +static void +fbdev_backend_output_configure(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + struct weston_config *wc = wet_get_config(output->compositor); + struct weston_config_section *section; + + section = weston_config_get_section(wc, "output", "name", "fbdev"); + + wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX); + weston_output_set_scale(output, 1); + + weston_output_enable(output); +} + +static int +load_fbdev_backend(struct weston_compositor *c, + int *argc, char **argv, struct weston_config *wc) +{ + struct weston_fbdev_backend_config config = {{ 0, }}; + int ret = 0; + + const struct weston_option fbdev_options[] = { + { WESTON_OPTION_INTEGER, "tty", 0, &config.tty }, + { WESTON_OPTION_STRING, "device", 0, &config.device }, + }; + + parse_options(fbdev_options, ARRAY_LENGTH(fbdev_options), argc, argv); + + if (!config.device) + config.device = strdup("/dev/fb0"); + + config.base.struct_version = WESTON_FBDEV_BACKEND_CONFIG_VERSION; + config.base.struct_size = sizeof(struct weston_fbdev_backend_config); + config.configure_device = configure_input_device; + + /* load the actual wayland backend and configure it */ + ret = weston_compositor_load_backend(c, WESTON_BACKEND_FBDEV, + &config.base); + + if (ret < 0) + goto out; + + wet_set_pending_output_handler(c, fbdev_backend_output_configure); + +out: + free(config.device); + return ret; +} + +static void +x11_backend_output_configure(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + struct wet_output_config defaults = { + .width = 1024, + .height = 600, + .scale = 1, + .transform = WL_OUTPUT_TRANSFORM_NORMAL + }; + + if (wet_configure_windowed_output_from_config(output, &defaults) < 0) + weston_log("Cannot configure output \"%s\".\n", output->name); +} + +static int +load_x11_backend(struct weston_compositor *c, + int *argc, char **argv, struct weston_config *wc) +{ + char *default_output; + const struct weston_windowed_output_api *api; + struct weston_x11_backend_config config = {{ 0, }}; + struct weston_config_section *section; + int ret = 0; + int option_count = 1; + int output_count = 0; + char const *section_name; + int i; + + struct wet_output_config *parsed_options = wet_init_parsed_options(c); + if (!parsed_options) + return -1; + + const struct weston_option options[] = { + { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, + { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, + { WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale }, + { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &config.fullscreen }, + { WESTON_OPTION_INTEGER, "output-count", 0, &option_count }, + { WESTON_OPTION_BOOLEAN, "no-input", 0, &config.no_input }, + { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, + }; + + parse_options(options, ARRAY_LENGTH(options), argc, argv); + + config.base.struct_version = WESTON_X11_BACKEND_CONFIG_VERSION; + config.base.struct_size = sizeof(struct weston_x11_backend_config); + + /* load the actual backend and configure it */ + ret = weston_compositor_load_backend(c, WESTON_BACKEND_X11, + &config.base); + + if (ret < 0) + return ret; + + wet_set_pending_output_handler(c, x11_backend_output_configure); + + api = weston_windowed_output_get_api(c); + + if (!api) { + weston_log("Cannot use weston_windowed_output_api.\n"); + return -1; + } + + section = NULL; + while (weston_config_next_section(wc, §ion, §ion_name)) { + char *output_name; + + if (output_count >= option_count) + break; + + if (strcmp(section_name, "output") != 0) { + continue; + } + + weston_config_section_get_string(section, "name", &output_name, NULL); + if (output_name == NULL || output_name[0] != 'X') { + free(output_name); + continue; + } + + if (api->output_create(c, output_name) < 0) { + free(output_name); + return -1; + } + free(output_name); + + output_count++; + } + + default_output = NULL; + + for (i = output_count; i < option_count; i++) { + if (asprintf(&default_output, "screen%d", i) < 0) { + return -1; + } + + if (api->output_create(c, default_output) < 0) { + free(default_output); + return -1; + } + free(default_output); + } + + return 0; +} + +static void +wayland_backend_output_configure_hotplug(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + + /* This backend has all values hardcoded, so nothing can be configured here */ + weston_output_enable(output); +} + +static void +wayland_backend_output_configure(struct wl_listener *listener, void *data) +{ + struct weston_output *output = data; + struct wet_output_config defaults = { + .width = 1024, + .height = 640, + .scale = 1, + .transform = WL_OUTPUT_TRANSFORM_NORMAL + }; + + if (wet_configure_windowed_output_from_config(output, &defaults) < 0) + weston_log("Cannot configure output \"%s\".\n", output->name); +} + +static int +load_wayland_backend(struct weston_compositor *c, + int *argc, char **argv, struct weston_config *wc) +{ + struct weston_wayland_backend_config config = {{ 0, }}; + struct weston_config_section *section; + const struct weston_windowed_output_api *api; + const char *section_name; + char *output_name = NULL; + int count = 1; + int ret = 0; + int i; + + struct wet_output_config *parsed_options = wet_init_parsed_options(c); + if (!parsed_options) + return -1; + + config.cursor_size = 32; + config.cursor_theme = NULL; + config.display_name = NULL; + config.fullscreen = false; + config.sprawl = false; + config.use_pixman = false; + + const struct weston_option wayland_options[] = { + { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, + { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, + { WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale }, + { WESTON_OPTION_STRING, "display", 0, &config.display_name }, + { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, + { WESTON_OPTION_INTEGER, "output-count", 0, &count }, + { WESTON_OPTION_BOOLEAN, "fullscreen", 0, &config.fullscreen }, + { WESTON_OPTION_BOOLEAN, "sprawl", 0, &config.sprawl }, + }; + + parse_options(wayland_options, ARRAY_LENGTH(wayland_options), argc, argv); + + section = weston_config_get_section(wc, "shell", NULL, NULL); + weston_config_section_get_string(section, "cursor-theme", + &config.cursor_theme, NULL); + weston_config_section_get_int(section, "cursor-size", + &config.cursor_size, 32); + + config.base.struct_size = sizeof(struct weston_wayland_backend_config); + config.base.struct_version = WESTON_WAYLAND_BACKEND_CONFIG_VERSION; + + /* load the actual wayland backend and configure it */ + ret = weston_compositor_load_backend(c, WESTON_BACKEND_WAYLAND, + &config.base); + + free(config.cursor_theme); + free(config.display_name); + + if (ret < 0) + return ret; + + api = weston_windowed_output_get_api(c); + + if (api == NULL) { + /* We will just assume if load_backend() finished cleanly and + * windowed_output_api is not present that wayland backend is + * started with --sprawl or runs on fullscreen-shell. */ + wet_set_pending_output_handler(c, wayland_backend_output_configure_hotplug); + + return 0; + } + + wet_set_pending_output_handler(c, wayland_backend_output_configure); + + section = NULL; + while (weston_config_next_section(wc, §ion, §ion_name)) { + if (count == 0) + break; + + if (strcmp(section_name, "output") != 0) { + continue; + } + + weston_config_section_get_string(section, "name", &output_name, NULL); + + if (output_name == NULL) + continue; + + if (output_name[0] != 'W' || output_name[1] != 'L') { + free(output_name); + continue; + } + + if (api->output_create(c, output_name) < 0) { + free(output_name); + return -1; + } + free(output_name); + + --count; + } + + for (i = 0; i < count; i++) { + if (asprintf(&output_name, "wayland%d", i) < 0) + return -1; + + if (api->output_create(c, output_name) < 0) { + free(output_name); + return -1; + } + free(output_name); + } + + return 0; +} + + +static int +load_backend(struct weston_compositor *compositor, const char *backend, + int *argc, char **argv, struct weston_config *config) +{ + if (strstr(backend, "headless-backend.so")) + return load_headless_backend(compositor, argc, argv, config); + else if (strstr(backend, "rdp-backend.so")) + return load_rdp_backend(compositor, argc, argv, config); + else if (strstr(backend, "fbdev-backend.so")) + return load_fbdev_backend(compositor, argc, argv, config); + else if (strstr(backend, "drm-backend.so")) + return load_drm_backend(compositor, argc, argv, config); + else if (strstr(backend, "x11-backend.so")) + return load_x11_backend(compositor, argc, argv, config); + else if (strstr(backend, "wayland-backend.so")) + return load_wayland_backend(compositor, argc, argv, config); + + weston_log("Error: unknown backend \"%s\"\n", backend); + return -1; +} + +static char * +copy_command_line(int argc, char * const argv[]) +{ + FILE *fp; + char *str = NULL; + size_t size = 0; + int i; + + fp = open_memstream(&str, &size); + if (!fp) + return NULL; + + fprintf(fp, "%s", argv[0]); + for (i = 1; i < argc; i++) + fprintf(fp, " %s", argv[i]); + fclose(fp); + + return str; +} + +static int +compositor_terminate(int fd, uint32_t mask, void * data) +{ + struct compositor_obj *comp_obj = (struct compositor_obj *)data; + int command; + int ret = -EINVAL; + if (NULL != comp_obj) { + do { + read(comp_obj->deinit_sync_fd, &command, sizeof(command)); + }while(EINTR == errno); + if (COMPOSITOR_TERMINATE == command) { + ret = 0; + wl_display_terminate(comp_obj->ec->wl_display); + } + } + return ret; +} + +static struct compositor_obj * +compositor_get_ctx(int id_ctx) +{ + struct compositor_obj *comp_obj = NULL; + if ((0 < id_ctx) && (MAX_COMPS_PER_PROCESS > id_ctx)) { + comp_obj = compositor_ctx_ids[id_ctx]; + } + return comp_obj; +} + +WL_EXPORT int +compositor_init(int argc, char *argv[], + int (*log_func)(const char *fmt, va_list ap), + int (*log_func_continue)(const char *fmt, va_list ap)) +{ + int ret = -1; + int comp_handle; + char *cmdline; + struct wl_display *display; + struct weston_compositor *ec; + int i, fd; + char *backend = NULL; + char *shell = NULL; + int32_t xwayland = 0; + char *modules = NULL; + char *option_modules = NULL; + char *log = NULL; + char *server_socket = NULL; + int32_t idle_time = -1; + int32_t help = 0; + char *socket_name = NULL; + int32_t version = 0; + int32_t noconfig = 0; + int32_t numlock_on; + char *config_file = NULL; + struct weston_config *config = NULL; + struct weston_config_section *section; + struct wl_client *primary_client; + struct wl_listener primary_client_destroyed; + struct weston_seat *seat; + struct wet_compositor *user_data; + struct wl_event_loop *loop; + struct compositor_obj *comp_obj; + int require_input; + + const struct weston_option core_options[] = { + { WESTON_OPTION_STRING, "backend", 'B', &backend }, + { WESTON_OPTION_STRING, "shell", 0, &shell }, + { WESTON_OPTION_STRING, "socket", 'S', &socket_name }, + { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time }, + { WESTON_OPTION_BOOLEAN, "xwayland", 0, &xwayland }, + { WESTON_OPTION_STRING, "modules", 0, &option_modules }, + { WESTON_OPTION_STRING, "log", 0, &log }, + { WESTON_OPTION_BOOLEAN, "help", 'h', &help }, + { WESTON_OPTION_BOOLEAN, "version", 0, &version }, + { WESTON_OPTION_BOOLEAN, "no-config", 0, &noconfig }, + { WESTON_OPTION_STRING, "config", 'c', &config_file }, + }; + + comp_obj = calloc(sizeof(struct compositor_obj), 1); + + if (NULL == comp_obj) + return -ENOMEM; + + user_data = &comp_obj->wet_ec; + cmdline = copy_command_line(argc, argv); + parse_options(core_options, ARRAY_LENGTH(core_options), &argc, argv); + + if (help) { + free(cmdline); + free(comp_obj); + usage(); + ret = 0; + return ret; + } + + if (version) { + printf(PACKAGE_STRING "\n"); + free(cmdline); + free(comp_obj); + ret = 0; + return ret; + } + + if ((NULL == log_func) || (NULL == log_func_continue)) { + weston_log_set_handler(vlog, vlog_continue); + } else { + weston_log_set_handler(log_func, log_func_continue); + } + + weston_log_file_open(log); + + weston_log("%s\n" + STAMP_SPACE "%s\n" + STAMP_SPACE "Bug reports to: %s\n" + STAMP_SPACE "Build: %s\n", + PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT, + BUILD_ID); + weston_log("Command line: %s\n", cmdline); + free(cmdline); + log_uname(); + + if (verify_xdg_runtime_dir() < 0) { + free(comp_obj); + weston_log_file_close(); + ret = -EINVAL; + return ret; + } + + display = wl_display_create(); + + loop = wl_display_get_event_loop(display); + + wl_list_init(&child_process_list); + + if (load_configuration(&config, noconfig, config_file) < 0) + goto out_signals; + user_data->config = config; + user_data->parsed_options = NULL; + + section = weston_config_get_section(config, "core", NULL, NULL); + + if (!backend) { + weston_config_section_get_string(section, "backend", &backend, + NULL); + if (!backend) + backend = weston_choose_default_backend(); + } + + ec = weston_compositor_create(display, user_data); + if (ec == NULL) { + weston_log("fatal: failed to create compositor\n"); + goto out; + } + + if (weston_compositor_init_config(ec, config) < 0) + goto out; + + weston_config_section_get_bool(section, "require-input", + &require_input, true); + ec->require_input = require_input; + + if (load_backend(ec, backend, &argc, argv, config) < 0) { + weston_log("fatal: failed to create compositor backend\n"); + goto out; + } + + weston_pending_output_coldplug(ec); + + if (idle_time < 0) + weston_config_section_get_int(section, "idle-time", &idle_time, -1); + if (idle_time < 0) + idle_time = 300; /* default idle timeout, in seconds */ + + ec->idle_time = idle_time; + ec->default_pointer_grab = NULL; + ec->exit = handle_exit; + + weston_compositor_log_capabilities(ec); + + server_socket = getenv("WAYLAND_SERVER_SOCKET"); + if (server_socket) { + weston_log("Running with single client\n"); + if (!safe_strtoint(server_socket, &fd)) + fd = -1; + } else { + fd = -1; + } + + if (fd != -1) { + primary_client = wl_client_create(display, fd); + if (!primary_client) { + weston_log("fatal: failed to add client: %m\n"); + goto out; + } + primary_client_destroyed.notify = + handle_primary_client_destroyed; + wl_client_add_destroy_listener(primary_client, + &primary_client_destroyed); + } else if (weston_create_listening_socket(display, socket_name)) { + goto out; + } + + if (!shell) + weston_config_section_get_string(section, "shell", &shell, + "desktop-shell.so"); + + if (wet_load_shell(ec, shell, &argc, argv) < 0) + goto out; + + weston_config_section_get_string(section, "modules", &modules, ""); + if (load_modules(ec, modules, &argc, argv, &xwayland) < 0) + goto out; + + if (load_modules(ec, option_modules, &argc, argv, &xwayland) < 0) + goto out; + + if (!xwayland) + weston_config_section_get_bool(section, "xwayland", &xwayland, + false); + if (xwayland) { + if (wet_load_xwayland(ec) < 0) + goto out; + } + + section = weston_config_get_section(config, "keyboard", NULL, NULL); + weston_config_section_get_bool(section, "numlock-on", &numlock_on, 0); + if (numlock_on) { + wl_list_for_each(seat, &ec->seat_list, link) { + struct weston_keyboard *keyboard = + weston_seat_get_keyboard(seat); + + if (keyboard) + weston_keyboard_set_locks(keyboard, + WESTON_NUM_LOCK, + WESTON_NUM_LOCK); + } + } + + for (i = 1; i < argc; i++) + weston_log("fatal: unhandled option: %s\n", argv[i]); + if (argc > 1) + goto out; + + comp_obj->backend = backend; + comp_obj->config_file = config_file; + comp_obj->ec = ec; + comp_obj->modules = modules; + comp_obj->option_modules = option_modules; + comp_obj->shell = shell; + comp_obj->socket_name = socket_name; + + weston_compositor_wake(ec); + + pthread_mutex_lock(&comp_mutex); + for (comp_handle = 1; comp_handle < MAX_COMPS_PER_PROCESS; + comp_handle++) { + if (NULL == compositor_ctx_ids[comp_handle]) { + break; + } + } + if (comp_handle < MAX_COMPS_PER_PROCESS) { + compositor_ctx_ids[comp_handle] = comp_obj; + comp_obj->ctx_id = comp_handle; + ret = comp_handle; + } else { + ret = -ENOMEM; + } + pthread_mutex_unlock(&comp_mutex); + + if (ret >= 0) { + comp_obj->deinit_sync_fd = eventfd(0, EFD_CLOEXEC); + comp_obj->ack_fd = eventfd(0, EFD_CLOEXEC); + + comp_obj->evt_src_for_deinit = wl_event_loop_add_fd(loop, + comp_obj->deinit_sync_fd, WL_EVENT_READABLE, + compositor_terminate, comp_obj); + + return ret; + } + +out: + /* free(NULL) is valid, and it won't be NULL if it's used */ + free(user_data->parsed_options); + + weston_compositor_destroy(ec); + +out_signals: + + wl_display_destroy(display); + + weston_log_file_close(); + + if (config) + weston_config_destroy(config); + free(config_file); + free(backend); + free(shell); + free(socket_name); + free(option_modules); + free(log); + free(modules); + free(comp_obj); + + return ret; +} + + +WL_EXPORT int +compositor_loadmodule(int comp_handle, const char* module_name, + int argc, char *argv[]) +{ + int ret = -EINVAL; + struct compositor_obj *comp_obj = compositor_get_ctx(comp_handle); + + if (NULL != comp_obj) { + ret = wet_load_module(comp_obj->ec, module_name, &argc, argv); + } + return ret; +} + +WL_EXPORT const void * +compositor_get_module_interface(int comp_handle, const char* module_name, + const char *lookup_name, size_t interface_size) +{ + const void* symbol_addr; + struct compositor_obj *comp_obj = compositor_get_ctx(comp_handle); + + if ((NULL != module_name) && (NULL != lookup_name) && (NULL != comp_obj)) { + symbol_addr = weston_plugin_api_get(comp_obj->ec, lookup_name, + interface_size); + } else { + symbol_addr = NULL; + } + return symbol_addr; +} + +WL_EXPORT void * +compositor_get_display(int comp_handle) +{ + void *ret = NULL; + struct compositor_obj *comp_obj = compositor_get_ctx(comp_handle); + + if (NULL != comp_obj) + ret = comp_obj->ec->wl_display; + + return ret; +} + +WL_EXPORT int +compositor_run(int comp_handle) +{ + struct compositor_obj *comp_obj= compositor_get_ctx(comp_handle); + uint64_t data = (uint64_t)COMPOSITOR_TERMINATE_COMPLETE; + + if (NULL != comp_obj) { + + pthread_mutex_lock(&comp_mutex); + if (!comp_obj->shut_down) + comp_obj->run_compthred = true; + + if (comp_obj->run_compthred) { + pthread_mutex_unlock(&comp_mutex); + comp_obj->compo_thread = pthread_self(); + wl_display_run(comp_obj->ec->wl_display); + + /*Indicate termination completion*/ + do { + write(comp_obj->ack_fd, &data, sizeof(data)); + }while(EINTR == errno); + } else + pthread_mutex_unlock(&comp_mutex); + } + + return 0; +} + +WL_EXPORT int +compositor_shutdown(int comp_handle) +{ + int ret = -EINVAL; + uint64_t data = (uint64_t)COMPOSITOR_TERMINATE; + struct compositor_obj *comp_obj = compositor_get_ctx(comp_handle); + + if (NULL != comp_obj) { + + pthread_mutex_lock(&comp_mutex); + compositor_ctx_ids[comp_obj->ctx_id] = NULL; + comp_obj->shut_down = true; + + if ( (comp_obj->run_compthred) + && (!pthread_equal(pthread_self(), comp_obj->compo_thread))) { + pthread_mutex_unlock(&comp_mutex); + /*nested compositor is running. Hence send + * a message to the thread for termination*/ + do { + write(comp_obj->deinit_sync_fd, &data, sizeof(data)); + }while(EINTR == errno); + + do { + read(comp_obj->ack_fd, &data, sizeof(data)); + }while(EINTR == errno); + + if (data != COMPOSITOR_TERMINATE_COMPLETE) + weston_log("Failed to terminate nested compositor thread\n"); + } else + pthread_mutex_unlock(&comp_mutex); + + wl_display_terminate(comp_obj->ec->wl_display); + weston_compositor_destroy(comp_obj->ec); + wl_display_destroy(comp_obj->ec->wl_display); + + ret = comp_obj->ec->exit_code; + + if (comp_obj->config) + weston_config_destroy(comp_obj->config); + + weston_log_file_close(); + close(comp_obj->ack_fd); + close(comp_obj->deinit_sync_fd); + free(comp_obj->config_file); + free(comp_obj->backend); + free(comp_obj->shell); + free(comp_obj->socket_name); + free(comp_obj->option_modules); + free(comp_obj->modules); + free(comp_obj->wet_ec.parsed_options); + weston_config_destroy(comp_obj->wet_ec.config); + free(comp_obj); + } + return ret; +} + +WL_EXPORT int +compositor_sigchld_handler(pid_t pid, int status) +{ + struct weston_process *p; + + wl_list_for_each(p, &child_process_list, link) { + if (p->pid == pid) + break; + } + + if (&p->link == &child_process_list) { + weston_log("unknown child process exited\n"); + } else { + wl_list_remove(&p->link); + p->cleanup(p, status); + } + return 0; +} + +WL_EXPORT void * +compositor_get_weston_compositor(int comp_handle) +{ + void *west_comp = NULL; + struct compositor_obj *comp_obj = compositor_get_ctx(comp_handle); + if (NULL != comp_obj) { + west_comp = (void *)comp_obj->ec; + } + return west_comp; +} + diff --git a/compositor/compositor_launch.h b/compositor/compositor_launch.h new file mode 100644 index 000000000..d918b5d8c --- /dev/null +++ b/compositor/compositor_launch.h @@ -0,0 +1,63 @@ +/** +* \file: compositor_launch.h +* +* \version: $Id:$ +* +* \release: $Name:$ +* +* This header exports interface to start compositor in the same process. +* Also exported is the interface to load proprietary weston modules +* +* \component: ivi-share +* +* \author: Harsha MM +* +* \copyright (c) 2017 Advanced Driver Information Technology. +* This code is developed by Advanced Driver Information Technology. +* Copyright of Advanced Driver Information Technology, Bosch, and DENSO. +* All rights reserved. +* +***********************************************************************/ +#ifndef _COMPOSITOR_LAUNCH_H +#define _COMPOSITOR_LAUNCH_H + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include + +int +compositor_init(int argc, char *argv[], + int (*log_func)(const char *fmt, va_list ap), + int (*log_func_continue)(const char *fmt, va_list ap)); + + +int +compositor_loadmodule(int comp_handle, const char* module_name, + int argc, char *argv[]); + +const void * +compositor_get_module_interface(int comp_handle, const char* module_name, + const char *lookup_name, size_t interface_size); + +void * +compositor_get_display(int comp_handle); + +int +compositor_run(int comp_handle); + +int +compositor_shutdown(int comp_handle); + +void * +compositor_get_weston_compositor(int comp_handle); + +int +compositor_sigchld_handler(pid_t pid, int status); + +#ifdef __cplusplus +} /**/ +#endif /* __cplusplus */ + +#endif diff --git a/compositor/compositor_launch.pc.in b/compositor/compositor_launch.pc.in new file mode 100644 index 000000000..8c9b82cb2 --- /dev/null +++ b/compositor/compositor_launch.pc.in @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: compositor_launch API +Description: Header files for compositor launch assistance +Version: @WESTON_VERSION@ +Requires.private: wayland-server libweston-@LIBWESTON_MAJOR@ +Cflags: -I${includedir}/weston +Libs: -L${libdir} -lcompositor_launch diff --git a/compositor/main.c b/compositor/main.c index 72c3cd10a..24c843d32 100644 --- a/compositor/main.c +++ b/compositor/main.c @@ -26,170 +26,27 @@ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ - #include "config.h" +#include #include #include +#include #include +#include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include #ifdef HAVE_LIBUNWIND #define UNW_LOCAL_ONLY #include #endif -#include "weston.h" -#include "compositor.h" -#include "../shared/os-compatibility.h" +#include "compositor_launch.h" #include "../shared/helpers.h" -#include "../shared/string-helpers.h" -#include "git-version.h" -#include "version.h" -#include "weston.h" - -#include "compositor-drm.h" -#include "compositor-headless.h" -#include "compositor-rdp.h" -#include "compositor-fbdev.h" -#include "compositor-x11.h" -#include "compositor-wayland.h" -#include "windowed-output-api.h" - -#define WINDOW_TITLE "Weston Compositor" - -struct wet_output_config { - int width; - int height; - int32_t scale; - uint32_t transform; -}; - -struct wet_compositor { - struct weston_config *config; - struct wet_output_config *parsed_options; - struct wl_listener pending_output_listener; - bool drm_use_current_mode; -}; - -static FILE *weston_logfile = NULL; - -static int cached_tm_mday = -1; - -static int weston_log_timestamp(void) -{ - struct timeval tv; - struct tm *brokendown_time; - char string[128]; - - gettimeofday(&tv, NULL); - - brokendown_time = localtime(&tv.tv_sec); - if (brokendown_time == NULL) - return fprintf(weston_logfile, "[(NULL)localtime] "); - - if (brokendown_time->tm_mday != cached_tm_mday) { - strftime(string, sizeof string, "%Y-%m-%d %Z", brokendown_time); - fprintf(weston_logfile, "Date: %s\n", string); - - cached_tm_mday = brokendown_time->tm_mday; - } - - strftime(string, sizeof string, "%H:%M:%S", brokendown_time); - - return fprintf(weston_logfile, "[%s.%03li] ", string, tv.tv_usec/1000); -} - -static void -custom_handler(const char *fmt, va_list arg) -{ - weston_log_timestamp(); - fprintf(weston_logfile, "libwayland: "); - vfprintf(weston_logfile, fmt, arg); -} - -static void -weston_log_file_open(const char *filename) -{ - wl_log_set_handler_server(custom_handler); - - if (filename != NULL) { - weston_logfile = fopen(filename, "a"); - if (weston_logfile) - os_fd_set_cloexec(fileno(weston_logfile)); - } - - if (weston_logfile == NULL) - weston_logfile = stderr; - else - setvbuf(weston_logfile, NULL, _IOLBF, 256); -} - -static void -weston_log_file_close(void) -{ - if ((weston_logfile != stderr) && (weston_logfile != NULL)) - fclose(weston_logfile); - weston_logfile = stderr; -} - -static int -vlog(const char *fmt, va_list ap) -{ - int l; - - l = weston_log_timestamp(); - l += vfprintf(weston_logfile, fmt, ap); - - return l; -} -static int -vlog_continue(const char *fmt, va_list argp) -{ - return vfprintf(weston_logfile, fmt, argp); -} - -static struct wl_list child_process_list; static struct weston_compositor *segv_compositor; -static int -sigchld_handler(int signal_number, void *data) -{ - struct weston_process *p; - int status; - pid_t pid; - - while ((pid = waitpid(-1, &status, WNOHANG)) > 0) { - wl_list_for_each(p, &child_process_list, link) { - if (p->pid == pid) - break; - } - - if (&p->link == &child_process_list) { - weston_log("unknown child process exited\n"); - continue; - } - - wl_list_remove(&p->link); - p->cleanup(p, status); - } - - if (pid < 0 && errno != ECHILD) - weston_log("waitpid error %m\n"); - - return 1; -} - #ifdef HAVE_LIBUNWIND static void @@ -269,368 +126,22 @@ print_backtrace(void) #endif -static void -child_client_exec(int sockfd, const char *path) -{ - int clientfd; - char s[32]; - sigset_t allsigs; - - /* do not give our signal mask to the new process */ - sigfillset(&allsigs); - sigprocmask(SIG_UNBLOCK, &allsigs, NULL); - - /* Launch clients as the user. Do not lauch clients with wrong euid.*/ - if (seteuid(getuid()) == -1) { - weston_log("compositor: failed seteuid\n"); - return; - } - - /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a - * non-CLOEXEC fd to pass through exec. */ - clientfd = dup(sockfd); - if (clientfd == -1) { - weston_log("compositor: dup failed: %m\n"); - return; - } - - snprintf(s, sizeof s, "%d", clientfd); - setenv("WAYLAND_SOCKET", s, 1); - - if (execl(path, path, NULL) < 0) - weston_log("compositor: executing '%s' failed: %m\n", - path); -} - -WL_EXPORT struct wl_client * -weston_client_launch(struct weston_compositor *compositor, - struct weston_process *proc, - const char *path, - weston_process_cleanup_func_t cleanup) +static int +sigchld_handler(int signal_number, void *data) { - int sv[2]; + int status; pid_t pid; - struct wl_client *client; - - weston_log("launching '%s'\n", path); - - if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) { - weston_log("weston_client_launch: " - "socketpair failed while launching '%s': %m\n", - path); - return NULL; - } - - pid = fork(); - if (pid == -1) { - close(sv[0]); - close(sv[1]); - weston_log("weston_client_launch: " - "fork failed while launching '%s': %m\n", path); - return NULL; - } - - if (pid == 0) { - child_client_exec(sv[1], path); - _exit(-1); - } - - close(sv[1]); - - client = wl_client_create(compositor->wl_display, sv[0]); - if (!client) { - close(sv[0]); - weston_log("weston_client_launch: " - "wl_client_create failed while launching '%s'.\n", - path); - return NULL; - } - - proc->pid = pid; - proc->cleanup = cleanup; - weston_watch_process(proc); - - return client; -} - -WL_EXPORT void -weston_watch_process(struct weston_process *process) -{ - wl_list_insert(&child_process_list, &process->link); -} - -struct process_info { - struct weston_process proc; - char *path; -}; - -static void -process_handle_sigchld(struct weston_process *process, int status) -{ - struct process_info *pinfo = - container_of(process, struct process_info, proc); - - /* - * There are no guarantees whether this runs before or after - * the wl_client destructor. - */ - - if (WIFEXITED(status)) { - weston_log("%s exited with status %d\n", pinfo->path, - WEXITSTATUS(status)); - } else if (WIFSIGNALED(status)) { - weston_log("%s died on signal %d\n", pinfo->path, - WTERMSIG(status)); - } else { - weston_log("%s disappeared\n", pinfo->path); - } - - free(pinfo->path); - free(pinfo); -} - -WL_EXPORT struct wl_client * -weston_client_start(struct weston_compositor *compositor, const char *path) -{ - struct process_info *pinfo; - struct wl_client *client; - - pinfo = zalloc(sizeof *pinfo); - if (!pinfo) - return NULL; - - pinfo->path = strdup(path); - if (!pinfo->path) - goto out_free; - - client = weston_client_launch(compositor, &pinfo->proc, path, - process_handle_sigchld); - if (!client) - goto out_str; - - return client; - -out_str: - free(pinfo->path); - -out_free: - free(pinfo); - - return NULL; -} - -static void -log_uname(void) -{ - struct utsname usys; - - uname(&usys); - - weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release, - usys.version, usys.machine); -} - -static struct wet_compositor * -to_wet_compositor(struct weston_compositor *compositor) -{ - return weston_compositor_get_user_data(compositor); -} - -static void -wet_set_pending_output_handler(struct weston_compositor *ec, - wl_notify_func_t handler) -{ - struct wet_compositor *compositor = to_wet_compositor(ec); - - compositor->pending_output_listener.notify = handler; - wl_signal_add(&ec->output_pending_signal, &compositor->pending_output_listener); -} -static struct wet_output_config * -wet_init_parsed_options(struct weston_compositor *ec) -{ - struct wet_compositor *compositor = to_wet_compositor(ec); - struct wet_output_config *config; - - config = zalloc(sizeof *config); - - if (!config) { - perror("out of memory"); - return NULL; - } - - config->width = 0; - config->height = 0; - config->scale = 0; - config->transform = UINT32_MAX; - - compositor->parsed_options = config; - - return config; -} - -WL_EXPORT struct weston_config * -wet_get_config(struct weston_compositor *ec) -{ - struct wet_compositor *compositor = to_wet_compositor(ec); - - return compositor->config; -} - -static const char xdg_error_message[] = - "fatal: environment variable XDG_RUNTIME_DIR is not set.\n"; - -static const char xdg_wrong_message[] = - "fatal: environment variable XDG_RUNTIME_DIR\n" - "is set to \"%s\", which is not a directory.\n"; - -static const char xdg_wrong_mode_message[] = - "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n" - "correctly. Unix access mode must be 0700 (current mode is %o),\n" - "and must be owned by the user (current owner is UID %d).\n"; - -static const char xdg_detail_message[] = - "Refer to your distribution on how to get it, or\n" - "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n" - "on how to implement it.\n"; - -static void -verify_xdg_runtime_dir(void) -{ - char *dir = getenv("XDG_RUNTIME_DIR"); - struct stat s; - - if (!dir) { - weston_log(xdg_error_message); - weston_log_continue(xdg_detail_message); - exit(EXIT_FAILURE); + while ((pid = waitpid(-1, &status, WNOHANG)) > 0) { + compositor_sigchld_handler(pid, status); } - if (stat(dir, &s) || !S_ISDIR(s.st_mode)) { - weston_log(xdg_wrong_message, dir); - weston_log_continue(xdg_detail_message); - exit(EXIT_FAILURE); - } + if (pid < 0 && errno != ECHILD) + weston_log("waitpid error %m\n"); - if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) { - weston_log(xdg_wrong_mode_message, - dir, s.st_mode & 0777, s.st_uid); - weston_log_continue(xdg_detail_message); - } + return 1; } -static int -usage(int error_code) -{ - fprintf(stderr, - "Usage: weston [OPTIONS]\n\n" - "This is weston version " VERSION ", the Wayland reference compositor.\n" - "Weston supports multiple backends, and depending on which backend is in use\n" - "different options will be accepted.\n\n" - - - "Core options:\n\n" - " --version\t\tPrint weston version\n" - " -B, --backend=MODULE\tBackend module, one of\n" -#if defined(BUILD_DRM_COMPOSITOR) - "\t\t\t\tdrm-backend.so\n" -#endif -#if defined(BUILD_FBDEV_COMPOSITOR) - "\t\t\t\tfbdev-backend.so\n" -#endif -#if defined(BUILD_HEADLESS_COMPOSITOR) - "\t\t\t\theadless-backend.so\n" -#endif -#if defined(BUILD_RDP_COMPOSITOR) - "\t\t\t\trdp-backend.so\n" -#endif -#if defined(BUILD_WAYLAND_COMPOSITOR) - "\t\t\t\twayland-backend.so\n" -#endif -#if defined(BUILD_X11_COMPOSITOR) - "\t\t\t\tx11-backend.so\n" -#endif - " --shell=MODULE\tShell module, defaults to desktop-shell.so\n" - " -S, --socket=NAME\tName of socket to listen on\n" - " -i, --idle-time=SECS\tIdle time in seconds\n" - " --modules\t\tLoad the comma-separated list of modules\n" - " --log=FILE\t\tLog to the given file\n" - " -c, --config=FILE\tConfig file to load, defaults to weston.ini\n" - " --no-config\t\tDo not read weston.ini\n" - " -h, --help\t\tThis help message\n\n"); - -#if defined(BUILD_DRM_COMPOSITOR) - fprintf(stderr, - "Options for drm-backend.so:\n\n" - " --connector=ID\tBring up only this connector\n" - " --seat=SEAT\t\tThe seat that weston should run on\n" - " --tty=TTY\t\tThe tty to use\n" - " --use-pixman\t\tUse the pixman (CPU) renderer\n" - " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n"); -#endif - -#if defined(BUILD_FBDEV_COMPOSITOR) - fprintf(stderr, - "Options for fbdev-backend.so:\n\n" - " --tty=TTY\t\tThe tty to use\n" - " --device=DEVICE\tThe framebuffer device to use\n" - "\n"); -#endif - -#if defined(BUILD_HEADLESS_COMPOSITOR) - fprintf(stderr, - "Options for headless-backend.so:\n\n" - " --width=WIDTH\t\tWidth of memory surface\n" - " --height=HEIGHT\tHeight of memory surface\n" - " --transform=TR\tThe output transformation, TR is one of:\n" - "\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n" - " --use-pixman\t\tUse the pixman (CPU) renderer (default: no rendering)\n" - " --no-outputs\t\tDo not create any virtual outputs\n" - "\n"); -#endif - -#if defined(BUILD_RDP_COMPOSITOR) - fprintf(stderr, - "Options for rdp-backend.so:\n\n" - " --width=WIDTH\t\tWidth of desktop\n" - " --height=HEIGHT\tHeight of desktop\n" - " --env-socket\t\tUse socket defined in RDP_FD env variable as peer connection\n" - " --address=ADDR\tThe address to bind\n" - " --port=PORT\t\tThe port to listen on\n" - " --no-clients-resize\tThe RDP peers will be forced to the size of the desktop\n" - " --rdp4-key=FILE\tThe file containing the key for RDP4 encryption\n" - " --rdp-tls-cert=FILE\tThe file containing the certificate for TLS encryption\n" - " --rdp-tls-key=FILE\tThe file containing the private key for TLS encryption\n" - "\n"); -#endif - -#if defined(BUILD_WAYLAND_COMPOSITOR) - fprintf(stderr, - "Options for wayland-backend.so:\n\n" - " --width=WIDTH\t\tWidth of Wayland surface\n" - " --height=HEIGHT\tHeight of Wayland surface\n" - " --scale=SCALE\t\tScale factor of output\n" - " --fullscreen\t\tRun in fullscreen mode\n" - " --use-pixman\t\tUse the pixman (CPU) renderer\n" - " --output-count=COUNT\tCreate multiple outputs\n" - " --sprawl\t\tCreate one fullscreen output for every parent output\n" - " --display=DISPLAY\tWayland display to connect to\n\n"); -#endif - -#if defined(BUILD_X11_COMPOSITOR) - fprintf(stderr, - "Options for x11-backend.so:\n\n" - " --width=WIDTH\t\tWidth of X window\n" - " --height=HEIGHT\tHeight of X window\n" - " --scale=SCALE\t\tScale factor of output\n" - " --fullscreen\t\tRun in fullscreen mode\n" - " --use-pixman\t\tUse the pixman (CPU) renderer\n" - " --output-count=COUNT\tCreate multiple outputs\n" - " --no-input\t\tDont create input devices\n\n"); -#endif - - exit(error_code); -} static int on_term_signal(int signal_number, void *data) { @@ -674,1325 +185,50 @@ catch_signals(void) sigaction(SIGABRT, &action, NULL); } -static const char * -clock_name(clockid_t clk_id) -{ - static const char *names[] = { - [CLOCK_REALTIME] = "CLOCK_REALTIME", - [CLOCK_MONOTONIC] = "CLOCK_MONOTONIC", - [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW", - [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE", - [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE", -#ifdef CLOCK_BOOTTIME - [CLOCK_BOOTTIME] = "CLOCK_BOOTTIME", -#endif - }; - - if (clk_id < 0 || (unsigned)clk_id >= ARRAY_LENGTH(names)) - return "unknown"; - - return names[clk_id]; -} - -static const struct { - uint32_t bit; /* enum weston_capability */ - const char *desc; -} capability_strings[] = { - { WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" }, - { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" }, -}; - -static void -weston_compositor_log_capabilities(struct weston_compositor *compositor) -{ - unsigned i; - int yes; - struct timespec res; - - weston_log("Compositor capabilities:\n"); - for (i = 0; i < ARRAY_LENGTH(capability_strings); i++) { - yes = compositor->capabilities & capability_strings[i].bit; - weston_log_continue(STAMP_SPACE "%s %s\n", - capability_strings[i].desc, - yes ? "yes" : "no"); - } - - weston_log_continue(STAMP_SPACE "presentation clock: %s, id %d\n", - clock_name(compositor->presentation_clock), - compositor->presentation_clock); - - if (clock_getres(compositor->presentation_clock, &res) == 0) - weston_log_continue(STAMP_SPACE - "presentation clock resolution: %d.%09ld s\n", - (int)res.tv_sec, res.tv_nsec); - else - weston_log_continue(STAMP_SPACE - "presentation clock resolution: N/A\n"); -} - -static void -handle_primary_client_destroyed(struct wl_listener *listener, void *data) -{ - struct wl_client *client = data; - - weston_log("Primary client died. Closing...\n"); - - wl_display_terminate(wl_client_get_display(client)); -} - -static int -weston_create_listening_socket(struct wl_display *display, const char *socket_name) -{ - if (socket_name) { - if (wl_display_add_socket(display, socket_name)) { - weston_log("fatal: failed to add socket: %m\n"); - return -1; - } - } else { - socket_name = wl_display_add_socket_auto(display); - if (!socket_name) { - weston_log("fatal: failed to add socket: %m\n"); - return -1; - } - } - - setenv("WAYLAND_DISPLAY", socket_name, 1); - - return 0; -} - -WL_EXPORT void * -wet_load_module_entrypoint(const char *name, const char *entrypoint) +int main(int argc, char *argv[]) { - const char *builddir = getenv("WESTON_BUILD_DIR"); - char path[PATH_MAX]; - void *module, *init; - size_t len; - - if (name == NULL) - return NULL; - - if (name[0] != '/') { - if (builddir) - len = snprintf(path, sizeof path, "%s/.libs/%s", builddir, - name); - else - len = snprintf(path, sizeof path, "%s/%s", MODULEDIR, - name); - } else { - len = snprintf(path, sizeof path, "%s", name); - } + int ret = -EINVAL; + int comp_obj; + int i; + struct wl_display *display; + struct wl_event_source *signals[4]; + struct wl_event_loop *loop; - /* snprintf returns the length of the string it would've written, - * _excluding_ the NUL byte. So even being equal to the size of - * our buffer is an error here. */ - if (len >= sizeof path) - return NULL; - module = dlopen(path, RTLD_NOW | RTLD_NOLOAD); - if (module) { - weston_log("Module '%s' already loaded\n", path); - dlclose(module); - return NULL; + comp_obj = compositor_init(argc, argv, NULL, NULL); + if (comp_obj <= 0) { + weston_log("compositor_init failed with error: %d", comp_obj); + return ret; } - weston_log("Loading module '%s'\n", path); - module = dlopen(path, RTLD_NOW); - if (!module) { - weston_log("Failed to load module: %s\n", dlerror()); - return NULL; - } + display = compositor_get_display(comp_obj); + loop = wl_display_get_event_loop(display); + signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, + display); + signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal, + display); + signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal, + display); + signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler, + NULL); - init = dlsym(module, entrypoint); - if (!init) { - weston_log("Failed to lookup init function: %s\n", dlerror()); - dlclose(module); - return NULL; + if (!signals[0] || !signals[1] || !signals[2] || !signals[3]) { + ret = -ENOMEM; + goto out; } - return init; -} - - -WL_EXPORT int -wet_load_module(struct weston_compositor *compositor, - const char *name, int *argc, char *argv[]) -{ - int (*module_init)(struct weston_compositor *ec, - int *argc, char *argv[]); - - module_init = wet_load_module_entrypoint(name, "wet_module_init"); - if (!module_init) - return -1; - if (module_init(compositor, argc, argv) < 0) - return -1; - return 0; -} - -static int -wet_load_shell(struct weston_compositor *compositor, - const char *name, int *argc, char *argv[]) -{ - int (*shell_init)(struct weston_compositor *ec, - int *argc, char *argv[]); - - shell_init = wet_load_module_entrypoint(name, "wet_shell_init"); - if (!shell_init) - return -1; - if (shell_init(compositor, argc, argv) < 0) - return -1; - return 0; -} - -static int -load_modules(struct weston_compositor *ec, const char *modules, - int *argc, char *argv[], int32_t *xwayland) -{ - const char *p, *end; - char buffer[256]; - - if (modules == NULL) - return 0; - - p = modules; - while (*p) { - end = strchrnul(p, ','); - snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p); - - if (strstr(buffer, "xwayland.so")) { - weston_log("Old Xwayland module loading detected: " - "Please use --xwayland command line option " - "or set xwayland=true in the [core] section " - "in weston.ini\n"); - *xwayland = 1; - } else { - if (wet_load_module(ec, buffer, argc, argv) < 0) - return -1; - } - - p = end; - while (*p == ',') - p++; - } + catch_signals(); + segv_compositor = (struct weston_compositor *) + compositor_get_weston_compositor(comp_obj); - return 0; -} + compositor_run(comp_obj); -static int -weston_compositor_init_config(struct weston_compositor *ec, - struct weston_config *config) -{ - struct xkb_rule_names xkb_names; - struct weston_config_section *s; - int repaint_msec; - int vt_switching; - - s = weston_config_get_section(config, "keyboard", NULL, NULL); - weston_config_section_get_string(s, "keymap_rules", - (char **) &xkb_names.rules, NULL); - weston_config_section_get_string(s, "keymap_model", - (char **) &xkb_names.model, NULL); - weston_config_section_get_string(s, "keymap_layout", - (char **) &xkb_names.layout, NULL); - weston_config_section_get_string(s, "keymap_variant", - (char **) &xkb_names.variant, NULL); - weston_config_section_get_string(s, "keymap_options", - (char **) &xkb_names.options, NULL); - - if (weston_compositor_set_xkb_rule_names(ec, &xkb_names) < 0) - return -1; - - weston_config_section_get_int(s, "repeat-rate", - &ec->kb_repeat_rate, 40); - weston_config_section_get_int(s, "repeat-delay", - &ec->kb_repeat_delay, 400); - - weston_config_section_get_bool(s, "vt-switching", - &vt_switching, true); - ec->vt_switching = vt_switching; - - s = weston_config_get_section(config, "core", NULL, NULL); - weston_config_section_get_int(s, "repaint-window", &repaint_msec, - ec->repaint_msec); - if (repaint_msec < -10 || repaint_msec > 1000) { - weston_log("Invalid repaint_window value in config: %d\n", - repaint_msec); - } else { - ec->repaint_msec = repaint_msec; - } - weston_log("Output repaint window is %d ms maximum.\n", - ec->repaint_msec); - - return 0; -} - -static char * -weston_choose_default_backend(void) -{ - char *backend = NULL; - - if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET")) - backend = strdup("wayland-backend.so"); - else if (getenv("DISPLAY")) - backend = strdup("x11-backend.so"); - else - backend = strdup(WESTON_NATIVE_BACKEND); - - return backend; -} - -static const struct { const char *name; uint32_t token; } transforms[] = { - { "normal", WL_OUTPUT_TRANSFORM_NORMAL }, - { "90", WL_OUTPUT_TRANSFORM_90 }, - { "180", WL_OUTPUT_TRANSFORM_180 }, - { "270", WL_OUTPUT_TRANSFORM_270 }, - { "flipped", WL_OUTPUT_TRANSFORM_FLIPPED }, - { "flipped-90", WL_OUTPUT_TRANSFORM_FLIPPED_90 }, - { "flipped-180", WL_OUTPUT_TRANSFORM_FLIPPED_180 }, - { "flipped-270", WL_OUTPUT_TRANSFORM_FLIPPED_270 }, -}; - -WL_EXPORT int -weston_parse_transform(const char *transform, uint32_t *out) -{ - unsigned int i; - - for (i = 0; i < ARRAY_LENGTH(transforms); i++) - if (strcmp(transforms[i].name, transform) == 0) { - *out = transforms[i].token; - return 0; - } - - *out = WL_OUTPUT_TRANSFORM_NORMAL; - return -1; -} - -WL_EXPORT const char * -weston_transform_to_string(uint32_t output_transform) -{ - unsigned int i; - - for (i = 0; i < ARRAY_LENGTH(transforms); i++) - if (transforms[i].token == output_transform) - return transforms[i].name; - - return ""; -} - -static int -load_configuration(struct weston_config **config, int32_t noconfig, - const char *config_file) -{ - const char *file = "weston.ini"; - const char *full_path; - - *config = NULL; - - if (config_file) - file = config_file; - - if (noconfig == 0) - *config = weston_config_parse(file); - - if (*config) { - full_path = weston_config_get_full_path(*config); - - weston_log("Using config file '%s'\n", full_path); - setenv(WESTON_CONFIG_FILE_ENV_VAR, full_path, 1); - - return 0; - } - - if (config_file && noconfig == 0) { - weston_log("fatal: error opening or reading config file" - " '%s'.\n", config_file); - - return -1; - } - - weston_log("Starting with no config file.\n"); - setenv(WESTON_CONFIG_FILE_ENV_VAR, "", 1); - - return 0; -} - -static void -handle_exit(struct weston_compositor *c) -{ - wl_display_terminate(c->wl_display); -} - -static void -wet_output_set_scale(struct weston_output *output, - struct weston_config_section *section, - int32_t default_scale, - int32_t parsed_scale) -{ - int32_t scale = default_scale; - - if (section) - weston_config_section_get_int(section, "scale", &scale, default_scale); - - if (parsed_scale) - scale = parsed_scale; - - weston_output_set_scale(output, scale); -} - -/* UINT32_MAX is treated as invalid because 0 is a valid - * enumeration value and the parameter is unsigned - */ -static void -wet_output_set_transform(struct weston_output *output, - struct weston_config_section *section, - uint32_t default_transform, - uint32_t parsed_transform) -{ - char *t; - uint32_t transform = default_transform; - - if (section) { - weston_config_section_get_string(section, - "transform", &t, "normal"); - - if (weston_parse_transform(t, &transform) < 0) { - weston_log("Invalid transform \"%s\" for output %s\n", - t, output->name); - transform = default_transform; - } - free(t); - } - - if (parsed_transform != UINT32_MAX) - transform = parsed_transform; - - weston_output_set_transform(output, transform); -} - -static int -wet_configure_windowed_output_from_config(struct weston_output *output, - struct wet_output_config *defaults) -{ - const struct weston_windowed_output_api *api = - weston_windowed_output_get_api(output->compositor); - - struct weston_config *wc = wet_get_config(output->compositor); - struct weston_config_section *section = NULL; - struct wet_compositor *compositor = to_wet_compositor(output->compositor); - struct wet_output_config *parsed_options = compositor->parsed_options; - int width = defaults->width; - int height = defaults->height; - - assert(parsed_options); - - if (!api) { - weston_log("Cannot use weston_windowed_output_api.\n"); - return -1; - } - - section = weston_config_get_section(wc, "output", "name", output->name); - - if (section) { - char *mode; - - weston_config_section_get_string(section, "mode", &mode, NULL); - if (!mode || sscanf(mode, "%dx%d", &width, - &height) != 2) { - weston_log("Invalid mode for output %s. Using defaults.\n", - output->name); - width = defaults->width; - height = defaults->height; - } - free(mode); - } - - if (parsed_options->width) - width = parsed_options->width; - - if (parsed_options->height) - height = parsed_options->height; - - wet_output_set_scale(output, section, defaults->scale, parsed_options->scale); - wet_output_set_transform(output, section, defaults->transform, parsed_options->transform); - - if (api->output_set_size(output, width, height) < 0) { - weston_log("Cannot configure output \"%s\" using weston_windowed_output_api.\n", - output->name); - return -1; - } - - weston_output_enable(output); - - return 0; -} - -static void -configure_input_device(struct weston_compositor *compositor, - struct libinput_device *device) -{ - struct weston_config_section *s; - struct weston_config *config = wet_get_config(compositor); - int enable_tap; - int enable_tap_default; - - s = weston_config_get_section(config, - "libinput", NULL, NULL); - - if (libinput_device_config_tap_get_finger_count(device) > 0) { - enable_tap_default = - libinput_device_config_tap_get_default_enabled( - device); - weston_config_section_get_bool(s, "enable_tap", - &enable_tap, - enable_tap_default); - libinput_device_config_tap_set_enabled(device, - enable_tap); - } -} - -static void -drm_backend_output_configure(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - struct weston_config *wc = wet_get_config(output->compositor); - struct wet_compositor *wet = to_wet_compositor(output->compositor); - struct weston_config_section *section; - const struct weston_drm_output_api *api = weston_drm_output_get_api(output->compositor); - enum weston_drm_backend_output_mode mode = - WESTON_DRM_BACKEND_OUTPUT_PREFERRED; - - char *s; - char *modeline = NULL; - char *gbm_format = NULL; - char *seat = NULL; - - if (!api) { - weston_log("Cannot use weston_drm_output_api.\n"); - return; - } - - section = weston_config_get_section(wc, "output", "name", output->name); - weston_config_section_get_string(section, "mode", &s, "preferred"); - - if (strcmp(s, "off") == 0) { - weston_output_disable(output); - free(s); - return; - } else if (wet->drm_use_current_mode || strcmp(s, "current") == 0) { - mode = WESTON_DRM_BACKEND_OUTPUT_CURRENT; - } else if (strcmp(s, "preferred") != 0) { - modeline = s; - s = NULL; - } - free(s); - - if (api->set_mode(output, mode, modeline) < 0) { - weston_log("Cannot configure an output using weston_drm_output_api.\n"); - free(modeline); - return; - } - free(modeline); - - wet_output_set_scale(output, section, 1, 0); - wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX); - - weston_config_section_get_string(section, - "gbm-format", &gbm_format, NULL); - - api->set_gbm_format(output, gbm_format); - free(gbm_format); - - weston_config_section_get_string(section, "seat", &seat, ""); - - api->set_seat(output, seat); - free(seat); - - weston_output_enable(output); -} - -static int -load_drm_backend(struct weston_compositor *c, - int *argc, char **argv, struct weston_config *wc) -{ - struct weston_drm_backend_config config = {{ 0, }}; - struct weston_config_section *section; - struct wet_compositor *wet = to_wet_compositor(c); - int ret = 0; - - wet->drm_use_current_mode = false; - - const struct weston_option options[] = { - { WESTON_OPTION_INTEGER, "connector", 0, &config.connector }, - { WESTON_OPTION_STRING, "seat", 0, &config.seat_id }, - { WESTON_OPTION_INTEGER, "tty", 0, &config.tty }, - { WESTON_OPTION_BOOLEAN, "current-mode", 0, &wet->drm_use_current_mode }, - { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, - }; - - parse_options(options, ARRAY_LENGTH(options), argc, argv); - - section = weston_config_get_section(wc, "core", NULL, NULL); - weston_config_section_get_string(section, - "gbm-format", &config.gbm_format, - NULL); - - config.base.struct_version = WESTON_DRM_BACKEND_CONFIG_VERSION; - config.base.struct_size = sizeof(struct weston_drm_backend_config); - config.configure_device = configure_input_device; - - ret = weston_compositor_load_backend(c, WESTON_BACKEND_DRM, - &config.base); - - wet_set_pending_output_handler(c, drm_backend_output_configure); - - free(config.gbm_format); - free(config.seat_id); - - return ret; -} - -static void -headless_backend_output_configure(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - struct wet_output_config defaults = { - .width = 1024, - .height = 640, - .scale = 1, - .transform = WL_OUTPUT_TRANSFORM_NORMAL - }; - - if (wet_configure_windowed_output_from_config(output, &defaults) < 0) - weston_log("Cannot configure output \"%s\".\n", output->name); -} - -static int -load_headless_backend(struct weston_compositor *c, - int *argc, char **argv, struct weston_config *wc) -{ - const struct weston_windowed_output_api *api; - struct weston_headless_backend_config config = {{ 0, }}; - int no_outputs = 0; - int ret = 0; - char *transform = NULL; - - struct wet_output_config *parsed_options = wet_init_parsed_options(c); - if (!parsed_options) - return -1; - - const struct weston_option options[] = { - { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, - { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, - { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, - { WESTON_OPTION_STRING, "transform", 0, &transform }, - { WESTON_OPTION_BOOLEAN, "no-outputs", 0, &no_outputs }, - }; - - parse_options(options, ARRAY_LENGTH(options), argc, argv); - - if (transform) { - if (weston_parse_transform(transform, &parsed_options->transform) < 0) { - weston_log("Invalid transform \"%s\"\n", transform); - parsed_options->transform = UINT32_MAX; - } - free(transform); - } - - config.base.struct_version = WESTON_HEADLESS_BACKEND_CONFIG_VERSION; - config.base.struct_size = sizeof(struct weston_headless_backend_config); - - /* load the actual wayland backend and configure it */ - ret = weston_compositor_load_backend(c, WESTON_BACKEND_HEADLESS, - &config.base); - - if (ret < 0) - return ret; - - wet_set_pending_output_handler(c, headless_backend_output_configure); - - if (!no_outputs) { - api = weston_windowed_output_get_api(c); - - if (!api) { - weston_log("Cannot use weston_windowed_output_api.\n"); - return -1; - } - - if (api->output_create(c, "headless") < 0) - return -1; - } - - return 0; -} - -static void -rdp_backend_output_configure(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - struct wet_compositor *compositor = to_wet_compositor(output->compositor); - struct wet_output_config *parsed_options = compositor->parsed_options; - const struct weston_rdp_output_api *api = weston_rdp_output_get_api(output->compositor); - int width = 640; - int height = 480; - - assert(parsed_options); - - if (!api) { - weston_log("Cannot use weston_rdp_output_api.\n"); - return; - } - - if (parsed_options->width) - width = parsed_options->width; - - if (parsed_options->height) - height = parsed_options->height; - - weston_output_set_scale(output, 1); - weston_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL); - - if (api->output_set_size(output, width, height) < 0) { - weston_log("Cannot configure output \"%s\" using weston_rdp_output_api.\n", - output->name); - return; - } - - weston_output_enable(output); -} - -static void -weston_rdp_backend_config_init(struct weston_rdp_backend_config *config) -{ - config->base.struct_version = WESTON_RDP_BACKEND_CONFIG_VERSION; - config->base.struct_size = sizeof(struct weston_rdp_backend_config); - - config->bind_address = NULL; - config->port = 3389; - config->rdp_key = NULL; - config->server_cert = NULL; - config->server_key = NULL; - config->env_socket = 0; - config->no_clients_resize = 0; -} - -static int -load_rdp_backend(struct weston_compositor *c, - int *argc, char *argv[], struct weston_config *wc) -{ - struct weston_rdp_backend_config config = {{ 0, }}; - int ret = 0; - - struct wet_output_config *parsed_options = wet_init_parsed_options(c); - if (!parsed_options) - return -1; - - weston_rdp_backend_config_init(&config); - - const struct weston_option rdp_options[] = { - { WESTON_OPTION_BOOLEAN, "env-socket", 0, &config.env_socket }, - { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, - { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, - { WESTON_OPTION_STRING, "address", 0, &config.bind_address }, - { WESTON_OPTION_INTEGER, "port", 0, &config.port }, - { WESTON_OPTION_BOOLEAN, "no-clients-resize", 0, &config.no_clients_resize }, - { WESTON_OPTION_STRING, "rdp4-key", 0, &config.rdp_key }, - { WESTON_OPTION_STRING, "rdp-tls-cert", 0, &config.server_cert }, - { WESTON_OPTION_STRING, "rdp-tls-key", 0, &config.server_key } - }; - - parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv); - - ret = weston_compositor_load_backend(c, WESTON_BACKEND_RDP, - &config.base); - - if (ret < 0) - goto out; - - wet_set_pending_output_handler(c, rdp_backend_output_configure); + for (i = ARRAY_LENGTH(signals) - 1; i >= 0; i--) + if (signals[i]) + wl_event_source_remove(signals[i]); out: - free(config.bind_address); - free(config.rdp_key); - free(config.server_cert); - free(config.server_key); - - return ret; -} - -static void -fbdev_backend_output_configure(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - struct weston_config *wc = wet_get_config(output->compositor); - struct weston_config_section *section; - - section = weston_config_get_section(wc, "output", "name", "fbdev"); - - wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX); - weston_output_set_scale(output, 1); - - weston_output_enable(output); -} - -static int -load_fbdev_backend(struct weston_compositor *c, - int *argc, char **argv, struct weston_config *wc) -{ - struct weston_fbdev_backend_config config = {{ 0, }}; - int ret = 0; - - const struct weston_option fbdev_options[] = { - { WESTON_OPTION_INTEGER, "tty", 0, &config.tty }, - { WESTON_OPTION_STRING, "device", 0, &config.device }, - }; - - parse_options(fbdev_options, ARRAY_LENGTH(fbdev_options), argc, argv); - - if (!config.device) - config.device = strdup("/dev/fb0"); - - config.base.struct_version = WESTON_FBDEV_BACKEND_CONFIG_VERSION; - config.base.struct_size = sizeof(struct weston_fbdev_backend_config); - config.configure_device = configure_input_device; - - /* load the actual wayland backend and configure it */ - ret = weston_compositor_load_backend(c, WESTON_BACKEND_FBDEV, - &config.base); - - if (ret < 0) - goto out; - - wet_set_pending_output_handler(c, fbdev_backend_output_configure); - -out: - free(config.device); - return ret; -} - -static void -x11_backend_output_configure(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - struct wet_output_config defaults = { - .width = 1024, - .height = 600, - .scale = 1, - .transform = WL_OUTPUT_TRANSFORM_NORMAL - }; - - if (wet_configure_windowed_output_from_config(output, &defaults) < 0) - weston_log("Cannot configure output \"%s\".\n", output->name); -} - -static int -load_x11_backend(struct weston_compositor *c, - int *argc, char **argv, struct weston_config *wc) -{ - char *default_output; - const struct weston_windowed_output_api *api; - struct weston_x11_backend_config config = {{ 0, }}; - struct weston_config_section *section; - int ret = 0; - int option_count = 1; - int output_count = 0; - char const *section_name; - int i; - - struct wet_output_config *parsed_options = wet_init_parsed_options(c); - if (!parsed_options) - return -1; - - const struct weston_option options[] = { - { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, - { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, - { WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale }, - { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &config.fullscreen }, - { WESTON_OPTION_INTEGER, "output-count", 0, &option_count }, - { WESTON_OPTION_BOOLEAN, "no-input", 0, &config.no_input }, - { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, - }; - - parse_options(options, ARRAY_LENGTH(options), argc, argv); - - config.base.struct_version = WESTON_X11_BACKEND_CONFIG_VERSION; - config.base.struct_size = sizeof(struct weston_x11_backend_config); - - /* load the actual backend and configure it */ - ret = weston_compositor_load_backend(c, WESTON_BACKEND_X11, - &config.base); - - if (ret < 0) - return ret; - - wet_set_pending_output_handler(c, x11_backend_output_configure); - - api = weston_windowed_output_get_api(c); - - if (!api) { - weston_log("Cannot use weston_windowed_output_api.\n"); - return -1; - } - - section = NULL; - while (weston_config_next_section(wc, §ion, §ion_name)) { - char *output_name; - - if (output_count >= option_count) - break; - - if (strcmp(section_name, "output") != 0) { - continue; - } - - weston_config_section_get_string(section, "name", &output_name, NULL); - if (output_name == NULL || output_name[0] != 'X') { - free(output_name); - continue; - } - - if (api->output_create(c, output_name) < 0) { - free(output_name); - return -1; - } - free(output_name); - - output_count++; - } - - default_output = NULL; - - for (i = output_count; i < option_count; i++) { - if (asprintf(&default_output, "screen%d", i) < 0) { - return -1; - } - - if (api->output_create(c, default_output) < 0) { - free(default_output); - return -1; - } - free(default_output); - } - - return 0; -} - -static void -wayland_backend_output_configure_hotplug(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - - /* This backend has all values hardcoded, so nothing can be configured here */ - weston_output_enable(output); -} - -static void -wayland_backend_output_configure(struct wl_listener *listener, void *data) -{ - struct weston_output *output = data; - struct wet_output_config defaults = { - .width = 1024, - .height = 640, - .scale = 1, - .transform = WL_OUTPUT_TRANSFORM_NORMAL - }; - - if (wet_configure_windowed_output_from_config(output, &defaults) < 0) - weston_log("Cannot configure output \"%s\".\n", output->name); -} - -static int -load_wayland_backend(struct weston_compositor *c, - int *argc, char **argv, struct weston_config *wc) -{ - struct weston_wayland_backend_config config = {{ 0, }}; - struct weston_config_section *section; - const struct weston_windowed_output_api *api; - const char *section_name; - char *output_name = NULL; - int count = 1; - int ret = 0; - int i; - - struct wet_output_config *parsed_options = wet_init_parsed_options(c); - if (!parsed_options) - return -1; - - config.cursor_size = 32; - config.cursor_theme = NULL; - config.display_name = NULL; - config.fullscreen = false; - config.sprawl = false; - config.use_pixman = false; - - const struct weston_option wayland_options[] = { - { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width }, - { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height }, - { WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale }, - { WESTON_OPTION_STRING, "display", 0, &config.display_name }, - { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman }, - { WESTON_OPTION_INTEGER, "output-count", 0, &count }, - { WESTON_OPTION_BOOLEAN, "fullscreen", 0, &config.fullscreen }, - { WESTON_OPTION_BOOLEAN, "sprawl", 0, &config.sprawl }, - }; - - parse_options(wayland_options, ARRAY_LENGTH(wayland_options), argc, argv); - - section = weston_config_get_section(wc, "shell", NULL, NULL); - weston_config_section_get_string(section, "cursor-theme", - &config.cursor_theme, NULL); - weston_config_section_get_int(section, "cursor-size", - &config.cursor_size, 32); - - config.base.struct_size = sizeof(struct weston_wayland_backend_config); - config.base.struct_version = WESTON_WAYLAND_BACKEND_CONFIG_VERSION; - - /* load the actual wayland backend and configure it */ - ret = weston_compositor_load_backend(c, WESTON_BACKEND_WAYLAND, - &config.base); - - free(config.cursor_theme); - free(config.display_name); - - if (ret < 0) - return ret; - - api = weston_windowed_output_get_api(c); - - if (api == NULL) { - /* We will just assume if load_backend() finished cleanly and - * windowed_output_api is not present that wayland backend is - * started with --sprawl or runs on fullscreen-shell. */ - wet_set_pending_output_handler(c, wayland_backend_output_configure_hotplug); - - return 0; - } - - wet_set_pending_output_handler(c, wayland_backend_output_configure); - - section = NULL; - while (weston_config_next_section(wc, §ion, §ion_name)) { - if (count == 0) - break; - - if (strcmp(section_name, "output") != 0) { - continue; - } - - weston_config_section_get_string(section, "name", &output_name, NULL); - - if (output_name == NULL) - continue; - - if (output_name[0] != 'W' || output_name[1] != 'L') { - free(output_name); - continue; - } - - if (api->output_create(c, output_name) < 0) { - free(output_name); - return -1; - } - free(output_name); - - --count; - } - - for (i = 0; i < count; i++) { - if (asprintf(&output_name, "wayland%d", i) < 0) - return -1; - - if (api->output_create(c, output_name) < 0) { - free(output_name); - return -1; - } - free(output_name); - } - - return 0; -} - - -static int -load_backend(struct weston_compositor *compositor, const char *backend, - int *argc, char **argv, struct weston_config *config) -{ - if (strstr(backend, "headless-backend.so")) - return load_headless_backend(compositor, argc, argv, config); - else if (strstr(backend, "rdp-backend.so")) - return load_rdp_backend(compositor, argc, argv, config); - else if (strstr(backend, "fbdev-backend.so")) - return load_fbdev_backend(compositor, argc, argv, config); - else if (strstr(backend, "drm-backend.so")) - return load_drm_backend(compositor, argc, argv, config); - else if (strstr(backend, "x11-backend.so")) - return load_x11_backend(compositor, argc, argv, config); - else if (strstr(backend, "wayland-backend.so")) - return load_wayland_backend(compositor, argc, argv, config); - - weston_log("Error: unknown backend \"%s\"\n", backend); - return -1; -} - -static char * -copy_command_line(int argc, char * const argv[]) -{ - FILE *fp; - char *str = NULL; - size_t size = 0; - int i; - - fp = open_memstream(&str, &size); - if (!fp) - return NULL; - - fprintf(fp, "%s", argv[0]); - for (i = 1; i < argc; i++) - fprintf(fp, " %s", argv[i]); - fclose(fp); - - return str; -} - -int main(int argc, char *argv[]) -{ - int ret = EXIT_FAILURE; - char *cmdline; - struct wl_display *display; - struct weston_compositor *ec; - struct wl_event_source *signals[4]; - struct wl_event_loop *loop; - int i, fd; - char *backend = NULL; - char *shell = NULL; - int32_t xwayland = 0; - char *modules = NULL; - char *option_modules = NULL; - char *log = NULL; - char *server_socket = NULL; - int32_t idle_time = -1; - int32_t help = 0; - char *socket_name = NULL; - int32_t version = 0; - int32_t noconfig = 0; - int32_t numlock_on; - char *config_file = NULL; - struct weston_config *config = NULL; - struct weston_config_section *section; - struct wl_client *primary_client; - struct wl_listener primary_client_destroyed; - struct weston_seat *seat; - struct wet_compositor user_data; - int require_input; - - const struct weston_option core_options[] = { - { WESTON_OPTION_STRING, "backend", 'B', &backend }, - { WESTON_OPTION_STRING, "shell", 0, &shell }, - { WESTON_OPTION_STRING, "socket", 'S', &socket_name }, - { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time }, - { WESTON_OPTION_BOOLEAN, "xwayland", 0, &xwayland }, - { WESTON_OPTION_STRING, "modules", 0, &option_modules }, - { WESTON_OPTION_STRING, "log", 0, &log }, - { WESTON_OPTION_BOOLEAN, "help", 'h', &help }, - { WESTON_OPTION_BOOLEAN, "version", 0, &version }, - { WESTON_OPTION_BOOLEAN, "no-config", 0, &noconfig }, - { WESTON_OPTION_STRING, "config", 'c', &config_file }, - }; - - cmdline = copy_command_line(argc, argv); - parse_options(core_options, ARRAY_LENGTH(core_options), &argc, argv); - - if (help) { - free(cmdline); - usage(EXIT_SUCCESS); - } - - if (version) { - printf(PACKAGE_STRING "\n"); - free(cmdline); - - return EXIT_SUCCESS; - } - - weston_log_set_handler(vlog, vlog_continue); - weston_log_file_open(log); - - weston_log("%s\n" - STAMP_SPACE "%s\n" - STAMP_SPACE "Bug reports to: %s\n" - STAMP_SPACE "Build: %s\n", - PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT, - BUILD_ID); - weston_log("Command line: %s\n", cmdline); - free(cmdline); - log_uname(); - - verify_xdg_runtime_dir(); - - display = wl_display_create(); - - loop = wl_display_get_event_loop(display); - signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal, - display); - signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal, - display); - signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal, - display); - - wl_list_init(&child_process_list); - signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler, - NULL); - - if (!signals[0] || !signals[1] || !signals[2] || !signals[3]) - goto out_signals; - - if (load_configuration(&config, noconfig, config_file) < 0) - goto out_signals; - user_data.config = config; - user_data.parsed_options = NULL; - - section = weston_config_get_section(config, "core", NULL, NULL); - - if (!backend) { - weston_config_section_get_string(section, "backend", &backend, - NULL); - if (!backend) - backend = weston_choose_default_backend(); - } - - ec = weston_compositor_create(display, &user_data); - if (ec == NULL) { - weston_log("fatal: failed to create compositor\n"); - goto out; - } - - if (weston_compositor_init_config(ec, config) < 0) - goto out; - - weston_config_section_get_bool(section, "require-input", - &require_input, true); - ec->require_input = require_input; - - if (load_backend(ec, backend, &argc, argv, config) < 0) { - weston_log("fatal: failed to create compositor backend\n"); - goto out; - } - - weston_pending_output_coldplug(ec); - - catch_signals(); - segv_compositor = ec; - - if (idle_time < 0) - weston_config_section_get_int(section, "idle-time", &idle_time, -1); - if (idle_time < 0) - idle_time = 300; /* default idle timeout, in seconds */ - - ec->idle_time = idle_time; - ec->default_pointer_grab = NULL; - ec->exit = handle_exit; - - weston_compositor_log_capabilities(ec); - - server_socket = getenv("WAYLAND_SERVER_SOCKET"); - if (server_socket) { - weston_log("Running with single client\n"); - if (!safe_strtoint(server_socket, &fd)) - fd = -1; - } else { - fd = -1; - } - - if (fd != -1) { - primary_client = wl_client_create(display, fd); - if (!primary_client) { - weston_log("fatal: failed to add client: %m\n"); - goto out; - } - primary_client_destroyed.notify = - handle_primary_client_destroyed; - wl_client_add_destroy_listener(primary_client, - &primary_client_destroyed); - } else if (weston_create_listening_socket(display, socket_name)) { - goto out; - } - - if (!shell) - weston_config_section_get_string(section, "shell", &shell, - "desktop-shell.so"); - - if (wet_load_shell(ec, shell, &argc, argv) < 0) - goto out; - - weston_config_section_get_string(section, "modules", &modules, ""); - if (load_modules(ec, modules, &argc, argv, &xwayland) < 0) - goto out; - - if (load_modules(ec, option_modules, &argc, argv, &xwayland) < 0) - goto out; - - if (!xwayland) - weston_config_section_get_bool(section, "xwayland", &xwayland, - false); - if (xwayland) { - if (wet_load_xwayland(ec) < 0) - goto out; - } - - section = weston_config_get_section(config, "keyboard", NULL, NULL); - weston_config_section_get_bool(section, "numlock-on", &numlock_on, 0); - if (numlock_on) { - wl_list_for_each(seat, &ec->seat_list, link) { - struct weston_keyboard *keyboard = - weston_seat_get_keyboard(seat); - - if (keyboard) - weston_keyboard_set_locks(keyboard, - WESTON_NUM_LOCK, - WESTON_NUM_LOCK); - } - } - - for (i = 1; i < argc; i++) - weston_log("fatal: unhandled option: %s\n", argv[i]); - if (argc > 1) - goto out; - - weston_compositor_wake(ec); - - wl_display_run(display); - - /* Allow for setting return exit code after - * wl_display_run returns normally. This is - * useful for devs/testers and automated tests - * that want to indicate failure status to - * testing infrastructure above - */ - ret = ec->exit_code; - -out: - /* free(NULL) is valid, and it won't be NULL if it's used */ - free(user_data.parsed_options); - - weston_compositor_destroy(ec); - -out_signals: - for (i = ARRAY_LENGTH(signals) - 1; i >= 0; i--) - if (signals[i]) - wl_event_source_remove(signals[i]); - - wl_display_destroy(display); - - weston_log_file_close(); - - if (config) - weston_config_destroy(config); - free(config_file); - free(backend); - free(shell); - free(socket_name); - free(option_modules); - free(log); - free(modules); + ret = compositor_shutdown(comp_obj); return ret; } diff --git a/configure.ac b/configure.ac index a36a5166f..9265e8d8d 100644 --- a/configure.ac +++ b/configure.ac @@ -670,7 +670,7 @@ if test "x$enable_systemd_notify" = "xyes"; then PKG_CHECK_MODULES(SYSTEMD_DAEMON, [libsystemd]) fi -AC_CONFIG_FILES([Makefile libweston/version.h compositor/weston.pc]) +AC_CONFIG_FILES([Makefile libweston/version.h compositor/weston.pc compositor/compositor_launch.pc]) # AC_CONFIG_FILES needs the full name when running autoconf, so we need to use # libweston_abi_version here, and outside [] because of m4 quoting rules