blob: 12f5e76bd4ec3edf2e73fcc663688bec035f2a81 [file] [log] [blame]
Giulio Camuffobab996e2014-10-12 00:24:25 +03001/*
2 * Copyright © 2010-2011 Intel Corporation
3 * Copyright © 2008-2011 Kristian Høgsberg
4 * Copyright © 2012-2015 Collabora, Ltd.
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02005 * Copyright © 2010-2011 Benjamin Franzke
6 * Copyright © 2013 Jason Ekstrand
Giulio Camuffobab996e2014-10-12 00:24:25 +03007 *
8 * Permission is hereby granted, free of charge, to any person obtaining
9 * a copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sublicense, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
15 *
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial
18 * portions of the Software.
19 *
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
24 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 * SOFTWARE.
28 */
29
30#include "config.h"
31
32#include <unistd.h>
33#include <signal.h>
34#include <errno.h>
35#include <dlfcn.h>
Jussi Kukkonen649bbce2016-07-19 14:16:27 +030036#include <stdint.h>
Giulio Camuffobab996e2014-10-12 00:24:25 +030037#include <string.h>
38#include <sys/utsname.h>
39#include <sys/stat.h>
40#include <sys/wait.h>
Giulio Camuffofba27fb2016-06-02 21:48:10 +030041#include <sys/socket.h>
Giulio Camuffo8aedf7b2016-06-02 21:48:12 +030042#include <libinput.h>
Giulio Camuffobe2b11a2016-06-02 21:48:13 +030043#include <sys/time.h>
Giulio Camuffo179fcda2016-06-02 21:48:14 +030044#include <linux/limits.h>
Giulio Camuffobab996e2014-10-12 00:24:25 +030045
46#ifdef HAVE_LIBUNWIND
47#define UNW_LOCAL_ONLY
48#include <libunwind.h>
49#endif
50
Giulio Camuffo179fcda2016-06-02 21:48:14 +030051#include "weston.h"
Giulio Camuffobab996e2014-10-12 00:24:25 +030052#include "compositor.h"
53#include "../shared/os-compatibility.h"
54#include "../shared/helpers.h"
Bryce Harrington25a2bdd2016-08-03 17:40:52 -070055#include "../shared/string-helpers.h"
Giulio Camuffobab996e2014-10-12 00:24:25 +030056#include "git-version.h"
57#include "version.h"
Giulio Camuffofba27fb2016-06-02 21:48:10 +030058#include "weston.h"
Giulio Camuffobab996e2014-10-12 00:24:25 +030059
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -070060#include "compositor-drm.h"
Benoit Gschwind3c530942016-04-15 20:28:32 -070061#include "compositor-headless.h"
Benoit Gschwindbd573102016-04-22 17:05:26 +020062#include "compositor-rdp.h"
Benoit Gschwind934e89a2016-04-27 23:56:42 +020063#include "compositor-fbdev.h"
Benoit Gschwinde16acab2016-04-15 20:28:31 -070064#include "compositor-x11.h"
Benoit Gschwind3ff10da2016-05-10 22:47:49 +020065#include "compositor-wayland.h"
Armin Krezovića3666d22016-09-30 14:11:04 +020066#include "windowed-output-api.h"
Benoit Gschwind3ff10da2016-05-10 22:47:49 +020067
68#define WINDOW_TITLE "Weston Compositor"
Benoit Gschwind3c530942016-04-15 20:28:32 -070069
Armin Krezovića3666d22016-09-30 14:11:04 +020070struct wet_output_config {
71 int width;
72 int height;
73 int32_t scale;
74 uint32_t transform;
75};
76
Armin Krezović78a36372016-08-01 18:51:46 +020077struct wet_compositor {
78 struct weston_config *config;
Armin Krezovića3666d22016-09-30 14:11:04 +020079 struct wet_output_config *parsed_options;
80 struct wl_listener pending_output_listener;
Armin Krezović78a36372016-08-01 18:51:46 +020081};
82
Giulio Camuffobe2b11a2016-06-02 21:48:13 +030083static FILE *weston_logfile = NULL;
84
85static int cached_tm_mday = -1;
86
87static int weston_log_timestamp(void)
88{
89 struct timeval tv;
90 struct tm *brokendown_time;
91 char string[128];
92
93 gettimeofday(&tv, NULL);
94
95 brokendown_time = localtime(&tv.tv_sec);
96 if (brokendown_time == NULL)
97 return fprintf(weston_logfile, "[(NULL)localtime] ");
98
99 if (brokendown_time->tm_mday != cached_tm_mday) {
100 strftime(string, sizeof string, "%Y-%m-%d %Z", brokendown_time);
101 fprintf(weston_logfile, "Date: %s\n", string);
102
103 cached_tm_mday = brokendown_time->tm_mday;
104 }
105
106 strftime(string, sizeof string, "%H:%M:%S", brokendown_time);
107
108 return fprintf(weston_logfile, "[%s.%03li] ", string, tv.tv_usec/1000);
109}
110
111static void
112custom_handler(const char *fmt, va_list arg)
113{
114 weston_log_timestamp();
115 fprintf(weston_logfile, "libwayland: ");
116 vfprintf(weston_logfile, fmt, arg);
117}
118
119static void
120weston_log_file_open(const char *filename)
121{
122 wl_log_set_handler_server(custom_handler);
123
124 if (filename != NULL) {
125 weston_logfile = fopen(filename, "a");
126 if (weston_logfile)
127 os_fd_set_cloexec(fileno(weston_logfile));
128 }
129
130 if (weston_logfile == NULL)
131 weston_logfile = stderr;
132 else
133 setvbuf(weston_logfile, NULL, _IOLBF, 256);
134}
135
136static void
137weston_log_file_close(void)
138{
139 if ((weston_logfile != stderr) && (weston_logfile != NULL))
140 fclose(weston_logfile);
141 weston_logfile = stderr;
142}
143
144static int
145vlog(const char *fmt, va_list ap)
146{
147 int l;
148
149 l = weston_log_timestamp();
150 l += vfprintf(weston_logfile, fmt, ap);
151
152 return l;
153}
154
155static int
156vlog_continue(const char *fmt, va_list argp)
157{
158 return vfprintf(weston_logfile, fmt, argp);
159}
160
Giulio Camuffobab996e2014-10-12 00:24:25 +0300161static struct wl_list child_process_list;
162static struct weston_compositor *segv_compositor;
163
164static int
165sigchld_handler(int signal_number, void *data)
166{
167 struct weston_process *p;
168 int status;
169 pid_t pid;
170
171 while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
172 wl_list_for_each(p, &child_process_list, link) {
173 if (p->pid == pid)
174 break;
175 }
176
177 if (&p->link == &child_process_list) {
178 weston_log("unknown child process exited\n");
179 continue;
180 }
181
182 wl_list_remove(&p->link);
183 p->cleanup(p, status);
184 }
185
186 if (pid < 0 && errno != ECHILD)
187 weston_log("waitpid error %m\n");
188
189 return 1;
190}
191
192#ifdef HAVE_LIBUNWIND
193
194static void
195print_backtrace(void)
196{
197 unw_cursor_t cursor;
198 unw_context_t context;
199 unw_word_t off;
200 unw_proc_info_t pip;
201 int ret, i = 0;
202 char procname[256];
203 const char *filename;
204 Dl_info dlinfo;
205
206 pip.unwind_info = NULL;
207 ret = unw_getcontext(&context);
208 if (ret) {
209 weston_log("unw_getcontext: %d\n", ret);
210 return;
211 }
212
213 ret = unw_init_local(&cursor, &context);
214 if (ret) {
215 weston_log("unw_init_local: %d\n", ret);
216 return;
217 }
218
219 ret = unw_step(&cursor);
220 while (ret > 0) {
221 ret = unw_get_proc_info(&cursor, &pip);
222 if (ret) {
223 weston_log("unw_get_proc_info: %d\n", ret);
224 break;
225 }
226
227 ret = unw_get_proc_name(&cursor, procname, 256, &off);
228 if (ret && ret != -UNW_ENOMEM) {
229 if (ret != -UNW_EUNSPEC)
230 weston_log("unw_get_proc_name: %d\n", ret);
231 procname[0] = '?';
232 procname[1] = 0;
233 }
234
235 if (dladdr((void *)(pip.start_ip + off), &dlinfo) && dlinfo.dli_fname &&
236 *dlinfo.dli_fname)
237 filename = dlinfo.dli_fname;
238 else
239 filename = "?";
240
241 weston_log("%u: %s (%s%s+0x%x) [%p]\n", i++, filename, procname,
242 ret == -UNW_ENOMEM ? "..." : "", (int)off, (void *)(pip.start_ip + off));
243
244 ret = unw_step(&cursor);
245 if (ret < 0)
246 weston_log("unw_step: %d\n", ret);
247 }
248}
249
250#else
251
252static void
253print_backtrace(void)
254{
255 void *buffer[32];
256 int i, count;
257 Dl_info info;
258
259 count = backtrace(buffer, ARRAY_LENGTH(buffer));
260 for (i = 0; i < count; i++) {
261 dladdr(buffer[i], &info);
262 weston_log(" [%016lx] %s (%s)\n",
263 (long) buffer[i],
264 info.dli_sname ? info.dli_sname : "--",
265 info.dli_fname);
266 }
267}
268
269#endif
270
Giulio Camuffofba27fb2016-06-02 21:48:10 +0300271static void
272child_client_exec(int sockfd, const char *path)
273{
274 int clientfd;
275 char s[32];
276 sigset_t allsigs;
277
278 /* do not give our signal mask to the new process */
279 sigfillset(&allsigs);
280 sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
281
282 /* Launch clients as the user. Do not lauch clients with wrong euid.*/
283 if (seteuid(getuid()) == -1) {
284 weston_log("compositor: failed seteuid\n");
285 return;
286 }
287
288 /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
289 * non-CLOEXEC fd to pass through exec. */
290 clientfd = dup(sockfd);
291 if (clientfd == -1) {
292 weston_log("compositor: dup failed: %m\n");
293 return;
294 }
295
296 snprintf(s, sizeof s, "%d", clientfd);
297 setenv("WAYLAND_SOCKET", s, 1);
298
299 if (execl(path, path, NULL) < 0)
300 weston_log("compositor: executing '%s' failed: %m\n",
301 path);
302}
303
304WL_EXPORT struct wl_client *
305weston_client_launch(struct weston_compositor *compositor,
306 struct weston_process *proc,
307 const char *path,
308 weston_process_cleanup_func_t cleanup)
309{
310 int sv[2];
311 pid_t pid;
312 struct wl_client *client;
313
314 weston_log("launching '%s'\n", path);
315
316 if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
317 weston_log("weston_client_launch: "
318 "socketpair failed while launching '%s': %m\n",
319 path);
320 return NULL;
321 }
322
323 pid = fork();
324 if (pid == -1) {
325 close(sv[0]);
326 close(sv[1]);
327 weston_log("weston_client_launch: "
328 "fork failed while launching '%s': %m\n", path);
329 return NULL;
330 }
331
332 if (pid == 0) {
333 child_client_exec(sv[1], path);
334 _exit(-1);
335 }
336
337 close(sv[1]);
338
339 client = wl_client_create(compositor->wl_display, sv[0]);
340 if (!client) {
341 close(sv[0]);
342 weston_log("weston_client_launch: "
343 "wl_client_create failed while launching '%s'.\n",
344 path);
345 return NULL;
346 }
347
348 proc->pid = pid;
349 proc->cleanup = cleanup;
350 weston_watch_process(proc);
351
352 return client;
353}
354
Giulio Camuffobab996e2014-10-12 00:24:25 +0300355WL_EXPORT void
356weston_watch_process(struct weston_process *process)
357{
358 wl_list_insert(&child_process_list, &process->link);
359}
360
Giulio Camuffofba27fb2016-06-02 21:48:10 +0300361struct process_info {
362 struct weston_process proc;
363 char *path;
364};
365
366static void
367process_handle_sigchld(struct weston_process *process, int status)
368{
369 struct process_info *pinfo =
370 container_of(process, struct process_info, proc);
371
372 /*
373 * There are no guarantees whether this runs before or after
374 * the wl_client destructor.
375 */
376
377 if (WIFEXITED(status)) {
378 weston_log("%s exited with status %d\n", pinfo->path,
379 WEXITSTATUS(status));
380 } else if (WIFSIGNALED(status)) {
381 weston_log("%s died on signal %d\n", pinfo->path,
382 WTERMSIG(status));
383 } else {
384 weston_log("%s disappeared\n", pinfo->path);
385 }
386
387 free(pinfo->path);
388 free(pinfo);
389}
390
391WL_EXPORT struct wl_client *
392weston_client_start(struct weston_compositor *compositor, const char *path)
393{
394 struct process_info *pinfo;
395 struct wl_client *client;
396
397 pinfo = zalloc(sizeof *pinfo);
398 if (!pinfo)
399 return NULL;
400
401 pinfo->path = strdup(path);
402 if (!pinfo->path)
403 goto out_free;
404
405 client = weston_client_launch(compositor, &pinfo->proc, path,
406 process_handle_sigchld);
407 if (!client)
408 goto out_str;
409
410 return client;
411
412out_str:
413 free(pinfo->path);
414
415out_free:
416 free(pinfo);
417
418 return NULL;
419}
420
Giulio Camuffobab996e2014-10-12 00:24:25 +0300421static void
422log_uname(void)
423{
424 struct utsname usys;
425
426 uname(&usys);
427
428 weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
429 usys.version, usys.machine);
430}
431
Armin Krezović78a36372016-08-01 18:51:46 +0200432static struct wet_compositor *
433to_wet_compositor(struct weston_compositor *compositor)
Giulio Camuffod52f3b72016-06-02 21:48:11 +0300434{
435 return weston_compositor_get_user_data(compositor);
436}
437
Armin Krezovića3666d22016-09-30 14:11:04 +0200438static void
439wet_set_pending_output_handler(struct weston_compositor *ec,
440 wl_notify_func_t handler)
441{
442 struct wet_compositor *compositor = to_wet_compositor(ec);
443
444 compositor->pending_output_listener.notify = handler;
445 wl_signal_add(&ec->output_pending_signal, &compositor->pending_output_listener);
446}
447
448static struct wet_output_config *
449wet_init_parsed_options(struct weston_compositor *ec)
450{
451 struct wet_compositor *compositor = to_wet_compositor(ec);
452 struct wet_output_config *config;
453
454 config = zalloc(sizeof *config);
455
456 if (!config) {
457 perror("out of memory");
458 return NULL;
459 }
460
461 config->width = 0;
462 config->height = 0;
463 config->scale = 0;
464 config->transform = UINT32_MAX;
465
466 compositor->parsed_options = config;
467
468 return config;
469}
470
Armin Krezović78a36372016-08-01 18:51:46 +0200471WL_EXPORT struct weston_config *
472wet_get_config(struct weston_compositor *ec)
473{
474 struct wet_compositor *compositor = to_wet_compositor(ec);
475
476 return compositor->config;
477}
478
Giulio Camuffobab996e2014-10-12 00:24:25 +0300479static const char xdg_error_message[] =
480 "fatal: environment variable XDG_RUNTIME_DIR is not set.\n";
481
482static const char xdg_wrong_message[] =
483 "fatal: environment variable XDG_RUNTIME_DIR\n"
484 "is set to \"%s\", which is not a directory.\n";
485
486static const char xdg_wrong_mode_message[] =
487 "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n"
488 "correctly. Unix access mode must be 0700 (current mode is %o),\n"
489 "and must be owned by the user (current owner is UID %d).\n";
490
491static const char xdg_detail_message[] =
492 "Refer to your distribution on how to get it, or\n"
493 "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
494 "on how to implement it.\n";
495
496static void
497verify_xdg_runtime_dir(void)
498{
499 char *dir = getenv("XDG_RUNTIME_DIR");
500 struct stat s;
501
502 if (!dir) {
503 weston_log(xdg_error_message);
504 weston_log_continue(xdg_detail_message);
505 exit(EXIT_FAILURE);
506 }
507
508 if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
509 weston_log(xdg_wrong_message, dir);
510 weston_log_continue(xdg_detail_message);
511 exit(EXIT_FAILURE);
512 }
513
514 if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) {
515 weston_log(xdg_wrong_mode_message,
516 dir, s.st_mode & 0777, s.st_uid);
517 weston_log_continue(xdg_detail_message);
518 }
519}
520
521static int
522usage(int error_code)
523{
524 fprintf(stderr,
525 "Usage: weston [OPTIONS]\n\n"
526 "This is weston version " VERSION ", the Wayland reference compositor.\n"
527 "Weston supports multiple backends, and depending on which backend is in use\n"
528 "different options will be accepted.\n\n"
529
530
531 "Core options:\n\n"
532 " --version\t\tPrint weston version\n"
533 " -B, --backend=MODULE\tBackend module, one of\n"
534#if defined(BUILD_DRM_COMPOSITOR)
535 "\t\t\t\tdrm-backend.so\n"
536#endif
537#if defined(BUILD_FBDEV_COMPOSITOR)
538 "\t\t\t\tfbdev-backend.so\n"
539#endif
Dawid Gajownik71f57042015-07-31 17:39:00 -0300540#if defined(BUILD_HEADLESS_COMPOSITOR)
541 "\t\t\t\theadless-backend.so\n"
Giulio Camuffobab996e2014-10-12 00:24:25 +0300542#endif
543#if defined(BUILD_RDP_COMPOSITOR)
544 "\t\t\t\trdp-backend.so\n"
545#endif
Dawid Gajownik71f57042015-07-31 17:39:00 -0300546#if defined(BUILD_WAYLAND_COMPOSITOR)
547 "\t\t\t\twayland-backend.so\n"
548#endif
549#if defined(BUILD_X11_COMPOSITOR)
550 "\t\t\t\tx11-backend.so\n"
551#endif
Giulio Camuffobab996e2014-10-12 00:24:25 +0300552 " --shell=MODULE\tShell module, defaults to desktop-shell.so\n"
553 " -S, --socket=NAME\tName of socket to listen on\n"
554 " -i, --idle-time=SECS\tIdle time in seconds\n"
555 " --modules\t\tLoad the comma-separated list of modules\n"
556 " --log=FILE\t\tLog to the given file\n"
557 " -c, --config=FILE\tConfig file to load, defaults to weston.ini\n"
558 " --no-config\t\tDo not read weston.ini\n"
559 " -h, --help\t\tThis help message\n\n");
560
561#if defined(BUILD_DRM_COMPOSITOR)
562 fprintf(stderr,
563 "Options for drm-backend.so:\n\n"
564 " --connector=ID\tBring up only this connector\n"
565 " --seat=SEAT\t\tThe seat that weston should run on\n"
566 " --tty=TTY\t\tThe tty to use\n"
567 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
568 " --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n");
569#endif
570
571#if defined(BUILD_FBDEV_COMPOSITOR)
572 fprintf(stderr,
573 "Options for fbdev-backend.so:\n\n"
574 " --tty=TTY\t\tThe tty to use\n"
575 " --device=DEVICE\tThe framebuffer device to use\n"
Pekka Paalanene77f8ad2016-06-08 17:39:37 +0300576 "\n");
Giulio Camuffobab996e2014-10-12 00:24:25 +0300577#endif
578
Dawid Gajownik71f57042015-07-31 17:39:00 -0300579#if defined(BUILD_HEADLESS_COMPOSITOR)
Giulio Camuffobab996e2014-10-12 00:24:25 +0300580 fprintf(stderr,
Dawid Gajownik71f57042015-07-31 17:39:00 -0300581 "Options for headless-backend.so:\n\n"
582 " --width=WIDTH\t\tWidth of memory surface\n"
583 " --height=HEIGHT\tHeight of memory surface\n"
Giulio Camuffobab996e2014-10-12 00:24:25 +0300584 " --transform=TR\tThe output transformation, TR is one of:\n"
585 "\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n"
Armin Krezovićd84deeb2016-06-23 11:59:29 +0200586 " --use-pixman\t\tUse the pixman (CPU) renderer (default: no rendering)\n"
587 " --no-outputs\t\tDo not create any virtual outputs\n"
588 "\n");
Giulio Camuffobab996e2014-10-12 00:24:25 +0300589#endif
590
591#if defined(BUILD_RDP_COMPOSITOR)
592 fprintf(stderr,
593 "Options for rdp-backend.so:\n\n"
594 " --width=WIDTH\t\tWidth of desktop\n"
595 " --height=HEIGHT\tHeight of desktop\n"
Dawid Gajownikd99a0502015-07-31 14:49:57 -0300596 " --env-socket\t\tUse socket defined in RDP_FD env variable as peer connection\n"
Giulio Camuffobab996e2014-10-12 00:24:25 +0300597 " --address=ADDR\tThe address to bind\n"
598 " --port=PORT\t\tThe port to listen on\n"
599 " --no-clients-resize\tThe RDP peers will be forced to the size of the desktop\n"
600 " --rdp4-key=FILE\tThe file containing the key for RDP4 encryption\n"
601 " --rdp-tls-cert=FILE\tThe file containing the certificate for TLS encryption\n"
602 " --rdp-tls-key=FILE\tThe file containing the private key for TLS encryption\n"
603 "\n");
604#endif
605
Dawid Gajownik71f57042015-07-31 17:39:00 -0300606#if defined(BUILD_WAYLAND_COMPOSITOR)
607 fprintf(stderr,
608 "Options for wayland-backend.so:\n\n"
609 " --width=WIDTH\t\tWidth of Wayland surface\n"
610 " --height=HEIGHT\tHeight of Wayland surface\n"
611 " --scale=SCALE\t\tScale factor of output\n"
612 " --fullscreen\t\tRun in fullscreen mode\n"
613 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
614 " --output-count=COUNT\tCreate multiple outputs\n"
615 " --sprawl\t\tCreate one fullscreen output for every parent output\n"
616 " --display=DISPLAY\tWayland display to connect to\n\n");
617#endif
618
619#if defined(BUILD_X11_COMPOSITOR)
620 fprintf(stderr,
621 "Options for x11-backend.so:\n\n"
622 " --width=WIDTH\t\tWidth of X window\n"
623 " --height=HEIGHT\tHeight of X window\n"
624 " --scale=SCALE\t\tScale factor of output\n"
625 " --fullscreen\t\tRun in fullscreen mode\n"
626 " --use-pixman\t\tUse the pixman (CPU) renderer\n"
627 " --output-count=COUNT\tCreate multiple outputs\n"
628 " --no-input\t\tDont create input devices\n\n");
Giulio Camuffobab996e2014-10-12 00:24:25 +0300629#endif
630
631 exit(error_code);
632}
633
634static int on_term_signal(int signal_number, void *data)
635{
636 struct wl_display *display = data;
637
638 weston_log("caught signal %d\n", signal_number);
639 wl_display_terminate(display);
640
641 return 1;
642}
643
644static void
645on_caught_signal(int s, siginfo_t *siginfo, void *context)
646{
647 /* This signal handler will do a best-effort backtrace, and
648 * then call the backend restore function, which will switch
649 * back to the vt we launched from or ungrab X etc and then
650 * raise SIGTRAP. If we run weston under gdb from X or a
651 * different vt, and tell gdb "handle *s* nostop", this
652 * will allow weston to switch back to gdb on crash and then
653 * gdb will catch the crash with SIGTRAP.*/
654
655 weston_log("caught signal: %d\n", s);
656
657 print_backtrace();
658
659 segv_compositor->backend->restore(segv_compositor);
660
661 raise(SIGTRAP);
662}
663
664static void
665catch_signals(void)
666{
667 struct sigaction action;
668
669 action.sa_flags = SA_SIGINFO | SA_RESETHAND;
670 action.sa_sigaction = on_caught_signal;
671 sigemptyset(&action.sa_mask);
672 sigaction(SIGSEGV, &action, NULL);
673 sigaction(SIGABRT, &action, NULL);
674}
675
676static const char *
677clock_name(clockid_t clk_id)
678{
679 static const char *names[] = {
680 [CLOCK_REALTIME] = "CLOCK_REALTIME",
681 [CLOCK_MONOTONIC] = "CLOCK_MONOTONIC",
682 [CLOCK_MONOTONIC_RAW] = "CLOCK_MONOTONIC_RAW",
683 [CLOCK_REALTIME_COARSE] = "CLOCK_REALTIME_COARSE",
684 [CLOCK_MONOTONIC_COARSE] = "CLOCK_MONOTONIC_COARSE",
Derek Foreman32838c92015-06-29 13:20:34 -0500685#ifdef CLOCK_BOOTTIME
Giulio Camuffobab996e2014-10-12 00:24:25 +0300686 [CLOCK_BOOTTIME] = "CLOCK_BOOTTIME",
Derek Foreman32838c92015-06-29 13:20:34 -0500687#endif
Giulio Camuffobab996e2014-10-12 00:24:25 +0300688 };
689
690 if (clk_id < 0 || (unsigned)clk_id >= ARRAY_LENGTH(names))
691 return "unknown";
692
693 return names[clk_id];
694}
695
696static const struct {
697 uint32_t bit; /* enum weston_capability */
698 const char *desc;
699} capability_strings[] = {
700 { WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" },
701 { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" },
702};
703
704static void
705weston_compositor_log_capabilities(struct weston_compositor *compositor)
706{
707 unsigned i;
708 int yes;
Pekka Paalanenbe112d42016-04-18 15:53:38 +0300709 struct timespec res;
Giulio Camuffobab996e2014-10-12 00:24:25 +0300710
711 weston_log("Compositor capabilities:\n");
712 for (i = 0; i < ARRAY_LENGTH(capability_strings); i++) {
713 yes = compositor->capabilities & capability_strings[i].bit;
714 weston_log_continue(STAMP_SPACE "%s %s\n",
715 capability_strings[i].desc,
716 yes ? "yes" : "no");
717 }
718
719 weston_log_continue(STAMP_SPACE "presentation clock: %s, id %d\n",
720 clock_name(compositor->presentation_clock),
721 compositor->presentation_clock);
Pekka Paalanenbe112d42016-04-18 15:53:38 +0300722
723 if (clock_getres(compositor->presentation_clock, &res) == 0)
724 weston_log_continue(STAMP_SPACE
725 "presentation clock resolution: %d.%09ld s\n",
726 (int)res.tv_sec, res.tv_nsec);
727 else
728 weston_log_continue(STAMP_SPACE
729 "presentation clock resolution: N/A\n");
Giulio Camuffobab996e2014-10-12 00:24:25 +0300730}
731
732static void
733handle_primary_client_destroyed(struct wl_listener *listener, void *data)
734{
735 struct wl_client *client = data;
736
737 weston_log("Primary client died. Closing...\n");
738
739 wl_display_terminate(wl_client_get_display(client));
740}
741
742static int
743weston_create_listening_socket(struct wl_display *display, const char *socket_name)
744{
745 if (socket_name) {
746 if (wl_display_add_socket(display, socket_name)) {
747 weston_log("fatal: failed to add socket: %m\n");
748 return -1;
749 }
750 } else {
751 socket_name = wl_display_add_socket_auto(display);
752 if (!socket_name) {
753 weston_log("fatal: failed to add socket: %m\n");
754 return -1;
755 }
756 }
757
758 setenv("WAYLAND_DISPLAY", socket_name, 1);
759
760 return 0;
761}
762
Giulio Camuffo179fcda2016-06-02 21:48:14 +0300763WL_EXPORT void *
764wet_load_module(const char *name, const char *entrypoint)
765{
766 const char *builddir = getenv("WESTON_BUILD_DIR");
767 char path[PATH_MAX];
768 void *module, *init;
769
770 if (name == NULL)
771 return NULL;
772
773 if (name[0] != '/') {
774 if (builddir)
775 snprintf(path, sizeof path, "%s/.libs/%s", builddir, name);
776 else
777 snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
778 } else {
779 snprintf(path, sizeof path, "%s", name);
780 }
781
782 module = dlopen(path, RTLD_NOW | RTLD_NOLOAD);
783 if (module) {
784 weston_log("Module '%s' already loaded\n", path);
785 dlclose(module);
786 return NULL;
787 }
788
789 weston_log("Loading module '%s'\n", path);
790 module = dlopen(path, RTLD_NOW);
791 if (!module) {
792 weston_log("Failed to load module: %s\n", dlerror());
793 return NULL;
794 }
795
796 init = dlsym(module, entrypoint);
797 if (!init) {
798 weston_log("Failed to lookup init function: %s\n", dlerror());
799 dlclose(module);
800 return NULL;
801 }
802
803 return init;
804}
805
Giulio Camuffobab996e2014-10-12 00:24:25 +0300806static int
807load_modules(struct weston_compositor *ec, const char *modules,
808 int *argc, char *argv[])
809{
810 const char *p, *end;
811 char buffer[256];
812 int (*module_init)(struct weston_compositor *ec,
813 int *argc, char *argv[]);
814
815 if (modules == NULL)
816 return 0;
817
818 p = modules;
819 while (*p) {
820 end = strchrnul(p, ',');
821 snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p);
Giulio Camuffo9c764df2016-06-29 11:54:27 +0200822
823 if (strstr(buffer, "xwayland.so")) {
824 if (wet_load_xwayland(ec) < 0)
825 return -1;
826 } else {
827 module_init = wet_load_module(buffer, "module_init");
828 if (!module_init)
829 return -1;
830 if (module_init(ec, argc, argv) < 0)
831 return -1;
832 }
Giulio Camuffobab996e2014-10-12 00:24:25 +0300833 p = end;
834 while (*p == ',')
835 p++;
836
837 }
838
839 return 0;
840}
841
842static int
843weston_compositor_init_config(struct weston_compositor *ec,
844 struct weston_config *config)
845{
846 struct xkb_rule_names xkb_names;
847 struct weston_config_section *s;
848 int repaint_msec;
Bob Ham91880f12016-01-12 10:21:47 +0000849 int vt_switching;
Giulio Camuffobab996e2014-10-12 00:24:25 +0300850
851 s = weston_config_get_section(config, "keyboard", NULL, NULL);
852 weston_config_section_get_string(s, "keymap_rules",
853 (char **) &xkb_names.rules, NULL);
854 weston_config_section_get_string(s, "keymap_model",
855 (char **) &xkb_names.model, NULL);
856 weston_config_section_get_string(s, "keymap_layout",
857 (char **) &xkb_names.layout, NULL);
858 weston_config_section_get_string(s, "keymap_variant",
859 (char **) &xkb_names.variant, NULL);
860 weston_config_section_get_string(s, "keymap_options",
861 (char **) &xkb_names.options, NULL);
862
Giulio Camuffo0358af42016-06-02 21:48:08 +0300863 if (weston_compositor_set_xkb_rule_names(ec, &xkb_names) < 0)
Giulio Camuffobab996e2014-10-12 00:24:25 +0300864 return -1;
865
866 weston_config_section_get_int(s, "repeat-rate",
867 &ec->kb_repeat_rate, 40);
868 weston_config_section_get_int(s, "repeat-delay",
869 &ec->kb_repeat_delay, 400);
870
Bob Ham91880f12016-01-12 10:21:47 +0000871 weston_config_section_get_bool(s, "vt-switching",
872 &vt_switching, true);
873 ec->vt_switching = vt_switching;
874
Giulio Camuffobab996e2014-10-12 00:24:25 +0300875 s = weston_config_get_section(config, "core", NULL, NULL);
876 weston_config_section_get_int(s, "repaint-window", &repaint_msec,
877 ec->repaint_msec);
878 if (repaint_msec < -10 || repaint_msec > 1000) {
879 weston_log("Invalid repaint_window value in config: %d\n",
880 repaint_msec);
881 } else {
882 ec->repaint_msec = repaint_msec;
883 }
884 weston_log("Output repaint window is %d ms maximum.\n",
885 ec->repaint_msec);
886
887 return 0;
888}
889
890static char *
891weston_choose_default_backend(void)
892{
893 char *backend = NULL;
894
895 if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET"))
896 backend = strdup("wayland-backend.so");
897 else if (getenv("DISPLAY"))
898 backend = strdup("x11-backend.so");
899 else
900 backend = strdup(WESTON_NATIVE_BACKEND);
901
902 return backend;
903}
904
905static const struct { const char *name; uint32_t token; } transforms[] = {
906 { "normal", WL_OUTPUT_TRANSFORM_NORMAL },
907 { "90", WL_OUTPUT_TRANSFORM_90 },
908 { "180", WL_OUTPUT_TRANSFORM_180 },
909 { "270", WL_OUTPUT_TRANSFORM_270 },
910 { "flipped", WL_OUTPUT_TRANSFORM_FLIPPED },
911 { "flipped-90", WL_OUTPUT_TRANSFORM_FLIPPED_90 },
912 { "flipped-180", WL_OUTPUT_TRANSFORM_FLIPPED_180 },
913 { "flipped-270", WL_OUTPUT_TRANSFORM_FLIPPED_270 },
914};
915
916WL_EXPORT int
917weston_parse_transform(const char *transform, uint32_t *out)
918{
919 unsigned int i;
920
921 for (i = 0; i < ARRAY_LENGTH(transforms); i++)
922 if (strcmp(transforms[i].name, transform) == 0) {
923 *out = transforms[i].token;
924 return 0;
925 }
926
927 *out = WL_OUTPUT_TRANSFORM_NORMAL;
928 return -1;
929}
930
931WL_EXPORT const char *
932weston_transform_to_string(uint32_t output_transform)
933{
934 unsigned int i;
935
936 for (i = 0; i < ARRAY_LENGTH(transforms); i++)
937 if (transforms[i].token == output_transform)
938 return transforms[i].name;
939
940 return "<illegal value>";
941}
942
943static int
944load_configuration(struct weston_config **config, int32_t noconfig,
945 const char *config_file)
946{
947 const char *file = "weston.ini";
948 const char *full_path;
949
950 *config = NULL;
951
952 if (config_file)
953 file = config_file;
954
955 if (noconfig == 0)
956 *config = weston_config_parse(file);
957
958 if (*config) {
959 full_path = weston_config_get_full_path(*config);
960
961 weston_log("Using config file '%s'\n", full_path);
962 setenv(WESTON_CONFIG_FILE_ENV_VAR, full_path, 1);
963
964 return 0;
965 }
966
967 if (config_file && noconfig == 0) {
968 weston_log("fatal: error opening or reading config file"
969 " '%s'.\n", config_file);
970
971 return -1;
972 }
973
974 weston_log("Starting with no config file.\n");
975 setenv(WESTON_CONFIG_FILE_ENV_VAR, "", 1);
976
977 return 0;
978}
979
980static void
981handle_exit(struct weston_compositor *c)
982{
983 wl_display_terminate(c->wl_display);
984}
985
Armin Krezovića3666d22016-09-30 14:11:04 +0200986static void
987wet_output_set_scale(struct weston_output *output,
988 struct weston_config_section *section,
989 int32_t default_scale,
990 int32_t parsed_scale)
991{
992 int32_t scale = default_scale;
993
994 if (section)
995 weston_config_section_get_int(section, "scale", &scale, default_scale);
996
997 if (parsed_scale)
998 scale = parsed_scale;
999
1000 weston_output_set_scale(output, scale);
1001}
1002
1003/* UINT32_MAX is treated as invalid because 0 is a valid
1004 * enumeration value and the parameter is unsigned
1005 */
1006static void
1007wet_output_set_transform(struct weston_output *output,
1008 struct weston_config_section *section,
1009 uint32_t default_transform,
1010 uint32_t parsed_transform)
1011{
1012 char *t;
1013 uint32_t transform = default_transform;
1014
1015 if (section) {
1016 weston_config_section_get_string(section,
1017 "transform", &t, "normal");
1018
1019 if (weston_parse_transform(t, &transform) < 0) {
1020 weston_log("Invalid transform \"%s\" for output %s\n",
1021 t, output->name);
1022 transform = default_transform;
1023 }
1024 free(t);
1025 }
1026
1027 if (parsed_transform != UINT32_MAX)
1028 transform = parsed_transform;
1029
1030 weston_output_set_transform(output, transform);
1031}
1032
1033static int
1034wet_configure_windowed_output_from_config(struct weston_output *output,
1035 struct wet_output_config *defaults)
1036{
1037 const struct weston_windowed_output_api *api =
1038 weston_windowed_output_get_api(output->compositor);
1039
1040 struct weston_config *wc = wet_get_config(output->compositor);
1041 struct weston_config_section *section = NULL;
1042 struct wet_compositor *compositor = to_wet_compositor(output->compositor);
1043 struct wet_output_config *parsed_options = compositor->parsed_options;
1044 int width = defaults->width;
1045 int height = defaults->height;
1046
1047 assert(parsed_options);
1048
1049 if (!api) {
1050 weston_log("Cannot use weston_windowed_output_api.\n");
1051 return -1;
1052 }
1053
1054 section = weston_config_get_section(wc, "output", "name", output->name);
1055
1056 if (section) {
1057 char *mode;
1058
1059 weston_config_section_get_string(section, "mode", &mode, NULL);
1060 if (!mode || sscanf(mode, "%dx%d", &width,
1061 &height) != 2) {
1062 weston_log("Invalid mode for output %s. Using defaults.\n",
1063 output->name);
1064 width = defaults->width;
1065 height = defaults->height;
1066 }
1067 free(mode);
1068 }
1069
1070 if (parsed_options->width)
1071 width = parsed_options->width;
1072
1073 if (parsed_options->height)
1074 height = parsed_options->height;
1075
1076 wet_output_set_scale(output, section, defaults->scale, parsed_options->scale);
1077 wet_output_set_transform(output, section, defaults->transform, parsed_options->transform);
1078
1079 if (api->output_set_size(output, width, height) < 0) {
1080 weston_log("Cannot configure output \"%s\" using weston_windowed_output_api.\n",
1081 output->name);
1082 return -1;
1083 }
1084
1085 weston_output_enable(output);
1086
1087 return 0;
1088}
1089
Giulio Camuffo8aedf7b2016-06-02 21:48:12 +03001090static void
1091configure_input_device(struct weston_compositor *compositor,
1092 struct libinput_device *device)
1093{
1094 struct weston_config_section *s;
1095 struct weston_config *config = wet_get_config(compositor);
1096 int enable_tap;
1097 int enable_tap_default;
1098
1099 s = weston_config_get_section(config,
1100 "libinput", NULL, NULL);
1101
1102 if (libinput_device_config_tap_get_finger_count(device) > 0) {
1103 enable_tap_default =
1104 libinput_device_config_tap_get_default_enabled(
1105 device);
1106 weston_config_section_get_bool(s, "enable_tap",
1107 &enable_tap,
1108 enable_tap_default);
1109 libinput_device_config_tap_set_enabled(device,
1110 enable_tap);
1111 }
1112}
1113
Armin Krezović08368132016-09-30 14:11:05 +02001114static void
1115drm_backend_output_configure(struct wl_listener *listener, void *data)
1116{
1117 struct weston_output *output = data;
1118 struct weston_config *wc = wet_get_config(output->compositor);
1119 struct weston_config_section *section;
1120 const struct weston_drm_output_api *api = weston_drm_output_get_api(output->compositor);
1121 enum weston_drm_backend_output_mode mode =
1122 WESTON_DRM_BACKEND_OUTPUT_PREFERRED;
1123
1124 char *s;
1125 char *modeline = NULL;
1126 char *gbm_format = NULL;
1127 char *seat = NULL;
1128
1129 if (!api) {
1130 weston_log("Cannot use weston_drm_output_api.\n");
1131 return;
1132 }
1133
1134 section = weston_config_get_section(wc, "output", "name", output->name);
1135 weston_config_section_get_string(section, "mode", &s, "preferred");
1136
1137 if (strcmp(s, "off") == 0) {
1138 weston_output_disable(output);
1139 free(s);
1140 return;
1141 } else if (strcmp(s, "current") == 0) {
1142 mode = WESTON_DRM_BACKEND_OUTPUT_CURRENT;
1143 } else if (strcmp(s, "preferred") != 0) {
1144 modeline = s;
1145 s = NULL;
1146 }
1147 free(s);
1148
1149 if (api->set_mode(output, mode, modeline) < 0) {
1150 weston_log("Cannot configure an output using weston_drm_output_api.\n");
1151 free(modeline);
1152 return;
1153 }
1154 free(modeline);
1155
1156 wet_output_set_scale(output, section, 1, 0);
1157 wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX);
1158
1159 weston_config_section_get_string(section,
1160 "gbm-format", &gbm_format, NULL);
1161
1162 api->set_gbm_format(output, gbm_format);
1163 free(gbm_format);
1164
1165 weston_config_section_get_string(section, "seat", &seat, "");
1166
1167 api->set_seat(output, seat);
1168 free(seat);
1169
1170 weston_output_enable(output);
1171}
1172
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07001173static int
Pekka Paalanen321ede72016-06-03 15:28:40 +03001174load_drm_backend(struct weston_compositor *c,
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07001175 int *argc, char **argv, struct weston_config *wc)
1176{
1177 struct weston_drm_backend_config config = {{ 0, }};
1178 struct weston_config_section *section;
1179 int ret = 0;
1180
1181 const struct weston_option options[] = {
1182 { WESTON_OPTION_INTEGER, "connector", 0, &config.connector },
1183 { WESTON_OPTION_STRING, "seat", 0, &config.seat_id },
1184 { WESTON_OPTION_INTEGER, "tty", 0, &config.tty },
1185 { WESTON_OPTION_BOOLEAN, "current-mode", 0, &config.use_current_mode },
1186 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1187 };
1188
1189 parse_options(options, ARRAY_LENGTH(options), argc, argv);
1190
1191 section = weston_config_get_section(wc, "core", NULL, NULL);
1192 weston_config_section_get_string(section,
1193 "gbm-format", &config.gbm_format,
1194 NULL);
1195
1196 config.base.struct_version = WESTON_DRM_BACKEND_CONFIG_VERSION;
1197 config.base.struct_size = sizeof(struct weston_drm_backend_config);
Giulio Camuffo8aedf7b2016-06-02 21:48:12 +03001198 config.configure_device = configure_input_device;
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07001199
Pekka Paalanen50dbf382016-06-03 15:23:46 +03001200 ret = weston_compositor_load_backend(c, WESTON_BACKEND_DRM,
1201 &config.base);
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07001202
Armin Krezović08368132016-09-30 14:11:05 +02001203 wet_set_pending_output_handler(c, drm_backend_output_configure);
1204
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07001205 free(config.gbm_format);
1206 free(config.seat_id);
1207
1208 return ret;
1209}
1210
Armin Krezović7fb17752016-09-30 14:11:07 +02001211static void
1212headless_backend_output_configure(struct wl_listener *listener, void *data)
1213{
1214 struct weston_output *output = data;
1215 struct wet_output_config defaults = {
1216 .width = 1024,
1217 .height = 640,
1218 .scale = 1,
1219 .transform = WL_OUTPUT_TRANSFORM_NORMAL
1220 };
1221
1222 if (wet_configure_windowed_output_from_config(output, &defaults) < 0)
1223 weston_log("Cannot configure output \"%s\".\n", output->name);
1224}
1225
Giulio Camuffo43008c72015-10-17 19:24:15 +03001226static int
Pekka Paalanen321ede72016-06-03 15:28:40 +03001227load_headless_backend(struct weston_compositor *c,
Benoit Gschwind3c530942016-04-15 20:28:32 -07001228 int *argc, char **argv, struct weston_config *wc)
1229{
Armin Krezović7fb17752016-09-30 14:11:07 +02001230 const struct weston_windowed_output_api *api;
Benoit Gschwind3c530942016-04-15 20:28:32 -07001231 struct weston_headless_backend_config config = {{ 0, }};
Armin Krezović7fb17752016-09-30 14:11:07 +02001232 int no_outputs = 0;
Benoit Gschwind3c530942016-04-15 20:28:32 -07001233 int ret = 0;
Benoit Gschwind2da6d0c2016-04-29 15:21:54 +02001234 char *transform = NULL;
Benoit Gschwind3c530942016-04-15 20:28:32 -07001235
Armin Krezović7fb17752016-09-30 14:11:07 +02001236 struct wet_output_config *parsed_options = wet_init_parsed_options(c);
1237 if (!parsed_options)
1238 return -1;
Benoit Gschwind3c530942016-04-15 20:28:32 -07001239
1240 const struct weston_option options[] = {
Armin Krezović7fb17752016-09-30 14:11:07 +02001241 { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width },
1242 { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height },
Benoit Gschwind3c530942016-04-15 20:28:32 -07001243 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1244 { WESTON_OPTION_STRING, "transform", 0, &transform },
Armin Krezović7fb17752016-09-30 14:11:07 +02001245 { WESTON_OPTION_BOOLEAN, "no-outputs", 0, &no_outputs },
Benoit Gschwind3c530942016-04-15 20:28:32 -07001246 };
1247
1248 parse_options(options, ARRAY_LENGTH(options), argc, argv);
1249
Benoit Gschwind2da6d0c2016-04-29 15:21:54 +02001250 if (transform) {
Armin Krezović7fb17752016-09-30 14:11:07 +02001251 if (weston_parse_transform(transform, &parsed_options->transform) < 0) {
Benoit Gschwind2da6d0c2016-04-29 15:21:54 +02001252 weston_log("Invalid transform \"%s\"\n", transform);
Armin Krezović7fb17752016-09-30 14:11:07 +02001253 parsed_options->transform = UINT32_MAX;
1254 }
Benoit Gschwind2da6d0c2016-04-29 15:21:54 +02001255 free(transform);
1256 }
Benoit Gschwind3c530942016-04-15 20:28:32 -07001257
1258 config.base.struct_version = WESTON_HEADLESS_BACKEND_CONFIG_VERSION;
1259 config.base.struct_size = sizeof(struct weston_headless_backend_config);
1260
1261 /* load the actual wayland backend and configure it */
Pekka Paalanen50dbf382016-06-03 15:23:46 +03001262 ret = weston_compositor_load_backend(c, WESTON_BACKEND_HEADLESS,
1263 &config.base);
Benoit Gschwind3c530942016-04-15 20:28:32 -07001264
Armin Krezović7fb17752016-09-30 14:11:07 +02001265 if (ret < 0)
1266 return ret;
1267
1268 wet_set_pending_output_handler(c, headless_backend_output_configure);
1269
1270 if (!no_outputs) {
1271 api = weston_windowed_output_get_api(c);
1272
1273 if (!api) {
1274 weston_log("Cannot use weston_windowed_output_api.\n");
1275 return -1;
1276 }
1277
1278 if (api->output_create(c, "headless") < 0)
1279 return -1;
1280 }
1281
1282 return 0;
Benoit Gschwind3c530942016-04-15 20:28:32 -07001283}
1284
Benoit Gschwindbd573102016-04-22 17:05:26 +02001285static void
1286weston_rdp_backend_config_init(struct weston_rdp_backend_config *config)
1287{
1288 config->base.struct_version = WESTON_RDP_BACKEND_CONFIG_VERSION;
1289 config->base.struct_size = sizeof(struct weston_rdp_backend_config);
1290
1291 config->width = 640;
1292 config->height = 480;
1293 config->bind_address = NULL;
1294 config->port = 3389;
1295 config->rdp_key = NULL;
1296 config->server_cert = NULL;
1297 config->server_key = NULL;
1298 config->env_socket = 0;
1299 config->no_clients_resize = 0;
1300}
1301
1302static int
Pekka Paalanen321ede72016-06-03 15:28:40 +03001303load_rdp_backend(struct weston_compositor *c,
Benoit Gschwindbd573102016-04-22 17:05:26 +02001304 int *argc, char *argv[], struct weston_config *wc)
1305{
1306 struct weston_rdp_backend_config config = {{ 0, }};
1307 int ret = 0;
1308
1309 weston_rdp_backend_config_init(&config);
1310
1311 const struct weston_option rdp_options[] = {
1312 { WESTON_OPTION_BOOLEAN, "env-socket", 0, &config.env_socket },
1313 { WESTON_OPTION_INTEGER, "width", 0, &config.width },
1314 { WESTON_OPTION_INTEGER, "height", 0, &config.height },
1315 { WESTON_OPTION_STRING, "address", 0, &config.bind_address },
1316 { WESTON_OPTION_INTEGER, "port", 0, &config.port },
1317 { WESTON_OPTION_BOOLEAN, "no-clients-resize", 0, &config.no_clients_resize },
1318 { WESTON_OPTION_STRING, "rdp4-key", 0, &config.rdp_key },
1319 { WESTON_OPTION_STRING, "rdp-tls-cert", 0, &config.server_cert },
1320 { WESTON_OPTION_STRING, "rdp-tls-key", 0, &config.server_key }
1321 };
1322
1323 parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv);
1324
Pekka Paalanen50dbf382016-06-03 15:23:46 +03001325 ret = weston_compositor_load_backend(c, WESTON_BACKEND_RDP,
1326 &config.base);
Benoit Gschwindbd573102016-04-22 17:05:26 +02001327
1328 free(config.bind_address);
1329 free(config.rdp_key);
1330 free(config.server_cert);
1331 free(config.server_key);
1332 return ret;
1333}
1334
Armin Krezović6ba369d2016-09-30 14:11:06 +02001335static void
1336fbdev_backend_output_configure(struct wl_listener *listener, void *data)
1337{
1338 struct weston_output *output = data;
1339 struct weston_config *wc = wet_get_config(output->compositor);
1340 struct weston_config_section *section;
1341
1342 section = weston_config_get_section(wc, "output", "name", "fbdev");
1343
1344 wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX);
1345 weston_output_set_scale(output, 1);
1346
1347 weston_output_enable(output);
1348}
1349
Benoit Gschwind3c530942016-04-15 20:28:32 -07001350static int
Pekka Paalanen321ede72016-06-03 15:28:40 +03001351load_fbdev_backend(struct weston_compositor *c,
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001352 int *argc, char **argv, struct weston_config *wc)
1353{
1354 struct weston_fbdev_backend_config config = {{ 0, }};
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001355 int ret = 0;
1356
1357 const struct weston_option fbdev_options[] = {
1358 { WESTON_OPTION_INTEGER, "tty", 0, &config.tty },
1359 { WESTON_OPTION_STRING, "device", 0, &config.device },
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001360 };
1361
1362 parse_options(fbdev_options, ARRAY_LENGTH(fbdev_options), argc, argv);
1363
1364 if (!config.device)
1365 config.device = strdup("/dev/fb0");
1366
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001367 config.base.struct_version = WESTON_FBDEV_BACKEND_CONFIG_VERSION;
1368 config.base.struct_size = sizeof(struct weston_fbdev_backend_config);
Giulio Camuffo8aedf7b2016-06-02 21:48:12 +03001369 config.configure_device = configure_input_device;
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001370
1371 /* load the actual wayland backend and configure it */
Pekka Paalanen50dbf382016-06-03 15:23:46 +03001372 ret = weston_compositor_load_backend(c, WESTON_BACKEND_FBDEV,
1373 &config.base);
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001374
Armin Krezović6ba369d2016-09-30 14:11:06 +02001375 if (ret < 0)
1376 goto out;
Benoit Gschwinde16acab2016-04-15 20:28:31 -07001377
Armin Krezović6ba369d2016-09-30 14:11:06 +02001378 wet_set_pending_output_handler(c, fbdev_backend_output_configure);
1379
1380out:
1381 free(config.device);
Benoit Gschwinde16acab2016-04-15 20:28:31 -07001382 return ret;
1383}
1384
1385static int
1386weston_x11_backend_config_append_output_config(struct weston_x11_backend_config *config,
1387 struct weston_x11_backend_output_config *output_config) {
1388 struct weston_x11_backend_output_config *new_outputs;
1389
1390 new_outputs = realloc(config->outputs, (config->num_outputs+1) *
1391 sizeof(struct weston_x11_backend_output_config));
1392 if (new_outputs == NULL)
1393 return -1;
1394
1395 config->outputs = new_outputs;
1396 config->outputs[config->num_outputs].width = output_config->width;
1397 config->outputs[config->num_outputs].height = output_config->height;
1398 config->outputs[config->num_outputs].transform = output_config->transform;
1399 config->outputs[config->num_outputs].scale = output_config->scale;
1400 config->outputs[config->num_outputs].name = strdup(output_config->name);
1401 config->num_outputs++;
1402
1403 return 0;
1404}
1405
1406static int
Pekka Paalanen321ede72016-06-03 15:28:40 +03001407load_x11_backend(struct weston_compositor *c,
Benoit Gschwinde16acab2016-04-15 20:28:31 -07001408 int *argc, char **argv, struct weston_config *wc)
1409{
1410 struct weston_x11_backend_output_config default_output;
1411 struct weston_x11_backend_config config = {{ 0, }};
1412 struct weston_config_section *section;
1413 int ret = 0;
1414 int option_width = 0;
1415 int option_height = 0;
1416 int option_scale = 0;
1417 int option_count = 1;
1418 int output_count = 0;
1419 char const *section_name;
1420 int i;
1421 uint32_t j;
1422
1423 const struct weston_option options[] = {
1424 { WESTON_OPTION_INTEGER, "width", 0, &option_width },
1425 { WESTON_OPTION_INTEGER, "height", 0, &option_height },
1426 { WESTON_OPTION_INTEGER, "scale", 0, &option_scale },
1427 { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &config.fullscreen },
1428 { WESTON_OPTION_INTEGER, "output-count", 0, &option_count },
1429 { WESTON_OPTION_BOOLEAN, "no-input", 0, &config.no_input },
1430 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1431 };
1432
1433 parse_options(options, ARRAY_LENGTH(options), argc, argv);
1434
1435 section = NULL;
1436 while (weston_config_next_section(wc, &section, &section_name)) {
1437 struct weston_x11_backend_output_config current_output = { 0, };
1438 char *t;
1439 char *mode;
1440
1441 if (strcmp(section_name, "output") != 0) {
1442 continue;
1443 }
1444
1445 weston_config_section_get_string(section, "name", &current_output.name, NULL);
1446 if (current_output.name == NULL || current_output.name[0] != 'X') {
1447 free(current_output.name);
1448 continue;
1449 }
1450
1451 weston_config_section_get_string(section, "mode", &mode, "1024x600");
1452 if (sscanf(mode, "%dx%d", &current_output.width,
1453 &current_output.height) != 2) {
1454 weston_log("Invalid mode \"%s\" for output %s\n",
1455 mode, current_output.name);
1456 current_output.width = 1024;
1457 current_output.height = 600;
1458 }
1459 free(mode);
1460 if (current_output.width < 1)
1461 current_output.width = 1024;
1462 if (current_output.height < 1)
1463 current_output.height = 600;
1464 if (option_width)
1465 current_output.width = option_width;
1466 if (option_height)
1467 current_output.height = option_height;
1468
1469 weston_config_section_get_int(section, "scale", &current_output.scale, 1);
1470 if (option_scale)
1471 current_output.scale = option_scale;
1472
1473 weston_config_section_get_string(section,
1474 "transform", &t, "normal");
1475 if (weston_parse_transform(t, &current_output.transform) < 0)
1476 weston_log("Invalid transform \"%s\" for output %s\n",
1477 t, current_output.name);
1478 free(t);
1479
1480 if (weston_x11_backend_config_append_output_config(&config, &current_output) < 0) {
1481 ret = -1;
1482 goto out;
1483 }
1484
1485 output_count++;
Bryce Harringtonaa258982016-05-03 01:34:23 -07001486 if (output_count >= option_count)
Benoit Gschwinde16acab2016-04-15 20:28:31 -07001487 break;
1488 }
1489
1490 default_output.name = NULL;
1491 default_output.width = option_width ? option_width : 1024;
1492 default_output.height = option_height ? option_height : 600;
1493 default_output.scale = option_scale ? option_scale : 1;
1494 default_output.transform = WL_OUTPUT_TRANSFORM_NORMAL;
1495
1496 for (i = output_count; i < option_count; i++) {
1497 if (asprintf(&default_output.name, "screen%d", i) < 0) {
1498 ret = -1;
1499 goto out;
1500 }
1501
1502 if (weston_x11_backend_config_append_output_config(&config, &default_output) < 0) {
1503 ret = -1;
1504 free(default_output.name);
1505 goto out;
1506 }
1507 free(default_output.name);
1508 }
1509
1510 config.base.struct_version = WESTON_X11_BACKEND_CONFIG_VERSION;
1511 config.base.struct_size = sizeof(struct weston_x11_backend_config);
1512
1513 /* load the actual backend and configure it */
Pekka Paalanen50dbf382016-06-03 15:23:46 +03001514 ret = weston_compositor_load_backend(c, WESTON_BACKEND_X11,
1515 &config.base);
Benoit Gschwinde16acab2016-04-15 20:28:31 -07001516
1517out:
1518 for (j = 0; j < config.num_outputs; ++j)
1519 free(config.outputs[j].name);
1520 free(config.outputs);
1521
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001522 return ret;
1523}
1524
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001525static void
1526weston_wayland_output_config_init(struct weston_wayland_backend_output_config *output_config,
1527 struct weston_config_section *config_section,
1528 int option_width, int option_height,
1529 int option_scale)
1530{
1531 char *mode, *t, *str;
1532 unsigned int slen;
1533
1534 weston_config_section_get_string(config_section, "name", &output_config->name,
1535 NULL);
1536 if (output_config->name) {
1537 slen = strlen(output_config->name);
1538 slen += strlen(WINDOW_TITLE " - ");
1539 str = malloc(slen + 1);
1540 if (str)
1541 snprintf(str, slen + 1, WINDOW_TITLE " - %s",
1542 output_config->name);
1543 free(output_config->name);
1544 output_config->name = str;
1545 }
1546 if (!output_config->name)
1547 output_config->name = strdup(WINDOW_TITLE);
1548
1549 weston_config_section_get_string(config_section,
1550 "mode", &mode, "1024x600");
1551 if (sscanf(mode, "%dx%d", &output_config->width, &output_config->height) != 2) {
1552 weston_log("Invalid mode \"%s\" for output %s\n",
1553 mode, output_config->name);
1554 output_config->width = 1024;
1555 output_config->height = 640;
1556 }
1557 free(mode);
1558
1559 if (option_width)
1560 output_config->width = option_width;
1561 if (option_height)
1562 output_config->height = option_height;
1563
1564 weston_config_section_get_int(config_section, "scale", &output_config->scale, 1);
1565
1566 if (option_scale)
1567 output_config->scale = option_scale;
1568
1569 weston_config_section_get_string(config_section,
1570 "transform", &t, "normal");
1571 if (weston_parse_transform(t, &output_config->transform) < 0)
1572 weston_log("Invalid transform \"%s\" for output %s\n",
1573 t, output_config->name);
1574 free(t);
1575
1576}
1577
1578static void
Benoit Gschwinde48ab5f2016-05-10 22:47:55 +02001579weston_wayland_backend_config_release(struct weston_wayland_backend_config *config)
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001580{
1581 int i;
1582
Benoit Gschwinde48ab5f2016-05-10 22:47:55 +02001583 for (i = 0; i < config->num_outputs; ++i) {
1584 free(config->outputs[i].name);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001585 }
Benoit Gschwinde48ab5f2016-05-10 22:47:55 +02001586 free(config->cursor_theme);
1587 free(config->display_name);
1588 free(config->outputs);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001589}
1590
1591/*
1592 * Append a new output struct at the end of new_config.outputs and return a
1593 * pointer to the newly allocated structure or NULL if fail. The allocated
1594 * structure is NOT cleared nor set to default values.
1595 */
1596static struct weston_wayland_backend_output_config *
Benoit Gschwind44e302b2016-05-10 22:47:56 +02001597weston_wayland_backend_config_add_new_output(struct weston_wayland_backend_config *config)
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001598{
1599 struct weston_wayland_backend_output_config *outputs;
1600 const size_t element_size = sizeof(struct weston_wayland_backend_output_config);
1601
Benoit Gschwind44e302b2016-05-10 22:47:56 +02001602 outputs = realloc(config->outputs,
1603 (config->num_outputs + 1) * element_size);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001604 if (!outputs)
1605 return NULL;
Benoit Gschwind44e302b2016-05-10 22:47:56 +02001606 config->num_outputs += 1;
1607 config->outputs = outputs;
1608 return &(config->outputs[config->num_outputs - 1]);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001609}
1610
1611static int
1612load_wayland_backend_config(struct weston_compositor *compositor, int *argc,
Benoit Gschwind6c1cd2f2016-05-10 22:47:50 +02001613 char *argv[], struct weston_config *wc,
Benoit Gschwind55a22882016-05-10 22:47:51 +02001614 struct weston_wayland_backend_config *config)
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001615{
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001616 struct weston_config_section *section;
1617 struct weston_wayland_backend_output_config *oc;
1618 int count, width, height, scale;
1619 const char *section_name;
1620 char *name;
1621
1622 const struct weston_option wayland_options[] = {
1623 { WESTON_OPTION_INTEGER, "width", 0, &width },
1624 { WESTON_OPTION_INTEGER, "height", 0, &height },
1625 { WESTON_OPTION_INTEGER, "scale", 0, &scale },
Benoit Gschwind55a22882016-05-10 22:47:51 +02001626 { WESTON_OPTION_STRING, "display", 0, &config->display_name },
1627 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config->use_pixman },
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001628 { WESTON_OPTION_INTEGER, "output-count", 0, &count },
Benoit Gschwind55a22882016-05-10 22:47:51 +02001629 { WESTON_OPTION_BOOLEAN, "fullscreen", 0, &config->fullscreen },
1630 { WESTON_OPTION_BOOLEAN, "sprawl", 0, &config->sprawl },
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001631 };
1632
1633 width = 0;
1634 height = 0;
1635 scale = 0;
Benoit Gschwind55a22882016-05-10 22:47:51 +02001636 config->display_name = NULL;
1637 config->use_pixman = 0;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001638 count = 1;
Benoit Gschwind55a22882016-05-10 22:47:51 +02001639 config->fullscreen = 0;
1640 config->sprawl = 0;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001641 parse_options(wayland_options,
1642 ARRAY_LENGTH(wayland_options), argc, argv);
1643
Benoit Gschwind55a22882016-05-10 22:47:51 +02001644 config->cursor_size = 32;
1645 config->cursor_theme = NULL;
1646 config->base.struct_size = sizeof(struct weston_wayland_backend_config);
1647 config->base.struct_version = WESTON_WAYLAND_BACKEND_CONFIG_VERSION;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001648
Benoit Gschwind6c1cd2f2016-05-10 22:47:50 +02001649 section = weston_config_get_section(wc, "shell", NULL, NULL);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001650 weston_config_section_get_string(section, "cursor-theme",
Benoit Gschwind55a22882016-05-10 22:47:51 +02001651 &config->cursor_theme, NULL);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001652 weston_config_section_get_int(section, "cursor-size",
Benoit Gschwind55a22882016-05-10 22:47:51 +02001653 &config->cursor_size, 32);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001654
Benoit Gschwind55a22882016-05-10 22:47:51 +02001655 if (config->sprawl) {
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001656 /* do nothing, everything is already set */
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001657 return 0;
1658 }
1659
Benoit Gschwind55a22882016-05-10 22:47:51 +02001660 if (config->fullscreen) {
Benoit Gschwind390af6d2016-05-10 22:47:52 +02001661 oc = weston_wayland_backend_config_add_new_output(config);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001662 if (!oc)
Benoit Gschwind53753842016-05-10 22:47:57 +02001663 return -1;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001664
1665 oc->width = width;
1666 oc->height = height;
1667 oc->name = NULL;
1668 oc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
1669 oc->scale = 1;
1670
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001671 return 0;
1672 }
1673
1674 section = NULL;
Benoit Gschwind6c1cd2f2016-05-10 22:47:50 +02001675 while (weston_config_next_section(wc, &section, &section_name)) {
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001676 if (!section_name || strcmp(section_name, "output") != 0)
1677 continue;
1678 weston_config_section_get_string(section, "name", &name, NULL);
1679 if (name == NULL)
1680 continue;
1681
1682 if (name[0] != 'W' || name[1] != 'L') {
1683 free(name);
1684 continue;
1685 }
1686 free(name);
1687
Benoit Gschwind390af6d2016-05-10 22:47:52 +02001688 oc = weston_wayland_backend_config_add_new_output(config);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001689 if (!oc)
Benoit Gschwind53753842016-05-10 22:47:57 +02001690 return -1;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001691
1692 weston_wayland_output_config_init(oc, section, width,
1693 height, scale);
1694 --count;
1695 }
1696
1697 if (!width)
1698 width = 1024;
1699 if (!height)
1700 height = 640;
1701 if (!scale)
1702 scale = 1;
Benoit Gschwind55a22882016-05-10 22:47:51 +02001703
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001704 while (count > 0) {
Benoit Gschwind390af6d2016-05-10 22:47:52 +02001705 oc = weston_wayland_backend_config_add_new_output(config);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001706 if (!oc)
Benoit Gschwind53753842016-05-10 22:47:57 +02001707 return -1;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001708
1709 oc->width = width;
1710 oc->height = height;
1711 oc->name = NULL;
1712 oc->transform = WL_OUTPUT_TRANSFORM_NORMAL;
1713 oc->scale = scale;
1714
1715 --count;
1716 }
1717
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001718 return 0;
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001719}
1720
1721static int
Pekka Paalanen321ede72016-06-03 15:28:40 +03001722load_wayland_backend(struct weston_compositor *c,
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001723 int *argc, char **argv, struct weston_config *wc)
1724{
1725 struct weston_wayland_backend_config config = {{ 0, }};
1726 int ret = 0;
1727
1728 ret = load_wayland_backend_config(c, argc, argv, wc, &config);
Bryce Harrington1dbdc0b2016-07-12 16:59:05 -07001729 if (ret < 0) {
Benoit Gschwind53753842016-05-10 22:47:57 +02001730 weston_wayland_backend_config_release(&config);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001731 return ret;
1732 }
1733
1734 /* load the actual wayland backend and configure it */
Pekka Paalanen50dbf382016-06-03 15:23:46 +03001735 ret = weston_compositor_load_backend(c, WESTON_BACKEND_WAYLAND,
1736 &config.base);
Benoit Gschwind68d6a6c2016-05-10 22:47:53 +02001737 weston_wayland_backend_config_release(&config);
Benoit Gschwind3ff10da2016-05-10 22:47:49 +02001738 return ret;
1739}
1740
1741
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001742static int
Giulio Camuffo43008c72015-10-17 19:24:15 +03001743load_backend(struct weston_compositor *compositor, const char *backend,
1744 int *argc, char **argv, struct weston_config *config)
1745{
Benoit Gschwind3c530942016-04-15 20:28:32 -07001746 if (strstr(backend, "headless-backend.so"))
Pekka Paalanen321ede72016-06-03 15:28:40 +03001747 return load_headless_backend(compositor, argc, argv, config);
Benoit Gschwindbd573102016-04-22 17:05:26 +02001748 else if (strstr(backend, "rdp-backend.so"))
Pekka Paalanen321ede72016-06-03 15:28:40 +03001749 return load_rdp_backend(compositor, argc, argv, config);
Benoit Gschwind934e89a2016-04-27 23:56:42 +02001750 else if (strstr(backend, "fbdev-backend.so"))
Pekka Paalanen321ede72016-06-03 15:28:40 +03001751 return load_fbdev_backend(compositor, argc, argv, config);
Giulio Camuffo1c0e40d2016-04-29 15:40:34 -07001752 else if (strstr(backend, "drm-backend.so"))
Pekka Paalanen321ede72016-06-03 15:28:40 +03001753 return load_drm_backend(compositor, argc, argv, config);
Benoit Gschwinde16acab2016-04-15 20:28:31 -07001754 else if (strstr(backend, "x11-backend.so"))
Pekka Paalanen321ede72016-06-03 15:28:40 +03001755 return load_x11_backend(compositor, argc, argv, config);
Giulio Camuffo43008c72015-10-17 19:24:15 +03001756 else if (strstr(backend, "wayland-backend.so"))
Pekka Paalanen321ede72016-06-03 15:28:40 +03001757 return load_wayland_backend(compositor, argc, argv, config);
Giulio Camuffo43008c72015-10-17 19:24:15 +03001758
Pekka Paalanen808b0062016-06-03 13:56:17 +03001759 weston_log("Error: unknown backend \"%s\"\n", backend);
1760 return -1;
Giulio Camuffo43008c72015-10-17 19:24:15 +03001761}
1762
Pekka Paalanen20436e22016-02-11 14:42:21 +02001763static char *
1764copy_command_line(int argc, char * const argv[])
1765{
1766 FILE *fp;
1767 char *str = NULL;
1768 size_t size = 0;
1769 int i;
1770
1771 fp = open_memstream(&str, &size);
1772 if (!fp)
1773 return NULL;
1774
1775 fprintf(fp, "%s", argv[0]);
1776 for (i = 1; i < argc; i++)
1777 fprintf(fp, " %s", argv[i]);
1778 fclose(fp);
1779
1780 return str;
1781}
1782
Giulio Camuffobab996e2014-10-12 00:24:25 +03001783int main(int argc, char *argv[])
1784{
1785 int ret = EXIT_FAILURE;
Pekka Paalanen20436e22016-02-11 14:42:21 +02001786 char *cmdline;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001787 struct wl_display *display;
1788 struct weston_compositor *ec;
1789 struct wl_event_source *signals[4];
1790 struct wl_event_loop *loop;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001791 int i, fd;
1792 char *backend = NULL;
1793 char *shell = NULL;
1794 char *modules = NULL;
1795 char *option_modules = NULL;
1796 char *log = NULL;
Bryce Harrington25a2bdd2016-08-03 17:40:52 -07001797 char *server_socket = NULL;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001798 int32_t idle_time = -1;
1799 int32_t help = 0;
1800 char *socket_name = NULL;
1801 int32_t version = 0;
1802 int32_t noconfig = 0;
1803 int32_t numlock_on;
1804 char *config_file = NULL;
1805 struct weston_config *config = NULL;
1806 struct weston_config_section *section;
1807 struct wl_client *primary_client;
1808 struct wl_listener primary_client_destroyed;
1809 struct weston_seat *seat;
Armin Krezović78a36372016-08-01 18:51:46 +02001810 struct wet_compositor user_data;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001811
1812 const struct weston_option core_options[] = {
1813 { WESTON_OPTION_STRING, "backend", 'B', &backend },
1814 { WESTON_OPTION_STRING, "shell", 0, &shell },
1815 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
1816 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
1817 { WESTON_OPTION_STRING, "modules", 0, &option_modules },
1818 { WESTON_OPTION_STRING, "log", 0, &log },
1819 { WESTON_OPTION_BOOLEAN, "help", 'h', &help },
1820 { WESTON_OPTION_BOOLEAN, "version", 0, &version },
1821 { WESTON_OPTION_BOOLEAN, "no-config", 0, &noconfig },
1822 { WESTON_OPTION_STRING, "config", 'c', &config_file },
1823 };
1824
Pekka Paalanen20436e22016-02-11 14:42:21 +02001825 cmdline = copy_command_line(argc, argv);
Giulio Camuffobab996e2014-10-12 00:24:25 +03001826 parse_options(core_options, ARRAY_LENGTH(core_options), &argc, argv);
1827
Pekka Paalanen20436e22016-02-11 14:42:21 +02001828 if (help) {
1829 free(cmdline);
Giulio Camuffobab996e2014-10-12 00:24:25 +03001830 usage(EXIT_SUCCESS);
Pekka Paalanen20436e22016-02-11 14:42:21 +02001831 }
Giulio Camuffobab996e2014-10-12 00:24:25 +03001832
1833 if (version) {
1834 printf(PACKAGE_STRING "\n");
Pekka Paalanen20436e22016-02-11 14:42:21 +02001835 free(cmdline);
1836
Giulio Camuffobab996e2014-10-12 00:24:25 +03001837 return EXIT_SUCCESS;
1838 }
1839
Giulio Camuffobe2b11a2016-06-02 21:48:13 +03001840 weston_log_set_handler(vlog, vlog_continue);
Giulio Camuffobab996e2014-10-12 00:24:25 +03001841 weston_log_file_open(log);
1842
1843 weston_log("%s\n"
1844 STAMP_SPACE "%s\n"
1845 STAMP_SPACE "Bug reports to: %s\n"
1846 STAMP_SPACE "Build: %s\n",
1847 PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
1848 BUILD_ID);
Pekka Paalanen20436e22016-02-11 14:42:21 +02001849 weston_log("Command line: %s\n", cmdline);
1850 free(cmdline);
Giulio Camuffobab996e2014-10-12 00:24:25 +03001851 log_uname();
1852
1853 verify_xdg_runtime_dir();
1854
1855 display = wl_display_create();
1856
1857 loop = wl_display_get_event_loop(display);
1858 signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
1859 display);
1860 signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
1861 display);
1862 signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
1863 display);
1864
1865 wl_list_init(&child_process_list);
1866 signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
1867 NULL);
1868
1869 if (!signals[0] || !signals[1] || !signals[2] || !signals[3])
1870 goto out_signals;
1871
1872 if (load_configuration(&config, noconfig, config_file) < 0)
1873 goto out_signals;
Armin Krezović78a36372016-08-01 18:51:46 +02001874 user_data.config = config;
Armin Krezovića3666d22016-09-30 14:11:04 +02001875 user_data.parsed_options = NULL;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001876
1877 section = weston_config_get_section(config, "core", NULL, NULL);
1878
1879 if (!backend) {
1880 weston_config_section_get_string(section, "backend", &backend,
1881 NULL);
1882 if (!backend)
1883 backend = weston_choose_default_backend();
1884 }
1885
Armin Krezović78a36372016-08-01 18:51:46 +02001886 ec = weston_compositor_create(display, &user_data);
Giulio Camuffobab996e2014-10-12 00:24:25 +03001887 if (ec == NULL) {
1888 weston_log("fatal: failed to create compositor\n");
Giulio Camuffo3c241b12015-10-03 16:25:16 +03001889 goto out;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001890 }
1891
Giulio Camuffobab996e2014-10-12 00:24:25 +03001892 if (weston_compositor_init_config(ec, config) < 0)
Giulio Camuffo3c241b12015-10-03 16:25:16 +03001893 goto out;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001894
Giulio Camuffo43008c72015-10-17 19:24:15 +03001895 if (load_backend(ec, backend, &argc, argv, config) < 0) {
Giulio Camuffobab996e2014-10-12 00:24:25 +03001896 weston_log("fatal: failed to create compositor backend\n");
Giulio Camuffo3c241b12015-10-03 16:25:16 +03001897 goto out;
Giulio Camuffobab996e2014-10-12 00:24:25 +03001898 }
1899
Armin Krezovića3666d22016-09-30 14:11:04 +02001900 weston_pending_output_coldplug(ec);
1901
Giulio Camuffobab996e2014-10-12 00:24:25 +03001902 catch_signals();
1903 segv_compositor = ec;
1904
1905 if (idle_time < 0)
1906 weston_config_section_get_int(section, "idle-time", &idle_time, -1);
1907 if (idle_time < 0)
1908 idle_time = 300; /* default idle timeout, in seconds */
1909
1910 ec->idle_time = idle_time;
1911 ec->default_pointer_grab = NULL;
1912 ec->exit = handle_exit;
1913
1914 weston_compositor_log_capabilities(ec);
1915
1916 server_socket = getenv("WAYLAND_SERVER_SOCKET");
1917 if (server_socket) {
1918 weston_log("Running with single client\n");
Bryce Harrington25a2bdd2016-08-03 17:40:52 -07001919 if (!safe_strtoint(server_socket, &fd))
Giulio Camuffobab996e2014-10-12 00:24:25 +03001920 fd = -1;
1921 } else {
1922 fd = -1;
1923 }
1924
1925 if (fd != -1) {
1926 primary_client = wl_client_create(display, fd);
1927 if (!primary_client) {
1928 weston_log("fatal: failed to add client: %m\n");
1929 goto out;
1930 }
1931 primary_client_destroyed.notify =
1932 handle_primary_client_destroyed;
1933 wl_client_add_destroy_listener(primary_client,
1934 &primary_client_destroyed);
1935 } else if (weston_create_listening_socket(display, socket_name)) {
1936 goto out;
1937 }
1938
1939 if (!shell)
1940 weston_config_section_get_string(section, "shell", &shell,
1941 "desktop-shell.so");
1942
1943 if (load_modules(ec, shell, &argc, argv) < 0)
1944 goto out;
1945
1946 weston_config_section_get_string(section, "modules", &modules, "");
1947 if (load_modules(ec, modules, &argc, argv) < 0)
1948 goto out;
1949
1950 if (load_modules(ec, option_modules, &argc, argv) < 0)
1951 goto out;
1952
1953 section = weston_config_get_section(config, "keyboard", NULL, NULL);
1954 weston_config_section_get_bool(section, "numlock-on", &numlock_on, 0);
1955 if (numlock_on) {
1956 wl_list_for_each(seat, &ec->seat_list, link) {
Derek Foreman1281a362015-07-31 16:55:32 -05001957 struct weston_keyboard *keyboard =
1958 weston_seat_get_keyboard(seat);
1959
1960 if (keyboard)
1961 weston_keyboard_set_locks(keyboard,
Giulio Camuffobab996e2014-10-12 00:24:25 +03001962 WESTON_NUM_LOCK,
1963 WESTON_NUM_LOCK);
1964 }
1965 }
1966
1967 for (i = 1; i < argc; i++)
1968 weston_log("fatal: unhandled option: %s\n", argv[i]);
1969 if (argc > 1)
1970 goto out;
1971
1972 weston_compositor_wake(ec);
1973
1974 wl_display_run(display);
1975
1976 /* Allow for setting return exit code after
1977 * wl_display_run returns normally. This is
1978 * useful for devs/testers and automated tests
1979 * that want to indicate failure status to
1980 * testing infrastructure above
1981 */
1982 ret = ec->exit_code;
1983
1984out:
Armin Krezovića3666d22016-09-30 14:11:04 +02001985 /* free(NULL) is valid, and it won't be NULL if it's used */
1986 free(user_data.parsed_options);
1987
Giulio Camuffobab996e2014-10-12 00:24:25 +03001988 weston_compositor_destroy(ec);
1989
1990out_signals:
1991 for (i = ARRAY_LENGTH(signals) - 1; i >= 0; i--)
1992 if (signals[i])
1993 wl_event_source_remove(signals[i]);
1994
1995 wl_display_destroy(display);
1996
1997 weston_log_file_close();
1998
1999 if (config)
2000 weston_config_destroy(config);
2001 free(config_file);
2002 free(backend);
2003 free(shell);
2004 free(socket_name);
2005 free(option_modules);
2006 free(log);
2007 free(modules);
2008
2009 return ret;
2010}