X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flogin%2Flogind-session.c;h=0e1c40b4eb8ab87418dfcfbe4a282f15431d84a9;hp=fcc1901ed626c9f2c21d6762fb42273bbac59ace;hb=6d33772f9ae6769c557e2267d16b7d31f67db914;hpb=118ecf32425a590ea266b5c2b6de7962bb242356 diff --git a/src/login/logind-session.c b/src/login/logind-session.c index fcc1901ed..0e1c40b4e 100644 --- a/src/login/logind-session.c +++ b/src/login/logind-session.c @@ -22,20 +22,35 @@ #include #include #include -#include #include -#include -#include - +#include "sd-id128.h" +#include "sd-messages.h" #include "strv.h" #include "util.h" #include "mkdir.h" #include "path-util.h" #include "fileio.h" -#include "dbus-common.h" +#include "audit.h" +#include "bus-util.h" +#include "bus-error.h" #include "logind-session.h" +static unsigned devt_hash_func(const void *p) { + uint64_t u = *(const dev_t*)p; + + return uint64_hash_func(&u); +} + +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; @@ -53,7 +68,7 @@ Session* session_new(Manager *m, const char *id) { return NULL; } - s->devices = hashmap_new(trivial_hash_func, trivial_compare_func); + s->devices = hashmap_new(devt_hash_func, devt_compare_func); if (!s->devices) { free(s->state_file); free(s); @@ -81,7 +96,9 @@ void session_free(Session *s) { assert(s); if (s->in_gc_queue) - LIST_REMOVE(Session, gc_queue, s->manager->session_gc_queue, s); + LIST_REMOVE(gc_queue, s->manager->session_gc_queue, s); + + session_remove_fifo(s); session_drop_controller(s); @@ -91,7 +108,7 @@ void session_free(Session *s) { hashmap_free(s->devices); if (s->user) { - LIST_REMOVE(Session, sessions_by_user, s->user->sessions, s); + LIST_REMOVE(sessions_by_user, s->user->sessions, s); if (s->user->display == s) s->user->display = NULL; @@ -100,8 +117,10 @@ void session_free(Session *s) { if (s->seat) { if (s->seat->active == s) s->seat->active = NULL; + if (s->seat->pending_switch == s) + s->seat->pending_switch = NULL; - LIST_REMOVE(Session, sessions_by_seat, s->seat->sessions, s); + LIST_REMOVE(sessions_by_seat, s->seat->sessions, s); } if (s->scope) { @@ -111,8 +130,7 @@ void session_free(Session *s) { free(s->scope_job); - if (s->create_message) - dbus_message_unref(s->create_message); + sd_bus_message_unref(s->create_message); free(s->tty); free(s->display); @@ -121,7 +139,6 @@ void session_free(Session *s) { free(s->service); hashmap_remove(s->manager->sessions, s->id); - session_remove_fifo(s); free(s->state_file); free(s); @@ -132,12 +149,12 @@ void session_set_user(Session *s, User *u) { assert(!s->user); s->user = u; - LIST_PREPEND(Session, sessions_by_user, u->sessions, s); + LIST_PREPEND(sessions_by_user, u->sessions, s); } int session_save(Session *s) { - _cleanup_fclose_ FILE *f = NULL; _cleanup_free_ char *temp_path = NULL; + _cleanup_fclose_ FILE *f = NULL; int r = 0; assert(s); @@ -222,6 +239,9 @@ int session_save(Session *s) { (unsigned long long) s->timestamp.realtime, (unsigned long long) s->timestamp.monotonic); + if (s->controller) + fprintf(f, "CONTROLLER=%s\n", s->controller); + fflush(f); if (ferror(f) || rename(temp_path, s->state_file) < 0) { @@ -242,12 +262,12 @@ int session_load(Session *s) { *seat = NULL, *vtnr = NULL, *leader = NULL, - *audit_id = NULL, *type = NULL, *class = NULL, *uid = NULL, *realtime = NULL, - *monotonic = NULL; + *monotonic = NULL, + *controller = NULL; int k, r; @@ -271,6 +291,7 @@ int session_load(Session *s) { "UID", &uid, "REALTIME", &realtime, "MONOTONIC", &monotonic, + "CONTROLLER", &controller, NULL); if (r < 0) { @@ -371,25 +392,49 @@ int session_load(Session *s) { s->timestamp.monotonic = l; } + if (controller) { + if (bus_name_has_owner(s->manager->bus, controller, NULL) > 0) + session_set_controller(s, controller, false); + } + return r; } int session_activate(Session *s) { + unsigned int num_pending; + assert(s); assert(s->user); - if (s->vtnr <= 0) - return -ENOTSUP; - if (!s->seat) return -ENOTSUP; if (s->seat->active == s) return 0; - assert(seat_has_vts(s->seat)); + /* on seats with VTs, we let VTs manage session-switching */ + if (seat_has_vts(s->seat)) { + if (s->vtnr <= 0) + return -ENOTSUP; + + return chvt(s->vtnr); + } + + /* On seats without VTs, we implement session-switching in logind. We + * try to pause all session-devices and wait until the session + * controller acknowledged them. Once all devices are asleep, we simply + * switch the active session and be done. + * We save the session we want to switch to in seat->pending_switch and + * seat_complete_switch() will perform the final switch. */ + + s->seat->pending_switch = s; - return chvt(s->vtnr); + /* if no devices are running, immediately perform the session switch */ + num_pending = session_device_try_pause_all(s); + if (!num_pending) + seat_complete_switch(s->seat); + + return 0; } static int session_link_x11_socket(Session *s) { @@ -459,16 +504,14 @@ done: } static int session_start_scope(Session *s) { - DBusError error; int r; assert(s); assert(s->user); assert(s->user->slice); - dbus_error_init(&error); - if (!s->scope) { + _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; _cleanup_free_ char *description = NULL; const char *kill_mode; char *scope, *job; @@ -486,9 +529,7 @@ static int session_start_scope(Session *s) { r = manager_start_scope(s->manager, scope, s->leader, s->user->slice, description, "systemd-user-sessions.service", kill_mode, &error, &job); if (r < 0) { log_error("Failed to start session scope %s: %s %s", - scope, bus_error(&error, r), error.name); - dbus_error_free(&error); - + scope, bus_error_message(&error, r), error.name); free(scope); return r; } else { @@ -554,32 +595,29 @@ int session_start(Session *s) { seat_save(s->seat); if (s->seat->active == s) - seat_send_changed(s->seat, "Sessions\0ActiveSession\0"); + seat_send_changed(s->seat, "Sessions", "ActiveSession", NULL); else - seat_send_changed(s->seat, "Sessions\0"); + seat_send_changed(s->seat, "Sessions", NULL); } - user_send_changed(s->user, "Sessions\0"); + user_send_changed(s->user, "Sessions", NULL); return 0; } static int session_stop_scope(Session *s) { - DBusError error; + _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL; char *job; int r; assert(s); - dbus_error_init(&error); - if (!s->scope) return 0; r = manager_stop_unit(s->manager, s->scope, &error, &job); if (r < 0) { - log_error("Failed to stop session scope: %s", bus_error(&error, r)); - dbus_error_free(&error); + log_error("Failed to stop session scope: %s", bus_error_message(&error, r)); return r; } @@ -621,6 +659,7 @@ int session_stop(Session *s) { r = session_stop_scope(s); session_save(s); + user_save(s->user); return r; } @@ -663,11 +702,11 @@ int session_finalize(Session *s) { if (s->seat->active == s) seat_set_active(s->seat, NULL); - seat_send_changed(s->seat, "Sessions\0"); + seat_send_changed(s->seat, "Sessions", NULL); seat_save(s->seat); } - user_send_changed(s->user, "Sessions\0"); + user_send_changed(s->user, "Sessions", NULL); user_save(s->user); return r; @@ -781,26 +820,27 @@ void session_set_idle_hint(Session *s, bool b) { s->idle_hint = b; dual_timestamp_get(&s->idle_hint_timestamp); - session_send_changed(s, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); + session_send_changed(s, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); if (s->seat) - seat_send_changed(s->seat, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); - - user_send_changed(s->user, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); - - manager_send_changed(s->manager, - "IdleHint\0" - "IdleSinceHint\0" - "IdleSinceHintMonotonic\0"); + seat_send_changed(s->seat, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); + + user_send_changed(s->user, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); + manager_send_changed(s->manager, "IdleHint", "IdleSinceHint", "IdleSinceHintMonotonic", NULL); +} + +static int session_dispatch_fifo(sd_event_source *es, int fd, uint32_t revents, void *userdata) { + Session *s = userdata; + + assert(s); + assert(s->fifo_fd == fd); + + /* EOF on the FIFO means the session died abnormally. */ + + session_remove_fifo(s); + session_stop(s); + + return 1; } int session_create_fifo(Session *s) { @@ -823,21 +863,20 @@ int session_create_fifo(Session *s) { /* Open reading side */ if (s->fifo_fd < 0) { - struct epoll_event ev = {}; - s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY); if (s->fifo_fd < 0) return -errno; - r = hashmap_put(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1), s); + } + + if (!s->fifo_event_source) { + r = sd_event_add_io(s->manager->event, s->fifo_fd, 0, session_dispatch_fifo, s, &s->fifo_event_source); if (r < 0) return r; - ev.events = 0; - ev.data.u32 = FD_OTHER_BASE + s->fifo_fd; - - if (epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->fifo_fd, &ev) < 0) - return -errno; + r = sd_event_source_set_priority(s->fifo_event_source, SD_EVENT_PRIORITY_IDLE); + if (r < 0) + return r; } /* Open writing side */ @@ -851,14 +890,12 @@ int session_create_fifo(Session *s) { void session_remove_fifo(Session *s) { assert(s); + if (s->fifo_event_source) + s->fifo_event_source = sd_event_source_unref(s->fifo_event_source); + if (s->fifo_fd >= 0) { - assert_se(hashmap_remove(s->manager->session_fds, INT_TO_PTR(s->fifo_fd + 1)) == s); - assert_se(epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->fifo_fd, NULL) == 0); close_nointr_nofail(s->fifo_fd); s->fifo_fd = -1; - - session_save(s); - user_save(s->user); } if (s->fifo_path) { @@ -868,33 +905,33 @@ void session_remove_fifo(Session *s) { } } -int session_check_gc(Session *s, bool drop_not_started) { +bool session_check_gc(Session *s, bool drop_not_started) { int r; assert(s); if (drop_not_started && !s->started) - return 0; + return false; if (!s->user) - return 0; + return false; if (s->fifo_fd >= 0) { r = pipe_eof(s->fifo_fd); if (r < 0) - return r; + return true; if (r == 0) - return 1; + return true; } - if (s->scope_job) - return 1; + if (s->scope_job && manager_job_is_active(s->manager, s->scope_job)) + return true; - if (s->scope) - return manager_unit_is_active(s->manager, s->scope) != 0; + if (s->scope && manager_unit_is_active(s->manager, s->scope)) + return true; - return 0; + return false; } void session_add_to_gc_queue(Session *s) { @@ -903,7 +940,7 @@ void session_add_to_gc_queue(Session *s) { if (s->in_gc_queue) return; - LIST_PREPEND(Session, gc_queue, s->manager->session_gc_queue, s); + LIST_PREPEND(gc_queue, s->manager->session_gc_queue, s); s->in_gc_queue = true; } @@ -934,13 +971,31 @@ int session_kill(Session *s, KillWho who, int signo) { return manager_kill_unit(s->manager, s->scope, who, signo, NULL); } -bool session_is_controller(Session *s, const char *sender) -{ +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) { + SessionDevice *sd; + + if (s->controller) { + manager_drop_busname(s->manager, s->controller); + free(s->controller); + s->controller = NULL; + + /* 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); + } + + s->controller = name; + session_save(s); +} + int session_set_controller(Session *s, const char *sender, bool force) { char *t; int r; @@ -963,28 +1018,18 @@ int session_set_controller(Session *s, const char *sender, bool force) { return r; } - session_drop_controller(s); + session_swap_controller(s, t); - s->controller = t; return 0; } void session_drop_controller(Session *s) { - SessionDevice *sd; - assert(s); if (!s->controller) return; - manager_drop_busname(s->manager, s->controller); - free(s->controller); - s->controller = NULL; - - /* 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); + session_swap_controller(s, NULL); } static const char* const session_state_table[_SESSION_STATE_MAX] = {