#include "logind.h"
#include "dbus-common.h"
#include "dbus-loop.h"
-
-enum {
- FD_UDEV,
- FD_CONSOLE,
- FD_BUS
-};
+#include "strv.h"
+#include "conf-parser.h"
Manager *manager_new(void) {
Manager *m;
m->console_active_fd = -1;
m->bus_fd = -1;
- m->udev_fd = -1;
+ m->udev_seat_fd = -1;
+ m->udev_vcsa_fd = -1;
m->epoll_fd = -1;
m->n_autovts = 6;
m->seats = hashmap_new(string_hash_func, string_compare_func);
m->sessions = hashmap_new(string_hash_func, string_compare_func);
m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
+ m->cgroups = hashmap_new(string_hash_func, string_compare_func);
+ m->fifo_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
+
+ if (!m->devices || !m->seats || !m->sessions || !m->users || !m->cgroups || !m->fifo_fds) {
+ manager_free(m);
+ return NULL;
+ }
- if (!m->devices || !m->seats || !m->sessions || !m->users) {
+ m->reset_controllers = strv_new("cpu", NULL);
+ m->kill_exclude_users = strv_new("root", NULL);
+ if (!m->reset_controllers || !m->kill_exclude_users) {
manager_free(m);
return NULL;
}
hashmap_free(m->users);
hashmap_free(m->devices);
hashmap_free(m->seats);
+ hashmap_free(m->cgroups);
+ hashmap_free(m->fifo_fds);
if (m->console_active_fd >= 0)
close_nointr_nofail(m->console_active_fd);
- if (m->udev_monitor)
- udev_monitor_unref(m->udev_monitor);
+ if (m->udev_seat_monitor)
+ udev_monitor_unref(m->udev_seat_monitor);
+
+ if (m->udev_vcsa_monitor)
+ udev_monitor_unref(m->udev_vcsa_monitor);
if (m->udev)
udev_unref(m->udev);
if (m->epoll_fd >= 0)
close_nointr_nofail(m->epoll_fd);
+ strv_free(m->controllers);
+ strv_free(m->reset_controllers);
+ strv_free(m->kill_only_users);
+ strv_free(m->kill_exclude_users);
+
free(m->cgroup_path);
free(m);
}
}
int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
- struct passwd *p;
+ uid_t uid;
+ gid_t gid;
+ int r;
assert(m);
assert(name);
- errno = 0;
- p = getpwnam(name);
- if (!p)
- return errno ? -errno : -ENOENT;
+ r = get_user_creds(&name, &uid, &gid, NULL);
+ if (r < 0)
+ return r;
- return manager_add_user(m, p->pw_uid, p->pw_gid, name, _user);
+ return manager_add_user(m, uid, gid, name, _user);
}
int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
}
-int manager_process_device(Manager *m, struct udev_device *d) {
+int manager_process_seat_device(Manager *m, struct udev_device *d) {
Device *device;
int r;
assert(m);
- /* FIXME: drop this check as soon as libudev's enum support
- * honours tags and subsystem matches at the same time */
- if (!streq_ptr(udev_device_get_subsystem(d), "graphics"))
- return 0;
-
if (streq_ptr(udev_device_get_action(d), "remove")) {
/* FIXME: use syspath instead of sysname here, as soon as fb driver is fixed */
Seat *seat;
sn = udev_device_get_property_value(d, "ID_SEAT");
- if (!sn)
+ if (isempty(sn))
sn = "seat0";
if (!seat_name_is_valid(sn)) {
goto finish;
}
- k = manager_process_device(m, d);
+ k = manager_process_seat_device(m, d);
udev_device_unref(d);
if (k < 0)
return r;
}
-
static int manager_enumerate_linger_users(Manager *m) {
DIR *d;
struct dirent *de;
}
while ((de = readdir(d))) {
- unsigned long ul;
+ uid_t uid;
User *u;
if (!dirent_is_file(de))
continue;
- k = safe_atolu(de->d_name, &ul);
+ k = parse_uid(de->d_name, &uid);
if (k < 0) {
log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
continue;
}
- u = hashmap_get(m->users, ULONG_TO_PTR(ul));
+ u = hashmap_get(m->users, ULONG_TO_PTR(uid));
if (!u) {
unlinkat(dirfd(d), de->d_name, 0);
continue;
while ((k = cg_read_subgroup(d, &name)) > 0) {
Session *session;
+ if (streq(name, "shared"))
+ continue;
+
k = manager_add_session(m, u, name, &session);
if (k < 0) {
free(name);
return r;
}
-int manager_dispatch_udev(Manager *m) {
+int manager_dispatch_seat_udev(Manager *m) {
struct udev_device *d;
int r;
assert(m);
- d = udev_monitor_receive_device(m->udev_monitor);
+ d = udev_monitor_receive_device(m->udev_seat_monitor);
+ if (!d)
+ return -ENOMEM;
+
+ r = manager_process_seat_device(m, d);
+ udev_device_unref(d);
+
+ return r;
+}
+
+
+int manager_dispatch_vcsa_udev(Manager *m) {
+ struct udev_device *d;
+ int r = 0;
+ const char *name;
+
+ assert(m);
+
+ d = udev_monitor_receive_device(m->udev_vcsa_monitor);
if (!d)
return -ENOMEM;
- r = manager_process_device(m, d);
+ name = udev_device_get_sysname(d);
+
+ /* Whenever a VCSA device is removed try to reallocate our
+ * VTs, to make sure our auto VTs never go away. */
+
+ if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
+ r = seat_preallocate_vts(m->vtconsole);
+
udev_device_unref(d);
return r;
assert(vtnr >= 1);
- fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
+ /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
+ * we'd open the latter we'd open the foreground tty which
+ * hence would be unconditionally busy. By opening /dev/tty1
+ * we avoid this. Since tty1 is special and needs to be an
+ * explicitly loaded getty or DM this is safe. */
+
+ fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
if (fd < 0)
return -errno;
int manager_spawn_autovt(Manager *m, int vtnr) {
int r;
+ DBusMessage *message = NULL, *reply = NULL;
+ char *name = NULL;
+ const char *mode = "fail";
+ DBusError error;
assert(m);
+ assert(vtnr >= 1);
+
+ dbus_error_init(&error);
+
+ if ((unsigned) vtnr > m->n_autovts)
+ return 0;
r = vt_is_busy(vtnr);
- if (r != 0)
+ if (r < 0)
return r;
+ else if (r > 0)
+ return -EBUSY;
+
+ message = dbus_message_new_method_call("org.freedesktop.systemd1", "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartUnit");
+ if (!message) {
+ log_error("Could not allocate message.");
+ r = -ENOMEM;
+ goto finish;
+ }
- /* ... */
+ if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
+ log_error("Could not allocate service name.");
+ r = -ENOMEM;
+ goto finish;
+ }
- return 0;
+ if (!dbus_message_append_args(message,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_STRING, &mode,
+ DBUS_TYPE_INVALID)) {
+ log_error("Could not attach target and flag information to message.");
+ r = -ENOMEM;
+ goto finish;
+ }
+
+ reply = dbus_connection_send_with_reply_and_block(m->bus, message, -1, &error);
+ if (!reply) {
+ log_error("Failed to start unit: %s", bus_error_message(&error));
+ goto finish;
+ }
+
+ r = 0;
+
+finish:
+ free(name);
+
+ if (message)
+ dbus_message_unref(message);
+
+ if (reply)
+ dbus_message_unref(reply);
+
+ dbus_error_free(&error);
+
+ return r;
+}
+
+void manager_cgroup_notify_empty(Manager *m, const char *cgroup) {
+ Session *s;
+ char *p;
+
+ assert(m);
+ assert(cgroup);
+
+ p = strdup(cgroup);
+ if (!p) {
+ log_error("Out of memory.");
+ return;
+ }
+
+ for (;;) {
+ char *e;
+
+ if (isempty(p) || streq(p, "/"))
+ break;
+
+ s = hashmap_get(m->cgroups, p);
+ if (s)
+ session_add_to_gc_queue(s);
+
+ assert_se(e = strrchr(p, '/'));
+ *e = 0;
+ }
+
+ free(p);
}
-static DBusHandlerResult login_message_filter(
- DBusConnection *connection,
- DBusMessage *message,
- void *userdata) {
+static void manager_pipe_notify_eof(Manager *m, int fd) {
+ Session *s;
+
+ assert_se(m);
+ assert_se(fd >= 0);
- return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ assert_se(s = hashmap_get(m->fifo_fds, INT_TO_PTR(fd + 1)));
+ assert(s->fifo_fd == fd);
+ session_remove_fifo(s);
+
+ session_stop(s);
}
static int manager_connect_bus(Manager *m) {
m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
if (!m->bus) {
- log_error("Failed to get system D-Bus connection: %s", error.message);
+ log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
r = -ECONNREFUSED;
goto fail;
}
!dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
!dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
!dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
- !dbus_connection_add_filter(m->bus, login_message_filter, m, NULL)) {
+ !dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
log_error("Not enough memory");
r = -ENOMEM;
goto fail;
&error);
if (dbus_error_is_set(&error)) {
- log_error("Failed to register match: %s", error.message);
+ log_error("Failed to register match: %s", bus_error_message(&error));
+ r = -EIO;
+ goto fail;
+ }
+
+ r = dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
+ if (dbus_error_is_set(&error)) {
+ log_error("Failed to register name on bus: %s", bus_error_message(&error));
r = -EIO;
goto fail;
}
- if (dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) < 0) {
- log_error("Failed to register name on bus: %s", error.message);
+ if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
+ log_error("Failed to acquire name.");
r = -EEXIST;
goto fail;
}
int r;
assert(m);
- assert(!m->udev_monitor);
+ assert(!m->udev_seat_monitor);
+ assert(!m->udev_vcsa_monitor);
- m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
- if (!m->udev_monitor)
+ m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
+ if (!m->udev_seat_monitor)
return -ENOMEM;
- r = udev_monitor_filter_add_match_tag(m->udev_monitor, "seat");
+ r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "seat");
if (r < 0)
return r;
- r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "graphics", NULL);
+ r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_seat_monitor, "graphics", NULL);
if (r < 0)
return r;
- r = udev_monitor_enable_receiving(m->udev_monitor);
+ r = udev_monitor_enable_receiving(m->udev_seat_monitor);
if (r < 0)
return r;
- m->udev_fd = udev_monitor_get_fd(m->udev_monitor);
+ m->udev_seat_fd = udev_monitor_get_fd(m->udev_seat_monitor);
zero(ev);
ev.events = EPOLLIN;
- ev.data.u32 = FD_UDEV;
+ ev.data.u32 = FD_SEAT_UDEV;
- if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_fd, &ev) < 0)
+ if (m->n_autovts <= 0)
+ return 0;
+
+ if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_seat_fd, &ev) < 0)
+ return -errno;
+
+ m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
+ if (!m->udev_vcsa_monitor)
+ return -ENOMEM;
+
+ r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
+ if (r < 0)
+ return r;
+
+ r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
+ if (r < 0)
+ return r;
+
+ m->udev_vcsa_fd = udev_monitor_get_fd(m->udev_vcsa_monitor);
+
+ zero(ev);
+ ev.events = EPOLLIN;
+ ev.data.u32 = FD_VCSA_UDEV;
+
+ if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_vcsa_fd, &ev) < 0)
return -errno;
return 0;
}
-void manager_gc(Manager *m) {
+void manager_gc(Manager *m, bool drop_not_started) {
Seat *seat;
Session *session;
User *user;
LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
seat->in_gc_queue = false;
- if (seat_check_gc(seat) == 0) {
+ if (seat_check_gc(seat, drop_not_started) == 0) {
seat_stop(seat);
seat_free(seat);
}
LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
session->in_gc_queue = false;
- if (session_check_gc(session) == 0) {
+ if (session_check_gc(session, drop_not_started) == 0) {
session_stop(session);
session_free(session);
}
LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
user->in_gc_queue = false;
- if (user_check_gc(user) == 0) {
+ if (user_check_gc(user, drop_not_started) == 0) {
user_stop(user);
user_free(user);
}
}
}
+int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
+ Session *s;
+ bool idle_hint = true;
+ dual_timestamp ts = { 0, 0 };
+ Iterator i;
+
+ assert(m);
+
+ HASHMAP_FOREACH(s, m->sessions, i) {
+ dual_timestamp k;
+ int ih;
+
+ ih = session_get_idle_hint(s, &k);
+ if (ih < 0)
+ return ih;
+
+ if (!ih) {
+ if (!idle_hint) {
+ if (k.monotonic < ts.monotonic)
+ ts = k;
+ } else {
+ idle_hint = false;
+ ts = k;
+ }
+ } else if (idle_hint) {
+
+ if (k.monotonic > ts.monotonic)
+ ts = k;
+ }
+ }
+
+ if (t)
+ *t = ts;
+
+ return idle_hint;
+}
+
int manager_startup(Manager *m) {
int r;
Seat *seat;
manager_enumerate_users(m);
manager_enumerate_sessions(m);
- /* Get rid of objects that are no longer used */
- manager_gc(m);
+ /* Remove stale objects before we start them */
+ manager_gc(m, false);
/* And start everything */
HASHMAP_FOREACH(seat, m->seats, i)
struct epoll_event event;
int n;
- manager_gc(m);
+ manager_gc(m, true);
if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
continue;
+ manager_gc(m, true);
+
n = epoll_wait(m->epoll_fd, &event, 1, -1);
if (n < 0) {
if (errno == EINTR || errno == EAGAIN)
switch (event.data.u32) {
- case FD_UDEV:
- manager_dispatch_udev(m);
+ case FD_SEAT_UDEV:
+ manager_dispatch_seat_udev(m);
+ break;
+
+ case FD_VCSA_UDEV:
+ manager_dispatch_vcsa_udev(m);
break;
case FD_CONSOLE:
case FD_BUS:
bus_loop_dispatch(m->bus_fd);
break;
+
+ default:
+ if (event.data.u32 >= FD_FIFO_BASE)
+ manager_pipe_notify_eof(m, event.data.u32 - FD_FIFO_BASE);
}
}
return 0;
}
+static int manager_parse_config_file(Manager *m) {
+ FILE *f;
+ const char *fn;
+ int r;
+
+ assert(m);
+
+ fn = "/etc/systemd/systemd-logind.conf";
+ f = fopen(fn, "re");
+ if (!f) {
+ if (errno == ENOENT)
+ return 0;
+
+ log_warning("Failed to open configuration file %s: %m", fn);
+ return -errno;
+ }
+
+ r = config_parse(fn, f, "Login\0", config_item_perf_lookup, (void*) logind_gperf_lookup, false, m);
+ if (r < 0)
+ log_warning("Failed to parse configuration file: %s", strerror(-r));
+
+ fclose(f);
+
+ return r;
+}
+
int main(int argc, char *argv[]) {
Manager *m = NULL;
int r;
log_parse_environment();
log_open();
+ umask(0022);
+
if (argc != 1) {
log_error("This program takes no arguments.");
r = -EINVAL;
goto finish;
}
- umask(0022);
-
m = manager_new();
if (!m) {
log_error("Out of memory");
goto finish;
}
+ manager_parse_config_file(m);
+
r = manager_startup(m);
if (r < 0) {
log_error("Failed to fully start up daemon: %s", strerror(-r));