blankie
/
wlroots
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #123 from ascent12/session-multi-gpu 

Session Multi-GPU
This commit is contained in:
Drew DeVault 2017-08-26 08:22:44 -05:00 committed by GitHub
parent 48fa59c22e d16b2977f6
commit 2f5ff45039
21 changed files with 354 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
backend/backend.c
View File

@ -12,7 +12,6 @@
#include <wlr/backend/wayland.h> #include <wlr/backend/wayland.h>
#include <wlr/backend/multi.h> #include <wlr/backend/multi.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/udev.h"
void wlr_backend_init(struct wlr_backend *backend, void wlr_backend_init(struct wlr_backend *backend,
const struct wlr_backend_impl *impl) { const struct wlr_backend_impl *impl) {
@ -85,35 +84,29 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display) {
// Attempt DRM+libinput // Attempt DRM+libinput
struct wlr_session *session = wlr_session_start(display); struct wlr_session *session = wlr_session_create(display);
if (!session) { if (!session) {
wlr_log(L_ERROR, "Failed to start a DRM session"); wlr_log(L_ERROR, "Failed to start a DRM session");
return NULL; return NULL;
} }
struct wlr_udev *udev = wlr_udev_create(display); int gpu = wlr_session_find_gpu(session);
if (!udev) { if (gpu == -1) {
wlr_log(L_ERROR, "Failed to start udev"); wlr_log(L_ERROR, "Failed to open DRM device");
goto error_session; goto error_session;
} }
int gpu = wlr_udev_find_gpu(udev, session); backend = wlr_multi_backend_create(session);
if (gpu == -1) {
wlr_log(L_ERROR, "Failed to open DRM device");
goto error_udev;
}
backend = wlr_multi_backend_create(session, udev);
if (!backend) { if (!backend) {
goto error_gpu; goto error_gpu;
} }
struct wlr_backend *libinput = wlr_libinput_backend_create(display, session, udev); struct wlr_backend *libinput = wlr_libinput_backend_create(display, session);
if (!libinput) { if (!libinput) {
goto error_multi; goto error_multi;
} }
struct wlr_backend *drm = wlr_drm_backend_create(display, session, udev, gpu); struct wlr_backend *drm = wlr_drm_backend_create(display, session, gpu);
if (!drm) { if (!drm) {
goto error_libinput; goto error_libinput;
} }
@ -128,9 +121,7 @@ error_multi:
wlr_backend_destroy(backend); wlr_backend_destroy(backend);
error_gpu: error_gpu:
wlr_session_close_file(session, gpu); wlr_session_close_file(session, gpu);
error_udev:
wlr_udev_destroy(udev);
error_session: error_session:
wlr_session_finish(session); wlr_session_destroy(session);
return NULL; return NULL;
} }

9
backend/drm/backend.c
View File

@ -13,7 +13,6 @@
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include <wlr/egl.h> #include <wlr/egl.h>
#include "backend/udev.h"
#include "backend/drm.h" #include "backend/drm.h"
static bool wlr_drm_backend_start(struct wlr_backend *_backend) { static bool wlr_drm_backend_start(struct wlr_backend *_backend) {
@ -32,7 +31,6 @@ static void wlr_drm_backend_destroy(struct wlr_backend *_backend) {
wlr_output_destroy(&output->output); wlr_output_destroy(&output->output);
} }
wlr_udev_signal_remove(backend->udev, &backend->drm_invalidated);
wlr_drm_renderer_free(&backend->renderer); wlr_drm_renderer_free(&backend->renderer);
wlr_drm_resources_free(backend); wlr_drm_resources_free(backend);
wlr_session_close_file(backend->session, backend->fd); wlr_session_close_file(backend->session, backend->fd);
@ -84,8 +82,6 @@ static void session_signal(struct wl_listener *listener, void *data) {
static void drm_invalidated(struct wl_listener *listener, void *data) { static void drm_invalidated(struct wl_listener *listener, void *data) {
struct wlr_drm_backend *backend = struct wlr_drm_backend *backend =
wl_container_of(listener, backend, drm_invalidated); wl_container_of(listener, backend, drm_invalidated);
struct wlr_udev *udev = data;
(void)udev;
char *name = drmGetDeviceNameFromFd2(backend->fd); char *name = drmGetDeviceNameFromFd2(backend->fd);
wlr_log(L_DEBUG, "%s invalidated", name); wlr_log(L_DEBUG, "%s invalidated", name);
@ -95,7 +91,7 @@ static void drm_invalidated(struct wl_listener *listener, void *data) {
} }
struct wlr_backend *wlr_drm_backend_create(struct wl_display *display, struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
struct wlr_session *session, struct wlr_udev *udev, int gpu_fd) { struct wlr_session *session, int gpu_fd) {
assert(display && session && gpu_fd >= 0); assert(display && session && gpu_fd >= 0);
char *name = drmGetDeviceNameFromFd2(gpu_fd); char *name = drmGetDeviceNameFromFd2(gpu_fd);
@ -112,7 +108,6 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
wlr_backend_init(&backend->backend, &backend_impl); wlr_backend_init(&backend->backend, &backend_impl);
backend->session = session; backend->session = session;
backend->udev = udev;
backend->outputs = list_create(); backend->outputs = list_create();
if (!backend->outputs) { if (!backend->outputs) {
wlr_log(L_ERROR, "Failed to allocate list"); wlr_log(L_ERROR, "Failed to allocate list");
@ -128,7 +123,7 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
backend->dev = st.st_rdev; backend->dev = st.st_rdev;
backend->drm_invalidated.notify = drm_invalidated; backend->drm_invalidated.notify = drm_invalidated;
wlr_udev_signal_add(udev, backend->dev, &backend->drm_invalidated); wlr_session_signal_add(session, gpu_fd, &backend->drm_invalidated);
backend->display = display; backend->display = display;
struct wl_event_loop *event_loop = wl_display_get_event_loop(display); struct wl_event_loop *event_loop = wl_display_get_event_loop(display);

8
backend/libinput/backend.c
View File

@ -4,7 +4,6 @@
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/udev.h"
#include "backend/libinput.h" #include "backend/libinput.h"
static int wlr_libinput_open_restricted(const char *path, static int wlr_libinput_open_restricted(const char *path,
@ -47,7 +46,7 @@ static bool wlr_libinput_backend_start(struct wlr_backend *_backend) {
struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend; struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend;
wlr_log(L_DEBUG, "Initializing libinput"); wlr_log(L_DEBUG, "Initializing libinput");
backend->libinput_context = libinput_udev_create_context(&libinput_impl, backend, backend->libinput_context = libinput_udev_create_context(&libinput_impl, backend,
backend->udev->udev); backend->session->udev);
if (!backend->libinput_context) { if (!backend->libinput_context) {
wlr_log(L_ERROR, "Failed to create libinput context"); wlr_log(L_ERROR, "Failed to create libinput context");
return false; return false;
@ -139,8 +138,8 @@ static void session_signal(struct wl_listener *listener, void *data) {
} }
struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display, struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display,
struct wlr_session *session, struct wlr_udev *udev) { struct wlr_session *session) {
assert(display && session && udev); assert(display && session);
struct wlr_libinput_backend *backend = calloc(1, sizeof(struct wlr_libinput_backend)); struct wlr_libinput_backend *backend = calloc(1, sizeof(struct wlr_libinput_backend));
if (!backend) { if (!backend) {
@ -155,7 +154,6 @@ struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display,
} }
backend->session = session; backend->session = session;
backend->udev = udev;
backend->display = display; backend->display = display;
backend->session_signal.notify = session_signal; backend->session_signal.notify = session_signal;

1
backend/meson.build
View File

@ -1,6 +1,5 @@
backend_files = files( backend_files = files(
'backend.c', 'backend.c',
'udev.c',
'session/direct-ipc.c', 'session/direct-ipc.c',
'session/direct.c', 'session/direct.c',
'session/session.c', 'session/session.c',

8
backend/multi/backend.c
View File

@ -2,7 +2,6 @@
#include <stdbool.h> #include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/udev.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/multi.h" #include "backend/multi.h"
@ -36,8 +35,7 @@ static void multi_backend_destroy(struct wlr_backend *_backend) {
free(sub); free(sub);
} }
list_free(backend->backends); list_free(backend->backends);
wlr_session_finish(backend->session); wlr_session_destroy(backend->session);
wlr_udev_destroy(backend->udev);
free(backend); free(backend);
} }
@ -59,8 +57,7 @@ struct wlr_backend_impl backend_impl = {
.get_egl = multi_backend_get_egl .get_egl = multi_backend_get_egl
}; };
struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session, struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session) {
struct wlr_udev *udev) {
struct wlr_multi_backend *backend = struct wlr_multi_backend *backend =
calloc(1, sizeof(struct wlr_multi_backend)); calloc(1, sizeof(struct wlr_multi_backend));
if (!backend) { if (!backend) {
@ -78,7 +75,6 @@ struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session,
wlr_backend_init(&backend->backend, &backend_impl); wlr_backend_init(&backend->backend, &backend_impl);
backend->session = session; backend->session = session;
backend->udev = udev;
return &backend->backend; return &backend->backend;
} }

2
backend/session/direct-ipc.c
View File

@ -212,7 +212,7 @@ void direct_ipc_finish(int sock, pid_t pid) {
waitpid(pid, NULL, 0); waitpid(pid, NULL, 0);
} }
int direct_ipc_start(pid_t *pid_out) { int direct_ipc_init(pid_t *pid_out) {
if (!have_permissions()) { if (!have_permissions()) {
return -1; return -1;
} }

38
backend/session/direct.c
View File

@ -48,7 +48,7 @@ static int direct_session_open(struct wlr_session *base, const char *path) {
} }
if (major(st.st_rdev) == DRM_MAJOR) { if (major(st.st_rdev) == DRM_MAJOR) {
session->base.drm_fd = fd; direct_ipc_setmaster(session->sock, fd);
} }
return fd; return fd;
@ -65,8 +65,7 @@ static void direct_session_close(struct wlr_session *base, int fd) {
} }
if (major(st.st_rdev) == DRM_MAJOR) { if (major(st.st_rdev) == DRM_MAJOR) {
direct_ipc_dropmaster(session->sock, session->base.drm_fd); direct_ipc_dropmaster(session->sock, fd);
session->base.drm_fd = -1;
} else if (major(st.st_rdev) == INPUT_MAJOR) { } else if (major(st.st_rdev) == INPUT_MAJOR) {
ioctl(fd, EVIOCREVOKE, 0); ioctl(fd, EVIOCREVOKE, 0);
} }
@ -79,7 +78,7 @@ static bool direct_change_vt(struct wlr_session *base, unsigned vt) {
return ioctl(session->tty_fd, VT_ACTIVATE, (int)vt) == 0; return ioctl(session->tty_fd, VT_ACTIVATE, (int)vt) == 0;
} }
static void direct_session_finish(struct wlr_session *base) { static void direct_session_destroy(struct wlr_session *base) {
struct direct_session *session = wl_container_of(base, session, base); struct direct_session *session = wl_container_of(base, session, base);
struct vt_mode mode = { struct vt_mode mode = {
.mode = VT_AUTO, .mode = VT_AUTO,
@ -109,11 +108,27 @@ static int vt_handler(int signo, void *data) {
if (session->base.active) { if (session->base.active) {
session->base.active = false; session->base.active = false;
wl_signal_emit(&session->base.session_signal, session); wl_signal_emit(&session->base.session_signal, session);
direct_ipc_dropmaster(session->sock, session->base.drm_fd);
struct wlr_device *dev;
wl_list_for_each(dev, &session->base.devices, link) {
if (major(dev->dev) == DRM_MAJOR) {
direct_ipc_dropmaster(session->sock,
dev->fd);
}
}
ioctl(session->tty_fd, VT_RELDISP, 1); ioctl(session->tty_fd, VT_RELDISP, 1);
} else { } else {
ioctl(session->tty_fd, VT_RELDISP, VT_ACKACQ); ioctl(session->tty_fd, VT_RELDISP, VT_ACKACQ);
direct_ipc_setmaster(session->sock, session->base.drm_fd);
struct wlr_device *dev;
wl_list_for_each(dev, &session->base.devices, link) {
if (major(dev->dev) == DRM_MAJOR) {
direct_ipc_setmaster(session->sock,
dev->fd);
}
}
session->base.active = true; session->base.active = true;
wl_signal_emit(&session->base.session_signal, session); wl_signal_emit(&session->base.session_signal, session);
} }
@ -196,14 +211,14 @@ error:
return false; return false;
} }
static struct wlr_session *direct_session_start(struct wl_display *disp) { static struct wlr_session *direct_session_create(struct wl_display *disp) {
struct direct_session *session = calloc(1, sizeof(*session)); struct direct_session *session = calloc(1, sizeof(*session));
if (!session) { if (!session) {
wlr_log_errno(L_ERROR, "Allocation failed"); wlr_log_errno(L_ERROR, "Allocation failed");
return NULL; return NULL;
} }
session->sock = direct_ipc_start(&session->child); session->sock = direct_ipc_init(&session->child);
if (session->sock == -1) { if (session->sock == -1) {
goto error_session; goto error_session;
} }
@ -221,10 +236,7 @@ static struct wlr_session *direct_session_start(struct wl_display *disp) {
wlr_log(L_INFO, "Successfully loaded direct session"); wlr_log(L_INFO, "Successfully loaded direct session");
snprintf(session->base.seat, sizeof(session->base.seat), "%s", seat); snprintf(session->base.seat, sizeof(session->base.seat), "%s", seat);
session->base.drm_fd = -1;
session->base.impl = &session_direct; session->base.impl = &session_direct;
session->base.active = true;
wl_signal_init(&session->base.session_signal);
return &session->base; return &session->base;
error_ipc: error_ipc:
@ -236,8 +248,8 @@ error_session:
} }
const struct session_impl session_direct = { const struct session_impl session_direct = {
.start = direct_session_start, .create = direct_session_create,
.finish = direct_session_finish, .destroy = direct_session_destroy,
.open = direct_session_open, .open = direct_session_open,
.close = direct_session_close, .close = direct_session_close,
.change_vt = direct_change_vt, .change_vt = direct_change_vt,

40
backend/session/logind.c
View File

@ -1,4 +1,5 @@
#define _POSIX_C_SOURCE 200809L #define _POSIX_C_SOURCE 200809L
#include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
@ -67,10 +68,6 @@ static int logind_take_device(struct wlr_session *base, const char *path) {
goto error; goto error;
} }
if (major(st.st_rdev) == DRM_MAJOR) {
session->base.drm_fd = fd;
}
error: error:
sd_bus_error_free(&error); sd_bus_error_free(&error);
sd_bus_message_unref(msg); sd_bus_message_unref(msg);
@ -97,10 +94,6 @@ static void logind_release_device(struct wlr_session *base, int fd) {
wlr_log(L_ERROR, "Failed to release device '%d'", fd); wlr_log(L_ERROR, "Failed to release device '%d'", fd);
} }
if (major(st.st_rdev) == DRM_MAJOR) {
session->base.drm_fd = -1;
}
sd_bus_error_free(&error); sd_bus_error_free(&error);
sd_bus_message_unref(msg); sd_bus_message_unref(msg);
} }
@ -204,7 +197,7 @@ static void release_control(struct logind_session *session) {
sd_bus_message_unref(msg); sd_bus_message_unref(msg);
} }
static void logind_session_finish(struct wlr_session *base) { static void logind_session_destroy(struct wlr_session *base) {
struct logind_session *session = wl_container_of(base, session, base); struct logind_session *session = wl_container_of(base, session, base);
release_control(session); release_control(session);
@ -221,6 +214,20 @@ static int session_removed(sd_bus_message *msg, void *userdata, sd_bus_error *re
return 0; return 0;
} }
static struct wlr_device *find_device(struct wlr_session *session, dev_t devnum) {
struct wlr_device *dev;
wl_list_for_each(dev, &session->devices, link) {
if (dev->dev == devnum) {
return dev;
}
}
wlr_log(L_ERROR, "Tried to use dev_t %lu not opened by session",
(unsigned long)devnum);
assert(0);
}
static int pause_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_error) { static int pause_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_error) {
struct logind_session *session = userdata; struct logind_session *session = userdata;
int ret; int ret;
@ -267,10 +274,14 @@ static int resume_device(sd_bus_message *msg, void *userdata, sd_bus_error *ret_
} }
if (major == DRM_MAJOR) { if (major == DRM_MAJOR) {
dup2(fd, session->base.drm_fd); struct wlr_device *dev = find_device(&session->base, makedev(major, minor));
dup2(fd, dev->fd);
if (!session->base.active) {
session->base.active = true; session->base.active = true;
wl_signal_emit(&session->base.session_signal, session); wl_signal_emit(&session->base.session_signal, session);
} }
}
error: error:
return 0; return 0;
@ -316,7 +327,7 @@ static int dbus_event(int fd, uint32_t mask, void *data) {
return 1; return 1;
} }
static struct wlr_session *logind_session_start(struct wl_display *disp) { static struct wlr_session *logind_session_create(struct wl_display *disp) {
int ret; int ret;
struct logind_session *session = calloc(1, sizeof(*session)); struct logind_session *session = calloc(1, sizeof(*session));
if (!session) { if (!session) {
@ -374,10 +385,7 @@ static struct wlr_session *logind_session_start(struct wl_display *disp) {
wlr_log(L_INFO, "Successfully loaded logind session"); wlr_log(L_INFO, "Successfully loaded logind session");
session->base.drm_fd = -1;
session->base.impl = &session_logind; session->base.impl = &session_logind;
session->base.active = true;
wl_signal_init(&session->base.session_signal);
return &session->base; return &session->base;
error_bus: error_bus:
@ -390,8 +398,8 @@ error:
} }
const struct session_impl session_logind = { const struct session_impl session_logind = {
.start = logind_session_start, .create = logind_session_create,
.finish = logind_session_finish, .destroy = logind_session_destroy,
.open = logind_take_device, .open = logind_take_device,
.close = logind_release_device, .close = logind_release_device,
.change_vt = logind_change_vt, .change_vt = logind_change_vt,

269
backend/session/session.c
View File

@ -1,5 +1,13 @@
#include <assert.h>
#include <stddef.h> #include <stddef.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <libudev.h>
#include <wayland-server.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/session/interface.h> #include <wlr/backend/session/interface.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
@ -15,34 +23,159 @@ static const struct session_impl *impls[] = {
NULL, NULL,
}; };
struct wlr_session *wlr_session_start(struct wl_display *disp) { static int udev_event(int fd, uint32_t mask, void *data) {
struct wlr_session *session = data;
struct udev_device *udev_dev = udev_monitor_receive_device(session->mon);
if (!udev_dev) {
return 1;
}
const char *action = udev_device_get_action(udev_dev);
wlr_log(L_DEBUG, "udev event for %s (%s)",
udev_device_get_sysname(udev_dev), action);
if (!action || strcmp(action, "change") != 0) {
goto out;
}
dev_t devnum = udev_device_get_devnum(udev_dev);
struct wlr_device *dev;
wl_list_for_each(dev, &session->devices, link) {
if (dev->dev == devnum) {
wl_signal_emit(&dev->signal, session);
break;
}
}
out:
udev_device_unref(udev_dev);
return 1;
}
struct wlr_session *wlr_session_create(struct wl_display *disp) {
struct wlr_session *session = NULL;
const struct session_impl **iter; const struct session_impl **iter;
for (iter = impls; *iter; ++iter) { for (iter = impls; !session && *iter; ++iter) {
struct wlr_session *session = (*iter)->start(disp); session = (*iter)->create(disp);
if (session) {
return session;
}
} }
if (!session) {
wlr_log(L_ERROR, "Failed to load session backend"); wlr_log(L_ERROR, "Failed to load session backend");
return NULL; return NULL;
}
session->active = true;
wl_signal_init(&session->session_signal);
wl_list_init(&session->devices);
session->udev = udev_new();
if (!session->udev) {
wlr_log_errno(L_ERROR, "Failed to create udev context");
goto error_session;
}
session->mon = udev_monitor_new_from_netlink(session->udev, "udev");
if (!session->mon) {
wlr_log_errno(L_ERROR, "Failed to create udev monitor");
goto error_udev;
}
udev_monitor_filter_add_match_subsystem_devtype(session->mon, "drm", NULL);
udev_monitor_enable_receiving(session->mon);
struct wl_event_loop *event_loop = wl_display_get_event_loop(disp);
int fd = udev_monitor_get_fd(session->mon);
session->udev_event = wl_event_loop_add_fd(event_loop, fd,
WL_EVENT_READABLE, udev_event, session);
if (!session->udev_event) {
wlr_log_errno(L_ERROR, "Failed to create udev event source");
goto error_mon;
}
return session;
error_mon:
udev_monitor_unref(session->mon);
error_udev:
udev_unref(session->udev);
error_session:
wlr_session_destroy(session);
return NULL;
} }
void wlr_session_finish(struct wlr_session *session) { void wlr_session_destroy(struct wlr_session *session) {
if (!session) { if (!session) {
return; return;
} }
session->impl->finish(session); wl_event_source_remove(session->udev_event);
}; udev_monitor_unref(session->mon);
udev_unref(session->udev);
session->impl->destroy(session);
}
int wlr_session_open_file(struct wlr_session *session, const char *path) { int wlr_session_open_file(struct wlr_session *session, const char *path) {
return session->impl->open(session, path); int fd = session->impl->open(session, path);
if (fd < 0) {
return fd;
}
struct wlr_device *dev = malloc(sizeof(*dev));
if (!dev) {
wlr_log_errno(L_ERROR, "Allocation failed");
goto error;
}
struct stat st;
if (fstat(fd, &st) < 0) {
wlr_log_errno(L_ERROR, "Stat failed");
goto error;
}
dev->fd = fd;
dev->dev = st.st_rdev;
wl_signal_init(&dev->signal);
wl_list_insert(&session->devices, &dev->link);
return fd;
error:
free(dev);
return fd;
}
static struct wlr_device *find_device(struct wlr_session *session, int fd) {
struct wlr_device *dev;
wl_list_for_each(dev, &session->devices, link) {
if (dev->fd == fd) {
return dev;
}
}
wlr_log(L_ERROR, "Tried to use fd %d not opened by session", fd);
assert(0);
} }
void wlr_session_close_file(struct wlr_session *session, int fd) { void wlr_session_close_file(struct wlr_session *session, int fd) {
struct wlr_device *dev = find_device(session, fd);
session->impl->close(session, fd); session->impl->close(session, fd);
wl_list_remove(&dev->link);
free(dev);
}
void wlr_session_signal_add(struct wlr_session *session, int fd,
struct wl_listener *listener) {
struct wlr_device *dev = find_device(session, fd);
wl_signal_add(&dev->signal, listener);
} }
bool wlr_session_change_vt(struct wlr_session *session, unsigned vt) { bool wlr_session_change_vt(struct wlr_session *session, unsigned vt) {
@ -52,3 +185,119 @@ bool wlr_session_change_vt(struct wlr_session *session, unsigned vt) {
return session->impl->change_vt(session, vt); return session->impl->change_vt(session, vt);
} }
/* Tests if 'path' is KMS compatible by trying to open it.
* It leaves the open device in *fd_out it it succeeds.
*/
static bool device_is_kms(struct wlr_session *restrict session,
const char *restrict path, int *restrict fd_out) {
int fd;
if (!path) {
return false;
}
fd = wlr_session_open_file(session, path);
if (fd < 0) {
return false;
}
drmModeRes *res = drmModeGetResources(fd);
if (!res) {
goto out_fd;
}
if (res->count_crtcs <= 0 || res->count_connectors <= 0 ||
res->count_encoders <= 0) {
goto out_res;
}
if (*fd_out >= 0) {
wlr_session_close_file(session, *fd_out);
}
*fd_out = fd;
drmModeFreeResources(res);
return true;
out_res:
drmModeFreeResources(res);
out_fd:
wlr_session_close_file(session, fd);
return false;
}
/* Tries to find the primary GPU by checking for the "boot_vga" attribute.
* If it's not found, it returns the first valid GPU it finds.
*/
int wlr_session_find_gpu(struct wlr_session *session) {
struct udev_enumerate *en = udev_enumerate_new(session->udev);
if (!en) {
wlr_log(L_ERROR, "Failed to create udev enumeration");
return -1;
}
udev_enumerate_add_match_subsystem(en, "drm");
udev_enumerate_add_match_sysname(en, "card[0-9]*");
udev_enumerate_scan_devices(en);
struct udev_list_entry *entry;
int fd = -1;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(en)) {
bool is_boot_vga = false;
const char *path = udev_list_entry_get_name(entry);
struct udev_device *dev = udev_device_new_from_syspath(session->udev, path);
if (!dev) {
continue;
}
/*
const char *seat = udev_device_get_property_value(dev, "ID_SEAT");
if (!seat)
seat = "seat0";
if (strcmp(session->seat, seat) != 0) {
udev_device_unref(dev);
continue;
}
*/
// This is owned by 'dev', so we don't need to free it
struct udev_device *pci =
udev_device_get_parent_with_subsystem_devtype(dev, "pci", NULL);
if (pci) {
const char *id = udev_device_get_sysattr_value(pci, "boot_vga");
if (id && strcmp(id, "1") == 0) {
is_boot_vga = true;
}
}
// We already have a valid GPU
if (!is_boot_vga && fd >= 0) {
udev_device_unref(dev);
continue;
}
path = udev_device_get_devnode(dev);
if (!device_is_kms(session, path, &fd)) {
udev_device_unref(dev);
continue;
}
udev_device_unref(dev);
// We've found the primary GPU
if (is_boot_vga) {
break;
}
}
udev_enumerate_unref(en);
return fd;
}

252
backend/udev.c
View File

@ -1,252 +0,0 @@
#define _POSIX_C_SOURCE 200809L
#include <libudev.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <wayland-server.h>
#include <wlr/backend/session.h>
#include <wlr/util/log.h>
#include "backend/udev.h"
/* Tests if 'path' is KMS compatible by trying to open it.
* It leaves the open device in *fd_out it it succeeds.
*/
static bool device_is_kms(struct wlr_session *restrict session,
const char *restrict path, int *restrict fd_out) {
int fd;
if (!path) {
return false;
}
fd = wlr_session_open_file(session, path);
if (fd < 0) {
return false;
}
drmModeRes *res = drmModeGetResources(fd);
if (!res) {
goto out_fd;
}
if (res->count_crtcs <= 0 || res->count_connectors <= 0 ||
res->count_encoders <= 0) {
goto out_res;
}
if (*fd_out >= 0) {
wlr_session_close_file(session, *fd_out);
}
*fd_out = fd;
drmModeFreeResources(res);
return true;
out_res:
drmModeFreeResources(res);
out_fd:
wlr_session_close_file(session, fd);
return false;
}
/* Tries to find the primary GPU by checking for the "boot_vga" attribute.
* If it's not found, it returns the first valid GPU it finds.
*/
int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session) {
struct udev_enumerate *en = udev_enumerate_new(udev->udev);
if (!en) {
wlr_log(L_ERROR, "Failed to create udev enumeration");
return -1;
}
udev_enumerate_add_match_subsystem(en, "drm");
udev_enumerate_add_match_sysname(en, "card[0-9]*");
udev_enumerate_scan_devices(en);
struct udev_list_entry *entry;
int fd = -1;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(en)) {
bool is_boot_vga = false;
const char *path = udev_list_entry_get_name(entry);
struct udev_device *dev = udev_device_new_from_syspath(udev->udev, path);
if (!dev) {
continue;
}
/*
const char *seat = udev_device_get_property_value(dev, "ID_SEAT");
if (!seat)
seat = "seat0";
if (strcmp(session->seat, seat) != 0) {
udev_device_unref(dev);
continue;
}
*/
// This is owned by 'dev', so we don't need to free it
struct udev_device *pci =
udev_device_get_parent_with_subsystem_devtype(dev, "pci", NULL);
if (pci) {
const char *id = udev_device_get_sysattr_value(pci, "boot_vga");
if (id && strcmp(id, "1") == 0) {
is_boot_vga = true;
}
}
// We already have a valid GPU
if (!is_boot_vga && fd >= 0) {
udev_device_unref(dev);
continue;
}
path = udev_device_get_devnode(dev);
if (!device_is_kms(session, path, &fd)) {
udev_device_unref(dev);
continue;
}
udev_device_unref(dev);
// We've found the primary GPU
if (is_boot_vga) {
break;
}
}
udev_enumerate_unref(en);
return fd;
}
static int udev_event(int fd, uint32_t mask, void *data) {
struct wlr_udev *udev = data;
struct udev_device *dev = udev_monitor_receive_device(udev->mon);
if (!dev) {
return 1;
}
const char *action = udev_device_get_action(dev);
wlr_log(L_DEBUG, "udev event for %s (%s)",
udev_device_get_sysname(dev), action);
if (!action || strcmp(action, "change") != 0) {
goto out;
}
dev_t devnum = udev_device_get_devnum(dev);
struct wlr_udev_dev *signal;
wl_list_for_each(signal, &udev->devices, link) {
if (signal->dev == devnum) {
wl_signal_emit(&signal->invalidate, udev);
break;
}
}
out:
udev_device_unref(dev);
return 1;
}
struct wlr_udev *wlr_udev_create(struct wl_display *display) {
struct wlr_udev *udev = calloc(sizeof(struct wlr_udev), 1);
if (!udev) {
return NULL;
}
udev->udev = udev_new();
if (!udev->udev) {
wlr_log(L_ERROR, "Failed to create udev context");
goto error;
}
udev->mon = udev_monitor_new_from_netlink(udev->udev, "udev");
if (!udev->mon) {
wlr_log(L_ERROR, "Failed to create udev monitor");
goto error_udev;
}
udev_monitor_filter_add_match_subsystem_devtype(udev->mon, "drm", NULL);
udev_monitor_enable_receiving(udev->mon);
struct wl_event_loop *event_loop = wl_display_get_event_loop(display);
int fd = udev_monitor_get_fd(udev->mon);
udev->event = wl_event_loop_add_fd(event_loop, fd, WL_EVENT_READABLE,
udev_event, udev);
if (!udev->event) {
wlr_log(L_ERROR, "Failed to create udev event source");
goto error_mon;
}
wl_list_init(&udev->devices);
wlr_log(L_DEBUG, "Successfully initialized udev");
return udev;
error_mon:
udev_monitor_unref(udev->mon);
error_udev:
udev_unref(udev->udev);
error:
free(udev);
return NULL;
}
void wlr_udev_destroy(struct wlr_udev *udev) {
if (!udev) {
return;
}
struct wlr_udev_dev *dev, *tmp;
wl_list_for_each_safe(dev, tmp, &udev->devices, link) {
free(dev);
}
wl_event_source_remove(udev->event);
udev_monitor_unref(udev->mon);
udev_unref(udev->udev);
free(udev);
}
bool wlr_udev_signal_add(struct wlr_udev *udev, dev_t dev, struct wl_listener *listener) {
struct wlr_udev_dev *device = malloc(sizeof(*device));
if (!device) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return false;
}
device->dev = dev;
wl_signal_init(&device->invalidate);
wl_signal_add(&device->invalidate, listener);
wl_list_insert(&udev->devices, &device->link);
return true;
}
void wlr_udev_signal_remove(struct wlr_udev *udev, struct wl_listener *listener) {
if (!udev || !listener) {
return;
}
struct wlr_udev_dev *dev, *tmp;
wl_list_for_each_safe(dev, tmp, &udev->devices, link) {
// The signal should only have a single listener
if (wl_signal_get(&dev->invalidate, listener->notify) != NULL) {
wl_list_remove(&dev->link);
free(dev);
return;
}
}
}

3
include/backend/drm.h
View File

@ -7,7 +7,6 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <xf86drmMode.h> #include <xf86drmMode.h>
#include <EGL/egl.h> #include <EGL/egl.h>
#include <libudev.h>
#include <gbm.h> #include <gbm.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
@ -16,7 +15,6 @@
#include <wlr/egl.h> #include <wlr/egl.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include <backend/udev.h>
#include "drm-properties.h" #include "drm-properties.h"
struct wlr_drm_plane { struct wlr_drm_plane {
@ -124,7 +122,6 @@ struct wlr_drm_backend {
struct wlr_drm_renderer renderer; struct wlr_drm_renderer renderer;
struct wlr_session *session; struct wlr_session *session;
struct wlr_udev *udev;
}; };
enum wlr_drm_output_state { enum wlr_drm_output_state {

2
include/backend/libinput.h
View File

@ -6,13 +6,11 @@
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/interfaces/wlr_input_device.h> #include <wlr/interfaces/wlr_input_device.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include "backend/udev.h"
struct wlr_libinput_backend { struct wlr_libinput_backend {
struct wlr_backend backend; struct wlr_backend backend;
struct wlr_session *session; struct wlr_session *session;
struct wlr_udev *udev;
struct wl_display *display; struct wl_display *display;
struct libinput *libinput_context; struct libinput *libinput_context;

2
include/backend/multi.h
View File

@ -3,7 +3,6 @@
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/multi.h> #include <wlr/backend/multi.h>
#include <wlr/backend/udev.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
@ -11,7 +10,6 @@ struct wlr_multi_backend {
struct wlr_backend backend; struct wlr_backend backend;
struct wlr_session *session; struct wlr_session *session;
struct wlr_udev *udev;
list_t *backends; list_t *backends;
}; };

2
include/backend/session/direct-ipc.h
View File

@ -7,6 +7,6 @@ int direct_ipc_open(int sock, const char *path);
void direct_ipc_setmaster(int sock, int fd); void direct_ipc_setmaster(int sock, int fd);
void direct_ipc_dropmaster(int sock, int fd); void direct_ipc_dropmaster(int sock, int fd);
void direct_ipc_finish(int sock, pid_t pid); void direct_ipc_finish(int sock, pid_t pid);
int direct_ipc_start(pid_t *pid_out); int direct_ipc_init(pid_t *pid_out);
#endif #endif

29
include/backend/udev.h
View File

@ -1,29 +0,0 @@
#ifndef _WLR_INTERNAL_UDEV_H
#define _WLR_INTERNAL_UDEV_H
#include <sys/types.h>
#include <libudev.h>
#include <wlr/backend/session.h>
#include <wayland-server.h>
#include <wlr/backend/udev.h>
struct wlr_udev_dev {
dev_t dev;
struct wl_signal invalidate;
struct wl_list link;
};
struct wlr_udev {
struct udev *udev;
struct udev_monitor *mon;
struct wl_event_source *event;
struct wl_list devices;
};
int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session);
bool wlr_udev_signal_add(struct wlr_udev *udev, dev_t dev, struct wl_listener *listener);
void wlr_udev_signal_remove(struct wlr_udev *udev, struct wl_listener *listener);
#endif

3
include/wlr/backend/drm.h
View File

@ -4,10 +4,9 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/udev.h>
struct wlr_backend *wlr_drm_backend_create(struct wl_display *display, struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
struct wlr_session *session, struct wlr_udev *udev, int gpu_fd); struct wlr_session *session, int gpu_fd);
bool wlr_backend_is_drm(struct wlr_backend *backend); bool wlr_backend_is_drm(struct wlr_backend *backend);

3
include/wlr/backend/libinput.h
View File

@ -5,11 +5,10 @@
#include <wayland-server.h> #include <wayland-server.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/udev.h>
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display, struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display,
struct wlr_session *session, struct wlr_udev *udev); struct wlr_session *session);
struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev); struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev);
bool wlr_backend_is_libinput(struct wlr_backend *backend); bool wlr_backend_is_libinput(struct wlr_backend *backend);

4
include/wlr/backend/multi.h
View File

@ -2,11 +2,9 @@
#define _WLR_BACKEND_MULTI_H #define _WLR_BACKEND_MULTI_H
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/udev.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session, struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session);
struct wlr_udev *udev);
void wlr_multi_backend_add(struct wlr_backend *multi, void wlr_multi_backend_add(struct wlr_backend *multi,
struct wlr_backend *backend); struct wlr_backend *backend);

24
include/wlr/backend/session.h
View File

@ -3,10 +3,19 @@
#include <stdbool.h> #include <stdbool.h>
#include <wayland-server.h> #include <wayland-server.h>
#include <libudev.h>
#include <sys/types.h> #include <sys/types.h>
struct session_impl; struct session_impl;
struct wlr_device {
int fd;
dev_t dev;
struct wl_signal signal;
struct wl_list link;
};
struct wlr_session { struct wlr_session {
const struct session_impl *impl; const struct session_impl *impl;
/* /*
@ -16,9 +25,14 @@ struct wlr_session {
struct wl_signal session_signal; struct wl_signal session_signal;
bool active; bool active;
int drm_fd;
unsigned vtnr; unsigned vtnr;
char seat[8]; char seat[8];
struct udev *udev;
struct udev_monitor *mon;
struct wl_event_source *udev_event;
struct wl_list devices;
}; };
/* /*
@ -31,14 +45,14 @@ struct wlr_session {
* *
* Returns NULL on error. * Returns NULL on error.
*/ */
struct wlr_session *wlr_session_start(struct wl_display *disp); struct wlr_session *wlr_session_create(struct wl_display *disp);
/* /*
* Closes a previously opened session and restores the virtual terminal. * Closes a previously opened session and restores the virtual terminal.
* You should call wlr_session_close_file on each files you opened * You should call wlr_session_close_file on each files you opened
* with wlr_session_open_file before you call this. * with wlr_session_open_file before you call this.
*/ */
void wlr_session_finish(struct wlr_session *session); void wlr_session_destroy(struct wlr_session *session);
/* /*
* Opens the file at path. * Opens the file at path.
@ -57,9 +71,13 @@ int wlr_session_open_file(struct wlr_session *session, const char *path);
*/ */
void wlr_session_close_file(struct wlr_session *session, int fd); void wlr_session_close_file(struct wlr_session *session, int fd);
void wlr_session_signal_add(struct wlr_session *session, int fd,
struct wl_listener *listener);
/* /*
* Changes the virtual terminal. * Changes the virtual terminal.
*/ */
bool wlr_session_change_vt(struct wlr_session *session, unsigned vt); bool wlr_session_change_vt(struct wlr_session *session, unsigned vt);
int wlr_session_find_gpu(struct wlr_session *session);
#endif #endif

4
include/wlr/backend/session/interface.h
View File

@ -4,8 +4,8 @@
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
struct session_impl { struct session_impl {
struct wlr_session *(*start)(struct wl_display *disp); struct wlr_session *(*create)(struct wl_display *disp);
void (*finish)(struct wlr_session *session); void (*destroy)(struct wlr_session *session);
int (*open)(struct wlr_session *session, const char *path); int (*open)(struct wlr_session *session, const char *path);
void (*close)(struct wlr_session *session, int fd); void (*close)(struct wlr_session *session, int fd);
bool (*change_vt)(struct wlr_session *session, unsigned vt); bool (*change_vt)(struct wlr_session *session, unsigned vt);

9
include/wlr/backend/udev.h
View File

@ -1,9 +0,0 @@
#ifndef _WLR_BACKEND_UDEV_H
#define _WLR_BACKEND_UDEV_H
struct wlr_udev;
struct wlr_udev *wlr_udev_create(struct wl_display *display);
void wlr_udev_destroy(struct wlr_udev *udev);
#endif