***/
#include <errno.h>
+#include <fcntl.h>
+#include <linux/vt.h>
+#include <linux/kd.h>
+#include <signal.h>
#include <string.h>
+#include <sys/ioctl.h>
#include <unistd.h>
-#include <fcntl.h>
#include "sd-id128.h"
#include "sd-messages.h"
return NULL;
}
- s->id = path_get_file_name(s->state_file);
+ s->id = basename(s->state_file);
if (hashmap_put(m->sessions, s->id, s) < 0) {
hashmap_free(s->devices);
s->manager = m;
s->fifo_fd = -1;
+ s->vtfd = -1;
return s;
}
fprintf(f, "SERVICE=%s\n", s->service);
if (s->seat && seat_has_vts(s->seat))
- fprintf(f, "VTNR=%i\n", s->vtnr);
+ fprintf(f, "VTNR=%u\n", s->vtnr);
if (s->leader > 0)
fprintf(f, "LEADER=%lu\n", (unsigned long) s->leader);
s->remote = k;
}
+ if (vtnr)
+ safe_atou(vtnr, &s->vtnr);
+
if (seat && !s->seat) {
Seat *o;
o = hashmap_get(s->manager->seats, seat);
if (o)
- seat_attach_session(o, s);
+ r = seat_attach_session(o, s);
+ if (!o || r < 0)
+ log_error("Cannot attach session %s to seat %s", s->id, seat);
}
- if (vtnr && s->seat && seat_has_vts(s->seat)) {
- int v;
-
- k = safe_atoi(vtnr, &v);
- if (k >= 0 && v >= 1)
- s->vtnr = v;
- }
+ if (!s->seat || !seat_has_vts(s->seat))
+ s->vtnr = 0;
if (leader) {
k = parse_pid(leader, &s->leader);
if (controller) {
if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0)
session_set_controller(s, controller, false);
+ else
+ session_restore_vt(s);
}
return r;
/* on seats with VTs, we let VTs manage session-switching */
if (seat_has_vts(s->seat)) {
- if (s->vtnr <= 0)
+ if (!s->vtnr)
return -ENOTSUP;
return chvt(s->vtnr);
SessionState session_get_state(Session *s) {
assert(s);
- if (s->closing)
- return SESSION_CLOSING;
-
if (s->scope_job)
return SESSION_OPENING;
return manager_kill_unit(s->manager, s->scope, who, signo, NULL);
}
+static int session_open_vt(Session *s) {
+ char path[128];
+
+ if (!s->vtnr)
+ return -1;
+
+ if (s->vtfd >= 0)
+ return s->vtfd;
+
+ sprintf(path, "/dev/tty%u", s->vtnr);
+ s->vtfd = open(path, O_RDWR | O_CLOEXEC | O_NONBLOCK | O_NOCTTY);
+ if (s->vtfd < 0) {
+ log_error("cannot open VT %s of session %s: %m", path, s->id);
+ return -1;
+ }
+
+ return s->vtfd;
+}
+
+static int session_vt_fn(sd_event_source *source, const struct signalfd_siginfo *si, void *data) {
+ Session *s = data;
+
+ if (s->vtfd >= 0)
+ ioctl(s->vtfd, VT_RELDISP, 1);
+
+ return 0;
+}
+
+void session_mute_vt(Session *s) {
+ int vt, r;
+ struct vt_mode mode = { 0 };
+ sigset_t mask;
+
+ vt = session_open_vt(s);
+ if (vt < 0)
+ return;
+
+ r = ioctl(vt, KDSKBMODE, K_OFF);
+ if (r < 0)
+ goto error;
+
+ r = ioctl(vt, KDSETMODE, KD_GRAPHICS);
+ if (r < 0)
+ goto error;
+
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGUSR1);
+ sigprocmask(SIG_BLOCK, &mask, NULL);
+
+ r = sd_event_add_signal(s->manager->event, SIGUSR1, session_vt_fn, s, &s->vt_source);
+ if (r < 0)
+ goto error;
+
+ /* Oh, thanks to the VT layer, VT_AUTO does not work with KD_GRAPHICS.
+ * So we need a dummy handler here which just acknowledges *all* VT
+ * switch requests. */
+ mode.mode = VT_PROCESS;
+ mode.relsig = SIGUSR1;
+ mode.acqsig = SIGUSR1;
+ r = ioctl(vt, VT_SETMODE, &mode);
+ if (r < 0)
+ goto error;
+
+ return;
+
+error:
+ log_error("cannot mute VT %u for session %s (%d/%d)", s->vtnr, s->id, r, errno);
+ session_restore_vt(s);
+}
+
+void session_restore_vt(Session *s) {
+ _cleanup_free_ char *utf8;
+ int vt, kb = K_XLATE;
+ struct vt_mode mode = { 0 };
+
+ vt = session_open_vt(s);
+ if (vt < 0)
+ return;
+
+ sd_event_source_unref(s->vt_source);
+ s->vt_source = NULL;
+
+ ioctl(vt, KDSETMODE, KD_TEXT);
+
+ if (read_one_line_file("/sys/module/vt/parameters/default_utf8", &utf8) >= 0 && *utf8 == '1')
+ kb = K_UNICODE;
+ ioctl(vt, KDSKBMODE, kb);
+
+ mode.mode = VT_AUTO;
+ ioctl(vt, VT_SETMODE, &mode);
+
+ close_nointr_nofail(vt);
+ s->vtfd = -1;
+}
+
bool session_is_controller(Session *s, const char *sender) {
assert(s);
* dbus signals. */
while ((sd = hashmap_first(s->devices)))
session_device_free(sd);
+
+ if (!name)
+ session_restore_vt(s);
}
s->controller = name;
session_swap_controller(s, t);
+ /* When setting a session controller, we forcibly mute the VT and set
+ * it into graphics-mode. Applications can override that by changing
+ * VT state after calling TakeControl(). However, this serves as a good
+ * default and well-behaving controllers can now ignore VTs entirely.
+ * Note that we reset the VT on ReleaseControl() and if the controller
+ * exits.
+ * If logind crashes/restarts, we restore the controller during restart
+ * or reset the VT in case it crashed/exited, too. */
+ session_mute_vt(s);
+
return 0;
}