Line data Source code
1 : /* SPDX-License-Identifier: LGPL-2.1+ */
2 :
3 : #include <fcntl.h>
4 : #include <linux/input.h>
5 : #include <string.h>
6 : #include <sys/ioctl.h>
7 : #include <sys/types.h>
8 :
9 : #include "sd-device.h"
10 : #include "sd-daemon.h"
11 :
12 : #include "alloc-util.h"
13 : #include "bus-util.h"
14 : #include "fd-util.h"
15 : #include "logind-session-dbus.h"
16 : #include "logind-session-device.h"
17 : #include "missing.h"
18 : #include "parse-util.h"
19 : #include "util.h"
20 :
21 : enum SessionDeviceNotifications {
22 : SESSION_DEVICE_RESUME,
23 : SESSION_DEVICE_TRY_PAUSE,
24 : SESSION_DEVICE_PAUSE,
25 : SESSION_DEVICE_RELEASE,
26 : };
27 :
28 0 : static int session_device_notify(SessionDevice *sd, enum SessionDeviceNotifications type) {
29 0 : _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
30 0 : _cleanup_free_ char *path = NULL;
31 0 : const char *t = NULL;
32 : uint32_t major, minor;
33 : int r;
34 :
35 0 : assert(sd);
36 :
37 0 : major = major(sd->dev);
38 0 : minor = minor(sd->dev);
39 :
40 0 : if (!sd->session->controller)
41 0 : return 0;
42 :
43 0 : path = session_bus_path(sd->session);
44 0 : if (!path)
45 0 : return -ENOMEM;
46 :
47 0 : r = sd_bus_message_new_signal(
48 0 : sd->session->manager->bus,
49 : &m, path,
50 : "org.freedesktop.login1.Session",
51 : (type == SESSION_DEVICE_RESUME) ? "ResumeDevice" : "PauseDevice");
52 0 : if (!m)
53 0 : return r;
54 :
55 0 : r = sd_bus_message_set_destination(m, sd->session->controller);
56 0 : if (r < 0)
57 0 : return r;
58 :
59 0 : switch (type) {
60 :
61 0 : case SESSION_DEVICE_RESUME:
62 0 : r = sd_bus_message_append(m, "uuh", major, minor, sd->fd);
63 0 : if (r < 0)
64 0 : return r;
65 0 : break;
66 :
67 0 : case SESSION_DEVICE_TRY_PAUSE:
68 0 : t = "pause";
69 0 : break;
70 :
71 0 : case SESSION_DEVICE_PAUSE:
72 0 : t = "force";
73 0 : break;
74 :
75 0 : case SESSION_DEVICE_RELEASE:
76 0 : t = "gone";
77 0 : break;
78 :
79 0 : default:
80 0 : return -EINVAL;
81 : }
82 :
83 0 : if (t) {
84 0 : r = sd_bus_message_append(m, "uus", major, minor, t);
85 0 : if (r < 0)
86 0 : return r;
87 : }
88 :
89 0 : return sd_bus_send(sd->session->manager->bus, m, NULL);
90 : }
91 :
92 0 : static void sd_eviocrevoke(int fd) {
93 : static bool warned = false;
94 :
95 0 : assert(fd >= 0);
96 :
97 0 : if (ioctl(fd, EVIOCREVOKE, NULL) < 0) {
98 :
99 0 : if (errno == EINVAL && !warned) {
100 0 : log_warning_errno(errno, "Kernel does not support evdev-revocation: %m");
101 0 : warned = true;
102 : }
103 : }
104 0 : }
105 :
106 0 : static int sd_drmsetmaster(int fd) {
107 0 : assert(fd >= 0);
108 :
109 0 : if (ioctl(fd, DRM_IOCTL_SET_MASTER, 0) < 0)
110 0 : return -errno;
111 :
112 0 : return 0;
113 : }
114 :
115 0 : static int sd_drmdropmaster(int fd) {
116 0 : assert(fd >= 0);
117 :
118 0 : if (ioctl(fd, DRM_IOCTL_DROP_MASTER, 0) < 0)
119 0 : return -errno;
120 :
121 0 : return 0;
122 : }
123 :
124 0 : static int session_device_open(SessionDevice *sd, bool active) {
125 : int fd, r;
126 :
127 0 : assert(sd);
128 0 : assert(sd->type != DEVICE_TYPE_UNKNOWN);
129 0 : assert(sd->node);
130 :
131 : /* open device and try to get an udev_device from it */
132 0 : fd = open(sd->node, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK);
133 0 : if (fd < 0)
134 0 : return -errno;
135 :
136 0 : switch (sd->type) {
137 :
138 0 : case DEVICE_TYPE_DRM:
139 0 : if (active) {
140 : /* Weird legacy DRM semantics might return an error even though we're master. No way to detect
141 : * that so fail at all times and let caller retry in inactive state. */
142 0 : r = sd_drmsetmaster(fd);
143 0 : if (r < 0) {
144 0 : close_nointr(fd);
145 0 : return r;
146 : }
147 : } else
148 : /* DRM-Master is granted to the first user who opens a device automatically (ughh,
149 : * racy!). Hence, we just drop DRM-Master in case we were the first. */
150 0 : (void) sd_drmdropmaster(fd);
151 0 : break;
152 :
153 0 : case DEVICE_TYPE_EVDEV:
154 0 : if (!active)
155 0 : sd_eviocrevoke(fd);
156 0 : break;
157 :
158 0 : case DEVICE_TYPE_UNKNOWN:
159 : default:
160 : /* fallback for devices without synchronizations */
161 0 : break;
162 : }
163 :
164 0 : return fd;
165 : }
166 :
167 0 : static int session_device_start(SessionDevice *sd) {
168 : int r;
169 :
170 0 : assert(sd);
171 0 : assert(session_is_active(sd->session));
172 :
173 0 : if (sd->active)
174 0 : return 0;
175 :
176 0 : switch (sd->type) {
177 :
178 0 : case DEVICE_TYPE_DRM:
179 0 : if (sd->fd < 0)
180 0 : return log_error_errno(SYNTHETIC_ERRNO(EBADF),
181 : "Failed to re-activate DRM fd, as the fd was lost (maybe logind restart went wrong?)");
182 :
183 : /* Device is kept open. Simply call drmSetMaster() and hope there is no-one else. In case it fails, we
184 : * keep the device paused. Maybe at some point we have a drmStealMaster(). */
185 0 : r = sd_drmsetmaster(sd->fd);
186 0 : if (r < 0)
187 0 : return r;
188 0 : break;
189 :
190 0 : case DEVICE_TYPE_EVDEV:
191 : /* Evdev devices are revoked while inactive. Reopen it and we are fine. */
192 0 : r = session_device_open(sd, true);
193 0 : if (r < 0)
194 0 : return r;
195 :
196 : /* For evdev devices, the file descriptor might be left uninitialized. This might happen while resuming
197 : * into a session and logind has been restarted right before. */
198 0 : safe_close(sd->fd);
199 0 : sd->fd = r;
200 0 : break;
201 :
202 0 : case DEVICE_TYPE_UNKNOWN:
203 : default:
204 : /* fallback for devices without synchronizations */
205 0 : break;
206 : }
207 :
208 0 : sd->active = true;
209 0 : return 0;
210 : }
211 :
212 0 : static void session_device_stop(SessionDevice *sd) {
213 0 : assert(sd);
214 :
215 0 : if (!sd->active)
216 0 : return;
217 :
218 0 : switch (sd->type) {
219 :
220 0 : case DEVICE_TYPE_DRM:
221 0 : if (sd->fd < 0) {
222 0 : log_error("Failed to de-activate DRM fd, as the fd was lost (maybe logind restart went wrong?)");
223 0 : return;
224 : }
225 :
226 : /* On DRM devices we simply drop DRM-Master but keep it open.
227 : * This allows the user to keep resources allocated. The
228 : * CAP_SYS_ADMIN restriction to DRM-Master prevents users from
229 : * circumventing this. */
230 0 : sd_drmdropmaster(sd->fd);
231 0 : break;
232 :
233 0 : case DEVICE_TYPE_EVDEV:
234 : /* Revoke access on evdev file-descriptors during deactivation.
235 : * This will basically prevent any operations on the fd and
236 : * cannot be undone. Good side is: it needs no CAP_SYS_ADMIN
237 : * protection this way. */
238 0 : sd_eviocrevoke(sd->fd);
239 0 : break;
240 :
241 0 : case DEVICE_TYPE_UNKNOWN:
242 : default:
243 : /* fallback for devices without synchronization */
244 0 : break;
245 : }
246 :
247 0 : sd->active = false;
248 : }
249 :
250 0 : static DeviceType detect_device_type(sd_device *dev) {
251 : const char *sysname, *subsystem;
252 0 : DeviceType type = DEVICE_TYPE_UNKNOWN;
253 :
254 0 : if (sd_device_get_sysname(dev, &sysname) < 0 ||
255 0 : sd_device_get_subsystem(dev, &subsystem) < 0)
256 0 : return type;
257 :
258 0 : if (streq(subsystem, "drm")) {
259 0 : if (startswith(sysname, "card"))
260 0 : type = DEVICE_TYPE_DRM;
261 0 : } else if (streq(subsystem, "input")) {
262 0 : if (startswith(sysname, "event"))
263 0 : type = DEVICE_TYPE_EVDEV;
264 : }
265 :
266 0 : return type;
267 : }
268 :
269 0 : static int session_device_verify(SessionDevice *sd) {
270 0 : _cleanup_(sd_device_unrefp) sd_device *p = NULL;
271 : const char *sp, *node;
272 : sd_device *dev;
273 : int r;
274 :
275 0 : r = sd_device_new_from_devnum(&p, 'c', sd->dev);
276 0 : if (r < 0)
277 0 : return r;
278 :
279 0 : dev = p;
280 :
281 0 : if (sd_device_get_syspath(dev, &sp) < 0 ||
282 0 : sd_device_get_devname(dev, &node) < 0)
283 0 : return -EINVAL;
284 :
285 : /* detect device type so we can find the correct sysfs parent */
286 0 : sd->type = detect_device_type(dev);
287 0 : if (sd->type == DEVICE_TYPE_UNKNOWN)
288 0 : return -ENODEV;
289 :
290 0 : else if (sd->type == DEVICE_TYPE_EVDEV) {
291 : /* for evdev devices we need the parent node as device */
292 0 : if (sd_device_get_parent_with_subsystem_devtype(p, "input", NULL, &dev) < 0)
293 0 : return -ENODEV;
294 0 : if (sd_device_get_syspath(dev, &sp) < 0)
295 0 : return -ENODEV;
296 :
297 0 : } else if (sd->type != DEVICE_TYPE_DRM)
298 : /* Prevent opening unsupported devices. Especially devices of
299 : * subsystem "input" must be opened via the evdev node as
300 : * we require EVIOCREVOKE. */
301 0 : return -ENODEV;
302 :
303 : /* search for an existing seat device and return it if available */
304 0 : sd->device = hashmap_get(sd->session->manager->devices, sp);
305 0 : if (!sd->device) {
306 : /* The caller might have gotten the udev event before we were
307 : * able to process it. Hence, fake the "add" event and let the
308 : * logind-manager handle the new device. */
309 0 : r = manager_process_seat_device(sd->session->manager, dev);
310 0 : if (r < 0)
311 0 : return r;
312 :
313 : /* if it's still not available, then the device is invalid */
314 0 : sd->device = hashmap_get(sd->session->manager->devices, sp);
315 0 : if (!sd->device)
316 0 : return -ENODEV;
317 : }
318 :
319 0 : if (sd->device->seat != sd->session->seat)
320 0 : return -EPERM;
321 :
322 0 : sd->node = strdup(node);
323 0 : if (!sd->node)
324 0 : return -ENOMEM;
325 :
326 0 : return 0;
327 : }
328 :
329 0 : int session_device_new(Session *s, dev_t dev, bool open_device, SessionDevice **out) {
330 : SessionDevice *sd;
331 : int r;
332 :
333 0 : assert(s);
334 0 : assert(out);
335 :
336 0 : if (!s->seat)
337 0 : return -EPERM;
338 :
339 0 : sd = new0(SessionDevice, 1);
340 0 : if (!sd)
341 0 : return -ENOMEM;
342 :
343 0 : sd->session = s;
344 0 : sd->dev = dev;
345 0 : sd->fd = -1;
346 0 : sd->type = DEVICE_TYPE_UNKNOWN;
347 :
348 0 : r = session_device_verify(sd);
349 0 : if (r < 0)
350 0 : goto error;
351 :
352 0 : r = hashmap_put(s->devices, &sd->dev, sd);
353 0 : if (r < 0)
354 0 : goto error;
355 :
356 0 : if (open_device) {
357 : /* Open the device for the first time. We need a valid fd to pass back
358 : * to the caller. If the session is not active, this _might_ immediately
359 : * revoke access and thus invalidate the fd. But this is still needed
360 : * to pass a valid fd back. */
361 0 : sd->active = session_is_active(s);
362 0 : r = session_device_open(sd, sd->active);
363 0 : if (r < 0) {
364 : /* EINVAL _may_ mean a master is active; retry inactive */
365 0 : if (sd->active && r == -EINVAL) {
366 0 : sd->active = false;
367 0 : r = session_device_open(sd, false);
368 : }
369 0 : if (r < 0)
370 0 : goto error;
371 : }
372 0 : sd->fd = r;
373 : }
374 :
375 0 : LIST_PREPEND(sd_by_device, sd->device->session_devices, sd);
376 :
377 0 : *out = sd;
378 0 : return 0;
379 :
380 0 : error:
381 0 : hashmap_remove(s->devices, &sd->dev);
382 0 : free(sd->node);
383 0 : free(sd);
384 0 : return r;
385 : }
386 :
387 0 : void session_device_free(SessionDevice *sd) {
388 0 : assert(sd);
389 :
390 : /* Make sure to remove the pushed fd. */
391 0 : if (sd->pushed_fd)
392 0 : (void) sd_notifyf(false,
393 : "FDSTOREREMOVE=1\n"
394 : "FDNAME=session-%s-device-%u-%u",
395 0 : sd->session->id, major(sd->dev), minor(sd->dev));
396 :
397 0 : session_device_stop(sd);
398 0 : session_device_notify(sd, SESSION_DEVICE_RELEASE);
399 0 : safe_close(sd->fd);
400 :
401 0 : LIST_REMOVE(sd_by_device, sd->device->session_devices, sd);
402 :
403 0 : hashmap_remove(sd->session->devices, &sd->dev);
404 :
405 0 : free(sd->node);
406 0 : free(sd);
407 0 : }
408 :
409 0 : void session_device_complete_pause(SessionDevice *sd) {
410 : SessionDevice *iter;
411 : Iterator i;
412 :
413 0 : if (!sd->active)
414 0 : return;
415 :
416 0 : session_device_stop(sd);
417 :
418 : /* if not all devices are paused, wait for further completion events */
419 0 : HASHMAP_FOREACH(iter, sd->session->devices, i)
420 0 : if (iter->active)
421 0 : return;
422 :
423 : /* complete any pending session switch */
424 0 : seat_complete_switch(sd->session->seat);
425 : }
426 :
427 0 : void session_device_resume_all(Session *s) {
428 : SessionDevice *sd;
429 : Iterator i;
430 :
431 0 : assert(s);
432 :
433 0 : HASHMAP_FOREACH(sd, s->devices, i) {
434 0 : if (sd->active)
435 0 : continue;
436 :
437 0 : if (session_device_start(sd) < 0)
438 0 : continue;
439 0 : if (session_device_save(sd) < 0)
440 0 : continue;
441 :
442 0 : session_device_notify(sd, SESSION_DEVICE_RESUME);
443 : }
444 0 : }
445 :
446 0 : void session_device_pause_all(Session *s) {
447 : SessionDevice *sd;
448 : Iterator i;
449 :
450 0 : assert(s);
451 :
452 0 : HASHMAP_FOREACH(sd, s->devices, i) {
453 0 : if (!sd->active)
454 0 : continue;
455 :
456 0 : session_device_stop(sd);
457 0 : session_device_notify(sd, SESSION_DEVICE_PAUSE);
458 : }
459 0 : }
460 :
461 0 : unsigned session_device_try_pause_all(Session *s) {
462 0 : unsigned num_pending = 0;
463 : SessionDevice *sd;
464 : Iterator i;
465 :
466 0 : assert(s);
467 :
468 0 : HASHMAP_FOREACH(sd, s->devices, i) {
469 0 : if (!sd->active)
470 0 : continue;
471 :
472 0 : session_device_notify(sd, SESSION_DEVICE_TRY_PAUSE);
473 0 : num_pending++;
474 : }
475 :
476 0 : return num_pending;
477 : }
478 :
479 0 : int session_device_save(SessionDevice *sd) {
480 0 : _cleanup_free_ char *m = NULL;
481 : const char *id;
482 : int r;
483 :
484 0 : assert(sd);
485 :
486 : /* Store device fd in PID1. It will send it back to us on restart so revocation will continue to work. To make
487 : * things simple, send fds for all type of devices even if they don't support the revocation mechanism so we
488 : * don't have to handle them differently later.
489 : *
490 : * Note: for device supporting revocation, PID1 will drop a stored fd automatically if the corresponding device
491 : * is revoked. */
492 :
493 0 : if (sd->pushed_fd)
494 0 : return 0;
495 :
496 : /* Session ID does not contain separators. */
497 0 : id = sd->session->id;
498 0 : assert(*(id + strcspn(id, "-\n")) == '\0');
499 :
500 0 : r = asprintf(&m, "FDSTORE=1\n"
501 : "FDNAME=session-%s-device-%u-%u\n",
502 : id, major(sd->dev), minor(sd->dev));
503 0 : if (r < 0)
504 0 : return r;
505 :
506 0 : r = sd_pid_notify_with_fds(0, false, m, &sd->fd, 1);
507 0 : if (r < 0)
508 0 : return r;
509 :
510 0 : sd->pushed_fd = true;
511 0 : return 1;
512 : }
513 :
514 0 : void session_device_attach_fd(SessionDevice *sd, int fd, bool active) {
515 0 : assert(fd >= 0);
516 0 : assert(sd);
517 0 : assert(sd->fd < 0);
518 0 : assert(!sd->active);
519 :
520 0 : sd->fd = fd;
521 0 : sd->pushed_fd = true;
522 0 : sd->active = active;
523 0 : }
|
