1 #define _POSIX_C_SOURCE 200809L
2 #include <assert.h>
3 #include <errno.h>
4 #include <libinput.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <unistd.h>
8 #include <wayland-server-core.h>
9 #include <wlr/backend/drm.h>
10 #include <wlr/backend/headless.h>
11 #include <wlr/backend/interface.h>
12 #include <wlr/backend/libinput.h>
13 #include <wlr/backend/multi.h>
14 #include <wlr/backend/noop.h>
15 #include <wlr/backend/session.h>
16 #include <wlr/backend/wayland.h>
17 #include <wlr/config.h>
18 #include <wlr/util/log.h>
19 #include "backend/multi.h"
20
21 #if WLR_HAS_X11_BACKEND
22 #include <wlr/backend/x11.h>
23 #endif
24
wlr_backend_init(struct wlr_backend * backend,const struct wlr_backend_impl * impl)25 void wlr_backend_init(struct wlr_backend *backend,
26 const struct wlr_backend_impl *impl) {
27 assert(backend);
28 backend->impl = impl;
29 wl_signal_init(&backend->events.destroy);
30 wl_signal_init(&backend->events.new_input);
31 wl_signal_init(&backend->events.new_output);
32 }
33
wlr_backend_start(struct wlr_backend * backend)34 bool wlr_backend_start(struct wlr_backend *backend) {
35 if (backend->impl->start) {
36 return backend->impl->start(backend);
37 }
38 return true;
39 }
40
wlr_backend_destroy(struct wlr_backend * backend)41 void wlr_backend_destroy(struct wlr_backend *backend) {
42 if (!backend) {
43 return;
44 }
45
46 if (backend->impl && backend->impl->destroy) {
47 backend->impl->destroy(backend);
48 } else {
49 free(backend);
50 }
51 }
52
wlr_backend_get_renderer(struct wlr_backend * backend)53 struct wlr_renderer *wlr_backend_get_renderer(struct wlr_backend *backend) {
54 if (backend->impl->get_renderer) {
55 return backend->impl->get_renderer(backend);
56 }
57 return NULL;
58 }
59
wlr_backend_get_session(struct wlr_backend * backend)60 struct wlr_session *wlr_backend_get_session(struct wlr_backend *backend) {
61 if (backend->impl->get_session) {
62 return backend->impl->get_session(backend);
63 }
64 return NULL;
65 }
66
wlr_backend_get_presentation_clock(struct wlr_backend * backend)67 clockid_t wlr_backend_get_presentation_clock(struct wlr_backend *backend) {
68 if (backend->impl->get_presentation_clock) {
69 return backend->impl->get_presentation_clock(backend);
70 }
71 return CLOCK_MONOTONIC;
72 }
73
parse_outputs_env(const char * name)74 static size_t parse_outputs_env(const char *name) {
75 const char *outputs_str = getenv(name);
76 if (outputs_str == NULL) {
77 return 1;
78 }
79
80 char *end;
81 int outputs = (int)strtol(outputs_str, &end, 10);
82 if (*end || outputs < 0) {
83 wlr_log(WLR_ERROR, "%s specified with invalid integer, ignoring", name);
84 return 1;
85 }
86
87 return outputs;
88 }
89
attempt_wl_backend(struct wl_display * display,wlr_renderer_create_func_t create_renderer_func)90 static struct wlr_backend *attempt_wl_backend(struct wl_display *display,
91 wlr_renderer_create_func_t create_renderer_func) {
92 struct wlr_backend *backend = wlr_wl_backend_create(display, NULL, create_renderer_func);
93 if (backend == NULL) {
94 return NULL;
95 }
96
97 size_t outputs = parse_outputs_env("WLR_WL_OUTPUTS");
98 for (size_t i = 0; i < outputs; ++i) {
99 wlr_wl_output_create(backend);
100 }
101
102 return backend;
103 }
104
105 #if WLR_HAS_X11_BACKEND
attempt_x11_backend(struct wl_display * display,const char * x11_display,wlr_renderer_create_func_t create_renderer_func)106 static struct wlr_backend *attempt_x11_backend(struct wl_display *display,
107 const char *x11_display, wlr_renderer_create_func_t create_renderer_func) {
108 struct wlr_backend *backend = wlr_x11_backend_create(display, x11_display, create_renderer_func);
109 if (backend == NULL) {
110 return NULL;
111 }
112
113 size_t outputs = parse_outputs_env("WLR_X11_OUTPUTS");
114 for (size_t i = 0; i < outputs; ++i) {
115 wlr_x11_output_create(backend);
116 }
117
118 return backend;
119 }
120 #endif
121
attempt_headless_backend(struct wl_display * display,wlr_renderer_create_func_t create_renderer_func)122 static struct wlr_backend *attempt_headless_backend(
123 struct wl_display *display, wlr_renderer_create_func_t create_renderer_func) {
124 struct wlr_backend *backend = wlr_headless_backend_create(display, create_renderer_func);
125 if (backend == NULL) {
126 return NULL;
127 }
128
129 size_t outputs = parse_outputs_env("WLR_HEADLESS_OUTPUTS");
130 for (size_t i = 0; i < outputs; ++i) {
131 wlr_headless_add_output(backend, 1280, 720);
132 }
133
134 return backend;
135 }
136
attempt_noop_backend(struct wl_display * display)137 static struct wlr_backend *attempt_noop_backend(struct wl_display *display) {
138 struct wlr_backend *backend = wlr_noop_backend_create(display);
139 if (backend == NULL) {
140 return NULL;
141 }
142
143 size_t outputs = parse_outputs_env("WLR_NOOP_OUTPUTS");
144 for (size_t i = 0; i < outputs; ++i) {
145 wlr_noop_add_output(backend);
146 }
147
148 return backend;
149 }
150
attempt_drm_backend(struct wl_display * display,struct wlr_backend * backend,struct wlr_session * session,wlr_renderer_create_func_t create_renderer_func)151 static struct wlr_backend *attempt_drm_backend(struct wl_display *display,
152 struct wlr_backend *backend, struct wlr_session *session,
153 wlr_renderer_create_func_t create_renderer_func) {
154 int gpus[8];
155 size_t num_gpus = wlr_session_find_gpus(session, 8, gpus);
156 struct wlr_backend *primary_drm = NULL;
157 wlr_log(WLR_INFO, "Found %zu GPUs", num_gpus);
158
159 for (size_t i = 0; i < num_gpus; ++i) {
160 struct wlr_backend *drm = wlr_drm_backend_create(display, session,
161 gpus[i], primary_drm, create_renderer_func);
162 if (!drm) {
163 wlr_log(WLR_ERROR, "Failed to open DRM device %d", gpus[i]);
164 continue;
165 }
166
167 if (!primary_drm) {
168 primary_drm = drm;
169 }
170
171 wlr_multi_backend_add(backend, drm);
172 }
173
174 return primary_drm;
175 }
176
attempt_backend_by_name(struct wl_display * display,struct wlr_backend * backend,struct wlr_session ** session,const char * name,wlr_renderer_create_func_t create_renderer_func)177 static struct wlr_backend *attempt_backend_by_name(struct wl_display *display,
178 struct wlr_backend *backend, struct wlr_session **session,
179 const char *name, wlr_renderer_create_func_t create_renderer_func) {
180 if (strcmp(name, "wayland") == 0) {
181 return attempt_wl_backend(display, create_renderer_func);
182 #if WLR_HAS_X11_BACKEND
183 } else if (strcmp(name, "x11") == 0) {
184 return attempt_x11_backend(display, NULL, create_renderer_func);
185 #endif
186 } else if (strcmp(name, "headless") == 0) {
187 return attempt_headless_backend(display, create_renderer_func);
188 } else if (strcmp(name, "noop") == 0) {
189 return attempt_noop_backend(display);
190 } else if (strcmp(name, "drm") == 0 || strcmp(name, "libinput") == 0) {
191 // DRM and libinput need a session
192 if (!*session) {
193 *session = wlr_session_create(display);
194 if (!*session) {
195 wlr_log(WLR_ERROR, "failed to start a session");
196 return NULL;
197 }
198 }
199
200 if (strcmp(name, "libinput") == 0) {
201 return wlr_libinput_backend_create(display, *session);
202 } else {
203 return attempt_drm_backend(display, backend, *session, create_renderer_func);
204 }
205 }
206
207 wlr_log(WLR_ERROR, "unrecognized backend '%s'", name);
208 return NULL;
209 }
210
wlr_backend_autocreate(struct wl_display * display,wlr_renderer_create_func_t create_renderer_func)211 struct wlr_backend *wlr_backend_autocreate(struct wl_display *display,
212 wlr_renderer_create_func_t create_renderer_func) {
213 struct wlr_backend *backend = wlr_multi_backend_create(display);
214 struct wlr_multi_backend *multi = (struct wlr_multi_backend *)backend;
215 if (!backend) {
216 wlr_log(WLR_ERROR, "could not allocate multibackend");
217 return NULL;
218 }
219
220 char *names = getenv("WLR_BACKENDS");
221 if (names) {
222 names = strdup(names);
223 if (names == NULL) {
224 wlr_log(WLR_ERROR, "allocation failed");
225 wlr_backend_destroy(backend);
226 return NULL;
227 }
228
229 char *saveptr;
230 char *name = strtok_r(names, ",", &saveptr);
231 while (name != NULL) {
232 struct wlr_backend *subbackend = attempt_backend_by_name(display,
233 backend, &multi->session, name, create_renderer_func);
234 if (subbackend == NULL) {
235 wlr_log(WLR_ERROR, "failed to start backend '%s'", name);
236 wlr_session_destroy(multi->session);
237 wlr_backend_destroy(backend);
238 free(names);
239 return NULL;
240 }
241
242 if (!wlr_multi_backend_add(backend, subbackend)) {
243 wlr_log(WLR_ERROR, "failed to add backend '%s'", name);
244 wlr_session_destroy(multi->session);
245 wlr_backend_destroy(backend);
246 free(names);
247 return NULL;
248 }
249
250 name = strtok_r(NULL, ",", &saveptr);
251 }
252
253 free(names);
254 return backend;
255 }
256
257 if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET")) {
258 struct wlr_backend *wl_backend = attempt_wl_backend(display,
259 create_renderer_func);
260 if (!wl_backend) {
261 goto error;
262 }
263
264 wlr_multi_backend_add(backend, wl_backend);
265 return backend;
266 }
267
268 #if WLR_HAS_X11_BACKEND
269 const char *x11_display = getenv("DISPLAY");
270 if (x11_display) {
271 struct wlr_backend *x11_backend =
272 attempt_x11_backend(display, x11_display, create_renderer_func);
273 if (!x11_backend) {
274 goto error;
275 }
276
277 wlr_multi_backend_add(backend, x11_backend);
278 return backend;
279 }
280 #endif
281
282 // Attempt DRM+libinput
283 multi->session = wlr_session_create(display);
284 if (!multi->session) {
285 wlr_log(WLR_ERROR, "Failed to start a DRM session");
286 wlr_backend_destroy(backend);
287 return NULL;
288 }
289
290 struct wlr_backend *libinput = wlr_libinput_backend_create(display,
291 multi->session);
292 if (!libinput) {
293 wlr_log(WLR_ERROR, "Failed to start libinput backend");
294 wlr_session_destroy(multi->session);
295 wlr_backend_destroy(backend);
296 return NULL;
297 }
298 wlr_multi_backend_add(backend, libinput);
299
300 struct wlr_backend *primary_drm = attempt_drm_backend(display, backend,
301 multi->session, create_renderer_func);
302 if (!primary_drm) {
303 wlr_log(WLR_ERROR, "Failed to open any DRM device");
304 wlr_backend_destroy(libinput);
305 wlr_session_destroy(multi->session);
306 wlr_backend_destroy(backend);
307 return NULL;
308 }
309
310 return backend;
311
312 error:
313 wlr_backend_destroy(backend);
314 return NULL;
315 }
316