X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Flogin%2Flogind-session.c;h=a02a537f7ca00666a2316ec357408d84d2323c32;hb=5e07a79e84ab8b045b9df1a2719f14fc84471a1d;hp=9d05faf47ceab9aa60cb99b84aaa967d867e6333;hpb=e9e74f28d783a052dce7edfa94d7918bb591ba7a;p=elogind.git diff --git a/src/login/logind-session.c b/src/login/logind-session.c index 9d05faf47..a02a537f7 100644 --- a/src/login/logind-session.c +++ b/src/login/logind-session.c @@ -44,21 +44,6 @@ static void session_remove_fifo(Session *s); -static unsigned long devt_hash_func(const void *p, const uint8_t hash_key[HASH_KEY_SIZE]) { - uint64_t u = *(const dev_t*)p; - - return uint64_hash_func(&u, hash_key); -} - -static int devt_compare_func(const void *_a, const void *_b) { - dev_t a, b; - - a = *(const dev_t*) _a; - b = *(const dev_t*) _b; - - return a < b ? -1 : (a > b ? 1 : 0); -} - Session* session_new(Manager *m, const char *id) { Session *s; @@ -76,7 +61,7 @@ Session* session_new(Manager *m, const char *id) { return NULL; } - s->devices = hashmap_new(devt_hash_func, devt_compare_func); + s->devices = hashmap_new(&devt_hash_ops); if (!s->devices) { free(s->state_file); free(s); @@ -307,7 +292,7 @@ int session_save(Session *s) { finish: if (r < 0) - log_error("Failed to save session data %s: %s", s->state_file, strerror(-r)); + log_error_errno(r, "Failed to save session data %s: %m", s->state_file); return r; } @@ -316,6 +301,7 @@ int session_load(Session *s) { _cleanup_free_ char *remote = NULL, *seat = NULL, *vtnr = NULL, + *state = NULL, *pos = NULL, *leader = NULL, *type = NULL, @@ -342,6 +328,7 @@ int session_load(Session *s) { "SERVICE", &s->service, "DESKTOP", &s->desktop, "VTNR", &vtnr, + "STATE", &state, "POS", &pos, "LEADER", &leader, "TYPE", &type, @@ -352,10 +339,8 @@ int session_load(Session *s) { "CONTROLLER", &controller, NULL); - if (r < 0) { - log_error("Failed to read %s: %s", s->state_file, strerror(-r)); - return r; - } + if (r < 0) + return log_error_errno(r, "Failed to read %s: %m", s->state_file); if (!s->user) { uid_t u; @@ -372,7 +357,7 @@ int session_load(Session *s) { return r; } - user = hashmap_get(s->manager->users, ULONG_TO_PTR((unsigned long) u)); + user = hashmap_get(s->manager->users, UID_TO_PTR(u)); if (!user) { log_error("User of session %s not known.", s->id); return -ENOENT; @@ -432,13 +417,18 @@ int session_load(Session *s) { s->class = c; } + if (state && streq(state, "closing")) + s->stopping = true; + if (s->fifo_path) { int fd; /* If we open an unopened pipe for reading we will not get an EOF. to trigger an EOF we hence open it for - reading, but close it right-away which then will - trigger the EOF. */ + writing, but close it right away which then will + trigger the EOF. This will happen immediately if no + other process has the FIFO open for writing, i. e. + when the session died before logind (re)started. */ fd = session_create_fifo(s); safe_close(fd); @@ -564,11 +554,11 @@ int session_start(Session *s) { return r; log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO, - MESSAGE_ID(SD_MESSAGE_SESSION_START), + LOG_MESSAGE_ID(SD_MESSAGE_SESSION_START), "SESSION_ID=%s", s->id, "USER_ID=%s", s->user->name, "LEADER="PID_FMT, s->leader, - "MESSAGE=New session %s of user %s.", s->id, s->user->name, + LOG_MESSAGE("New session %s of user %s.", s->id, s->user->name), NULL); if (!dual_timestamp_is_set(&s->timestamp)) @@ -667,11 +657,11 @@ int session_finalize(Session *s) { if (s->started) log_struct(s->class == SESSION_BACKGROUND ? LOG_DEBUG : LOG_INFO, - MESSAGE_ID(SD_MESSAGE_SESSION_STOP), + LOG_MESSAGE_ID(SD_MESSAGE_SESSION_STOP), "SESSION_ID=%s", s->id, "USER_ID=%s", s->user->name, "LEADER="PID_FMT, s->leader, - "MESSAGE=Removed session %s.", s->id, + LOG_MESSAGE("Removed session %s.", s->id), NULL); s->timer_event_source = sd_event_source_unref(s->timer_event_source); @@ -984,10 +974,8 @@ static int session_open_vt(Session *s) { 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 -errno; - } + if (s->vtfd < 0) + return log_error_errno(errno, "cannot open VT %s of session %s: %m", path, s->id); return s->vtfd; } @@ -1006,21 +994,21 @@ int session_prepare_vt(Session *s) { r = fchown(vt, s->user->uid, -1); if (r < 0) { r = -errno; - log_error("Cannot change owner of /dev/tty%u: %m", s->vtnr); + log_error_errno(errno, "Cannot change owner of /dev/tty%u: %m", s->vtnr); goto error; } r = ioctl(vt, KDSKBMODE, K_OFF); if (r < 0) { r = -errno; - log_error("Cannot set K_OFF on /dev/tty%u: %m", s->vtnr); + log_error_errno(errno, "Cannot set K_OFF on /dev/tty%u: %m", s->vtnr); goto error; } r = ioctl(vt, KDSETMODE, KD_GRAPHICS); if (r < 0) { r = -errno; - log_error("Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr); + log_error_errno(errno, "Cannot set KD_GRAPHICS on /dev/tty%u: %m", s->vtnr); goto error; } @@ -1033,7 +1021,7 @@ int session_prepare_vt(Session *s) { r = ioctl(vt, VT_SETMODE, &mode); if (r < 0) { r = -errno; - log_error("Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr); + log_error_errno(errno, "Cannot set VT_PROCESS on /dev/tty%u: %m", s->vtnr); goto error; } @@ -1068,36 +1056,61 @@ void session_restore_vt(Session *s) { s->vtfd = safe_close(s->vtfd); } +void session_leave_vt(Session *s) { + int r; + + assert(s); + + /* This is called whenever we get a VT-switch signal from the kernel. + * We acknowledge all of them unconditionally. Note that session are + * free to overwrite those handlers and we only register them for + * sessions with controllers. Legacy sessions are not affected. + * However, if we switch from a non-legacy to a legacy session, we must + * make sure to pause all device before acknowledging the switch. We + * process the real switch only after we are notified via sysfs, so the + * legacy session might have already started using the devices. If we + * don't pause the devices before the switch, we might confuse the + * session we switch to. */ + + if (s->vtfd < 0) + return; + + session_device_pause_all(s); + r = ioctl(s->vtfd, VT_RELDISP, 1); + if (r < 0) + log_debug_errno(errno, "Cannot release VT of session %s: %m", s->id); +} + bool session_is_controller(Session *s, const char *sender) { assert(s); return streq_ptr(s->controller, sender); } -static void session_swap_controller(Session *s, char *name) { +static void session_release_controller(Session *s, bool notify) { + _cleanup_free_ char *name = NULL; SessionDevice *sd; - if (s->controller) { - manager_drop_busname(s->manager, s->controller); - free(s->controller); - s->controller = NULL; + if (!s->controller) + return; - /* Drop all devices as they're now unused. Do that after the - * controller is released to avoid sending out useles - * dbus signals. */ - while ((sd = hashmap_first(s->devices))) - session_device_free(sd); + name = s->controller; - if (!name) - session_restore_vt(s); - } + /* By resetting the controller before releasing the devices, we won't + * send notification signals. This avoids sending useless notifications + * if the controller is released on disconnects. */ + if (!notify) + s->controller = NULL; - s->controller = name; - session_save(s); + while ((sd = hashmap_first(s->devices))) + session_device_free(sd); + + s->controller = NULL; + manager_drop_busname(s->manager, name); } int session_set_controller(Session *s, const char *sender, bool force) { - char *t; + _cleanup_free_ char *name = NULL; int r; assert(s); @@ -1108,15 +1121,13 @@ int session_set_controller(Session *s, const char *sender, bool force) { if (s->controller && !force) return -EBUSY; - t = strdup(sender); - if (!t) + name = strdup(sender); + if (!name) return -ENOMEM; - r = manager_watch_busname(s->manager, sender); - if (r) { - free(t); + r = manager_watch_busname(s->manager, name); + if (r) return r; - } /* When setting a session controller, we forcibly mute the VT and set * it into graphics-mode. Applications can override that by changing @@ -1127,10 +1138,15 @@ int session_set_controller(Session *s, const char *sender, bool force) { * If logind crashes/restarts, we restore the controller during restart * or reset the VT in case it crashed/exited, too. */ r = session_prepare_vt(s); - if (r < 0) + if (r < 0) { + manager_drop_busname(s->manager, name); return r; + } - session_swap_controller(s, t); + session_release_controller(s, true); + s->controller = name; + name = NULL; + session_save(s); return 0; } @@ -1141,7 +1157,9 @@ void session_drop_controller(Session *s) { if (!s->controller) return; - session_swap_controller(s, NULL); + session_release_controller(s, false); + session_save(s); + session_restore_vt(s); } static const char* const session_state_table[_SESSION_STATE_MAX] = {