X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fload-fragment.c;h=0961d945aa3a2d042fc29389019d2bf032dd2ccf;hp=424e6c37bb9d8d6e82572d986713a407ae04eec5;hb=1124fe6f01b1d59d016c238026f20380f38d98dc;hpb=d257ddef22ff1a1b98e6172799819e6511b1bcfb diff --git a/src/load-fragment.c b/src/load-fragment.c index 424e6c37b..0961d945a 100644 --- a/src/load-fragment.c +++ b/src/load-fragment.c @@ -30,6 +30,8 @@ #include #include #include +#include +#include #include "unit.h" #include "strv.h" @@ -43,11 +45,12 @@ #include "bus-errors.h" #ifndef HAVE_SYSV_COMPAT -static int config_parse_warn_compat( +int config_parse_warn_compat( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -57,16 +60,17 @@ static int config_parse_warn_compat( } #endif -static int config_parse_deps( +int config_parse_unit_deps( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { - UnitDependency d = PTR_TO_UINT(data); + UnitDependency d = ltype; Unit *u = userdata; char *w; size_t l; @@ -80,7 +84,8 @@ static int config_parse_deps( char *t, *k; int r; - if (!(t = strndup(w, l))) + t = strndup(w, l); + if (!t) return -ENOMEM; k = unit_name_printf(u, t); @@ -90,12 +95,8 @@ static int config_parse_deps( return -ENOMEM; r = unit_add_dependency_by_name(u, d, k, NULL, true); - - if (r < 0) { - log_error("Failed to add dependency on %s, ignoring: %s", k, strerror(-r)); - free(k); - return 0; - } + if (r < 0) + log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", filename, line, k, strerror(-r)); free(k); } @@ -103,11 +104,12 @@ static int config_parse_deps( return 0; } -static int config_parse_names( +int config_parse_unit_names( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -149,11 +151,12 @@ static int config_parse_names( return 0; } -static int config_parse_string_printf( +int config_parse_unit_string_printf( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -182,17 +185,83 @@ static int config_parse_string_printf( return 0; } -static int config_parse_listen( +int config_parse_unit_strv_printf( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { + Unit *u = userdata; + char *k; int r; - SocketPort *p; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(u); + + k = unit_full_printf(u, rvalue); + if (!k) + return -ENOMEM; + + r = config_parse_strv(filename, line, section, lvalue, ltype, k, data, userdata); + free(k); + + return r; +} + +int config_parse_unit_path_printf( + const char *filename, + unsigned line, + const char *section, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + Unit *u = userdata; + char **s = data; + char *k; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(s); + assert(u); + + if (!(k = unit_full_printf(u, rvalue))) + return -ENOMEM; + + if (!path_is_absolute(k)) { + log_error("[%s:%u] Not an absolute path: %s", filename, line, k); + free(k); + return -EINVAL; + } + + path_kill_slashes(k); + + free(*s); + *s = k; + + return 0; +} + +int config_parse_socket_listen( + const char *filename, + unsigned line, + const char *section, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + SocketPort *p, *tail; Socket *s; assert(filename); @@ -208,16 +277,59 @@ static int config_parse_listen( if (streq(lvalue, "ListenFIFO")) { p->type = SOCKET_FIFO; - if (!(p->path = strdup(rvalue))) { + if (!(p->path = unit_full_printf(UNIT(s), rvalue))) { + free(p); + return -ENOMEM; + } + + path_kill_slashes(p->path); + + } else if (streq(lvalue, "ListenSpecial")) { + p->type = SOCKET_SPECIAL; + + if (!(p->path = unit_full_printf(UNIT(s), rvalue))) { free(p); return -ENOMEM; } path_kill_slashes(p->path); + + } else if (streq(lvalue, "ListenMessageQueue")) { + + p->type = SOCKET_MQUEUE; + + if (!(p->path = unit_full_printf(UNIT(s), rvalue))) { + free(p); + return -ENOMEM; + } + + path_kill_slashes(p->path); + + } else if (streq(lvalue, "ListenNetlink")) { + char *k; + int r; + + p->type = SOCKET_SOCKET; + k = unit_full_printf(UNIT(s), rvalue); + r = socket_address_parse_netlink(&p->address, k); + free(k); + + if (r < 0) { + log_error("[%s:%u] Failed to parse address value, ignoring: %s", filename, line, rvalue); + free(p); + return 0; + } + } else { + char *k; + int r; + p->type = SOCKET_SOCKET; + k = unit_full_printf(UNIT(s), rvalue); + r = socket_address_parse(&p->address, k); + free(k); - if ((r = socket_address_parse(&p->address, rvalue)) < 0) { + if (r < 0) { log_error("[%s:%u] Failed to parse address value, ignoring: %s", filename, line, rvalue); free(p); return 0; @@ -240,16 +352,22 @@ static int config_parse_listen( } p->fd = -1; - LIST_PREPEND(SocketPort, port, s->ports, p); + + if (s->ports) { + LIST_FIND_TAIL(SocketPort, port, s->ports, tail); + LIST_INSERT_AFTER(SocketPort, port, s->ports, tail, p); + } else + LIST_PREPEND(SocketPort, port, s->ports, p); return 0; } -static int config_parse_socket_bind( +int config_parse_socket_bind( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -279,24 +397,25 @@ static int config_parse_socket_bind( return 0; } -static int config_parse_nice( +int config_parse_exec_nice( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { ExecContext *c = data; - int priority, r; + int priority; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if ((r = safe_atoi(rvalue, &priority)) < 0) { + if (safe_atoi(rvalue, &priority) < 0) { log_error("[%s:%u] Failed to parse nice priority, ignoring: %s. ", filename, line, rvalue); return 0; } @@ -307,29 +426,30 @@ static int config_parse_nice( } c->nice = priority; - c->nice_set = false; + c->nice_set = true; return 0; } -static int config_parse_oom_score_adjust( +int config_parse_exec_oom_score_adjust( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { ExecContext *c = data; - int oa, r; + int oa; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if ((r = safe_atoi(rvalue, &oa)) < 0) { + if (safe_atoi(rvalue, &oa) < 0) { log_error("[%s:%u] Failed to parse the OOM score adjust value, ignoring: %s", filename, line, rvalue); return 0; } @@ -345,45 +465,12 @@ static int config_parse_oom_score_adjust( return 0; } -static int config_parse_mode( - const char *filename, - unsigned line, - const char *section, - const char *lvalue, - const char *rvalue, - void *data, - void *userdata) { - - mode_t *m = data; - long l; - char *x = NULL; - - assert(filename); - assert(lvalue); - assert(rvalue); - assert(data); - - errno = 0; - l = strtol(rvalue, &x, 8); - if (!x || *x || errno) { - log_error("[%s:%u] Failed to parse mode value, ignoring: %s", filename, line, rvalue); - return 0; - } - - if (l < 0000 || l > 07777) { - log_error("[%s:%u] mode value out of range, ignoring: %s", filename, line, rvalue); - return 0; - } - - *m = (mode_t) l; - return 0; -} - -static int config_parse_exec( +int config_parse_exec( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -401,6 +488,8 @@ static int config_parse_exec( * alternatively an absolute prefixed with @ to allow * overriding of argv[0]. */ + e += ltype; + for (;;) { char *w; size_t l; @@ -433,7 +522,7 @@ static int config_parse_exec( k = 0; FOREACH_WORD_QUOTED(w, l, rvalue, state) { - if (strncmp(w, ";", l) == 0) + if (strncmp(w, ";", MAX(l, 1U)) == 0) break; k++; @@ -444,7 +533,7 @@ static int config_parse_exec( k = 0; FOREACH_WORD_QUOTED(w, l, rvalue, state) { - if (strncmp(w, ";", l) == 0) + if (strncmp(w, ";", MAX(l, 1U)) == 0) break; if (honour_argv0 && w == rvalue) { @@ -462,6 +551,7 @@ static int config_parse_exec( if (!n[0]) { log_error("[%s:%u] Invalid command line, ignoring: %s", filename, line, rvalue); strv_free(n); + free(path); return 0; } @@ -496,39 +586,15 @@ fail: return -ENOMEM; } -static int config_parse_usec( - const char *filename, - unsigned line, - const char *section, - const char *lvalue, - const char *rvalue, - void *data, - void *userdata) { - - usec_t *usec = data; - int r; - - assert(filename); - assert(lvalue); - assert(rvalue); - assert(data); - - if ((r = parse_usec(rvalue, usec)) < 0) { - log_error("[%s:%u] Failed to parse time value, ignoring: %s", filename, line, rvalue); - return 0; - } - - return 0; -} - -static DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type"); -static DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier"); +DEFINE_CONFIG_PARSE_ENUM(config_parse_service_type, service_type, ServiceType, "Failed to parse service type"); +DEFINE_CONFIG_PARSE_ENUM(config_parse_service_restart, service_restart, ServiceRestart, "Failed to parse service restart specifier"); -static int config_parse_bindtodevice( +int config_parse_socket_bindtodevice( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -553,14 +619,15 @@ static int config_parse_bindtodevice( return 0; } -static DEFINE_CONFIG_PARSE_ENUM(config_parse_output, exec_output, ExecOutput, "Failed to parse output specifier"); -static DEFINE_CONFIG_PARSE_ENUM(config_parse_input, exec_input, ExecInput, "Failed to parse input specifier"); +DEFINE_CONFIG_PARSE_ENUM(config_parse_output, exec_output, ExecOutput, "Failed to parse output specifier"); +DEFINE_CONFIG_PARSE_ENUM(config_parse_input, exec_input, ExecInput, "Failed to parse input specifier"); -static int config_parse_facility( +int config_parse_facility( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -573,21 +640,22 @@ static int config_parse_facility( assert(rvalue); assert(data); - if ((x = log_facility_from_string(rvalue)) < 0) { + if ((x = log_facility_unshifted_from_string(rvalue)) < 0) { log_error("[%s:%u] Failed to parse log facility, ignoring: %s", filename, line, rvalue); return 0; } - *o = LOG_MAKEPRI(x, LOG_PRI(*o)); + *o = (x << 3) | LOG_PRI(*o); return 0; } -static int config_parse_level( +int config_parse_level( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -605,15 +673,16 @@ static int config_parse_level( return 0; } - *o = LOG_MAKEPRI(LOG_FAC(*o), x); + *o = (*o & LOG_FACMASK) | x; return 0; } -static int config_parse_io_class( +int config_parse_exec_io_class( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -637,11 +706,12 @@ static int config_parse_io_class( return 0; } -static int config_parse_io_priority( +int config_parse_exec_io_priority( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -665,11 +735,12 @@ static int config_parse_io_priority( return 0; } -static int config_parse_cpu_sched_policy( +int config_parse_exec_cpu_sched_policy( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -694,11 +765,12 @@ static int config_parse_cpu_sched_policy( return 0; } -static int config_parse_cpu_sched_prio( +int config_parse_exec_cpu_sched_prio( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -723,11 +795,12 @@ static int config_parse_cpu_sched_prio( return 0; } -static int config_parse_cpu_affinity( +int config_parse_exec_cpu_affinity( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -768,11 +841,12 @@ static int config_parse_cpu_affinity( return 0; } -static int config_parse_capabilities( +int config_parse_exec_capabilities( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -800,11 +874,12 @@ static int config_parse_capabilities( return 0; } -static int config_parse_secure_bits( +int config_parse_exec_secure_bits( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -841,11 +916,12 @@ static int config_parse_secure_bits( return 0; } -static int config_parse_bounding_set( +int config_parse_exec_bounding_set( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -854,12 +930,24 @@ static int config_parse_bounding_set( char *w; size_t l; char *state; + bool invert = false; + uint64_t sum = 0; assert(filename); assert(lvalue); assert(rvalue); assert(data); + if (rvalue[0] == '~') { + invert = true; + rvalue++; + } + + /* Note that we store this inverted internally, since the + * kernel wants it like this. But we actually expose it + * non-inverted everywhere to have a fully normalized + * interface. */ + FOREACH_WORD_QUOTED(w, l, rvalue, state) { char *t; int r; @@ -876,31 +964,36 @@ static int config_parse_bounding_set( return 0; } - c->capability_bounding_set_drop |= 1 << cap; + sum |= ((uint64_t) 1ULL) << (uint64_t) cap; } + if (invert) + c->capability_bounding_set_drop |= sum; + else + c->capability_bounding_set_drop |= ~sum; + return 0; } -static int config_parse_timer_slack_nsec( +int config_parse_exec_timer_slack_nsec( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { ExecContext *c = data; unsigned long u; - int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if ((r = safe_atolu(rvalue, &u)) < 0) { + if (safe_atolu(rvalue, &u) < 0) { log_error("[%s:%u] Failed to parse time slack value, ignoring: %s", filename, line, rvalue); return 0; } @@ -910,25 +1003,29 @@ static int config_parse_timer_slack_nsec( return 0; } -static int config_parse_limit( +int config_parse_limit( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { struct rlimit **rl = data; unsigned long long u; - int r; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if ((r = safe_atollu(rvalue, &u)) < 0) { + rl += ltype; + + if (streq(rvalue, "infinity")) + u = (unsigned long long) RLIM_INFINITY; + else if (safe_atollu(rvalue, &u) < 0) { log_error("[%s:%u] Failed to parse resource value, ignoring: %s", filename, line, rvalue); return 0; } @@ -941,11 +1038,12 @@ static int config_parse_limit( return 0; } -static int config_parse_cgroup( +int config_parse_unit_cgroup( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -956,10 +1054,23 @@ static int config_parse_cgroup( char *state; FOREACH_WORD_QUOTED(w, l, rvalue, state) { - char *t; + char *t, *k; int r; - if (!(t = cunescape_length(w, l))) + t = strndup(w, l); + if (!t) + return -ENOMEM; + + k = unit_full_printf(u, t); + free(t); + + if (!k) + return -ENOMEM; + + t = cunescape(k); + free(k); + + if (!t) return -ENOMEM; r = unit_add_cgroup_from_text(u, t); @@ -975,24 +1086,25 @@ static int config_parse_cgroup( } #ifdef HAVE_SYSV_COMPAT -static int config_parse_sysv_priority( +int config_parse_sysv_priority( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { int *priority = data; - int r, i; + int i; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if ((r = safe_atoi(rvalue, &i)) < 0 || i < 0) { + if (safe_atoi(rvalue, &i) < 0 || i < 0) { log_error("[%s:%u] Failed to parse SysV start priority, ignoring: %s", filename, line, rvalue); return 0; } @@ -1002,24 +1114,25 @@ static int config_parse_sysv_priority( } #endif -static int config_parse_fsck_passno( +int config_parse_fsck_passno( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { int *passno = data; - int r, i; + int i; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if ((r = safe_atoi(rvalue, &i)) < 0 || i < 0) { + if (safe_atoi(rvalue, &i) || i < 0) { log_error("[%s:%u] Failed to parse fsck pass number, ignoring: %s", filename, line, rvalue); return 0; } @@ -1028,13 +1141,14 @@ static int config_parse_fsck_passno( return 0; } -static DEFINE_CONFIG_PARSE_ENUM(config_parse_kill_mode, kill_mode, KillMode, "Failed to parse kill mode"); +DEFINE_CONFIG_PARSE_ENUM(config_parse_kill_mode, kill_mode, KillMode, "Failed to parse kill mode"); -static int config_parse_kill_signal( +int config_parse_kill_signal( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -1056,11 +1170,12 @@ static int config_parse_kill_signal( return 0; } -static int config_parse_mount_flags( +int config_parse_exec_mount_flags( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -1077,11 +1192,11 @@ static int config_parse_mount_flags( assert(data); FOREACH_WORD_QUOTED(w, l, rvalue, state) { - if (strncmp(w, "shared", l) == 0) + if (strncmp(w, "shared", MAX(l, 6U)) == 0) flags |= MS_SHARED; - else if (strncmp(w, "slave", l) == 0) + else if (strncmp(w, "slave", MAX(l, 5U)) == 0) flags |= MS_SLAVE; - else if (strncmp(w, "private", l) == 0) + else if (strncmp(w, "private", MAX(l, 7U)) == 0) flags |= MS_PRIVATE; else { log_error("[%s:%u] Failed to parse mount flags, ignoring: %s", filename, line, rvalue); @@ -1093,18 +1208,18 @@ static int config_parse_mount_flags( return 0; } -static int config_parse_timer( +int config_parse_timer( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { Timer *t = data; usec_t u; - int r; TimerValue *v; TimerBase b; @@ -1118,7 +1233,7 @@ static int config_parse_timer( return 0; } - if ((r = parse_usec(rvalue, &u)) < 0) { + if (parse_usec(rvalue, &u) < 0) { log_error("[%s:%u] Failed to parse timer value, ignoring: %s", filename, line, rvalue); return 0; } @@ -1134,11 +1249,12 @@ static int config_parse_timer( return 0; } -static int config_parse_timer_unit( +int config_parse_timer_unit( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -1146,6 +1262,7 @@ static int config_parse_timer_unit( Timer *t = data; int r; DBusError error; + Unit *u; assert(filename); assert(lvalue); @@ -1159,20 +1276,24 @@ static int config_parse_timer_unit( return 0; } - if ((r = manager_load_unit(t->meta.manager, rvalue, NULL, NULL, &t->unit)) < 0) { + r = manager_load_unit(UNIT(t)->manager, rvalue, NULL, NULL, &u); + if (r < 0) { log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r)); dbus_error_free(&error); return 0; } + unit_ref_set(&t->unit, u); + return 0; } -static int config_parse_path_spec( +int config_parse_path_spec( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -1214,11 +1335,12 @@ static int config_parse_path_spec( return 0; } -static int config_parse_path_unit( +int config_parse_path_unit( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -1226,6 +1348,7 @@ static int config_parse_path_unit( Path *t = data; int r; DBusError error; + Unit *u; assert(filename); assert(lvalue); @@ -1239,20 +1362,23 @@ static int config_parse_path_unit( return 0; } - if ((r = manager_load_unit(t->meta.manager, rvalue, NULL, &error, &t->unit)) < 0) { + if ((r = manager_load_unit(UNIT(t)->manager, rvalue, NULL, &error, &u)) < 0) { log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r)); dbus_error_free(&error); return 0; } + unit_ref_set(&t->unit, u); + return 0; } -static int config_parse_socket_service( +int config_parse_socket_service( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { @@ -1260,6 +1386,7 @@ static int config_parse_socket_service( Socket *s = data; int r; DBusError error; + Unit *x; assert(filename); assert(lvalue); @@ -1273,27 +1400,30 @@ static int config_parse_socket_service( return 0; } - if ((r = manager_load_unit(s->meta.manager, rvalue, NULL, &error, (Unit**) &s->service)) < 0) { + r = manager_load_unit(UNIT(s)->manager, rvalue, NULL, &error, &x); + if (r < 0) { log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r)); dbus_error_free(&error); return 0; } + unit_ref_set(&s->service, x); + return 0; } -static int config_parse_service_sockets( +int config_parse_service_sockets( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { Service *s = data; int r; - DBusError error; char *state, *w; size_t l; @@ -1302,110 +1432,90 @@ static int config_parse_service_sockets( assert(rvalue); assert(data); - dbus_error_init(&error); - FOREACH_WORD_QUOTED(w, l, rvalue, state) { - char *t; - Unit *sock; + char *t, *k; - if (!(t = strndup(w, l))) + t = strndup(w, l); + if (!t) return -ENOMEM; - if (!endswith(t, ".socket")) { - log_error("[%s:%u] Unit must be of type socket, ignoring: %s", filename, line, rvalue); - free(t); - continue; - } - - r = manager_load_unit(s->meta.manager, t, NULL, &error, &sock); + k = unit_name_printf(UNIT(s), t); free(t); - if (r < 0) { - log_error("[%s:%u] Failed to load unit %s, ignoring: %s", filename, line, rvalue, bus_error(&error, r)); - dbus_error_free(&error); + if (!k) + return -ENOMEM; + + if (!endswith(k, ".socket")) { + log_error("[%s:%u] Unit must be of type socket, ignoring: %s", filename, line, rvalue); + free(k); continue; } - if ((r = set_ensure_allocated(&s->configured_sockets, trivial_hash_func, trivial_compare_func)) < 0) - return r; + r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_WANTS, UNIT_AFTER, k, NULL, true); + if (r < 0) + log_error("[%s:%u] Failed to add dependency on %s, ignoring: %s", filename, line, k, strerror(-r)); - if ((r = set_put(s->configured_sockets, sock)) < 0) + r = unit_add_dependency_by_name(UNIT(s), UNIT_TRIGGERED_BY, k, NULL, true); + if (r < 0) return r; + + free(k); } return 0; } -static int config_parse_env_file( +int config_parse_unit_env_file( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { - FILE *f; - int r; - char ***env = data; + char ***env = data, **k; + Unit *u = userdata; + char *s; assert(filename); assert(lvalue); assert(rvalue); assert(data); - if (!(f = fopen(rvalue, "re"))) { - log_error("[%s:%u] Failed to open environment file '%s', ignoring: %m", filename, line, rvalue); - return 0; - } - - while (!feof(f)) { - char l[LINE_MAX], *p; - char **t; - - if (!fgets(l, sizeof(l), f)) { - if (feof(f)) - break; - - r = -errno; - log_error("[%s:%u] Failed to read environment file '%s', ignoring: %m", filename, line, rvalue); - r = 0; - goto finish; - } - - p = strstrip(l); - - if (!*p) - continue; - - if (strchr(COMMENTS, *p)) - continue; + s = unit_full_printf(u, rvalue); + if (!s) + return -ENOMEM; - t = strv_env_set(*env, p); - strv_free(*env); - *env = t; + if (!path_is_absolute(s[0] == '-' ? s + 1 : s)) { + log_error("[%s:%u] Path '%s' is not absolute, ignoring.", filename, line, s); + free(s); + return 0; } - r = 0; + k = strv_append(*env, s); + free(s); + if (!k) + return -ENOMEM; -finish: - if (f) - fclose(f); + strv_free(*env); + *env = k; - return r; + return 0; } -static int config_parse_ip_tos( +int config_parse_ip_tos( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { int *ip_tos = data, x; - int r; assert(filename); assert(lvalue); @@ -1413,7 +1523,7 @@ static int config_parse_ip_tos( assert(data); if ((x = ip_tos_from_string(rvalue)) < 0) - if ((r = safe_atoi(rvalue, &x)) < 0) { + if (safe_atoi(rvalue, &x) < 0) { log_error("[%s:%u] Failed to parse IP TOS value, ignoring: %s", filename, line, rvalue); return 0; } @@ -1422,17 +1532,19 @@ static int config_parse_ip_tos( return 0; } -static int config_parse_condition_path( +int config_parse_unit_condition_path( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { + ConditionType cond = ltype; Unit *u = data; - bool negate; + bool trigger, negate; Condition *c; assert(filename); @@ -1440,7 +1552,12 @@ static int config_parse_condition_path( assert(rvalue); assert(data); - if ((negate = rvalue[0] == '!')) + trigger = rvalue[0] == '|'; + if (trigger) + rvalue++; + + negate = rvalue[0] == '!'; + if (negate) rvalue++; if (!path_is_absolute(rvalue)) { @@ -1448,24 +1565,27 @@ static int config_parse_condition_path( return 0; } - if (!(c = condition_new(CONDITION_PATH_EXISTS, rvalue, negate))) + c = condition_new(cond, rvalue, trigger, negate); + if (!c) return -ENOMEM; - LIST_PREPEND(Condition, conditions, u->meta.conditions, c); + LIST_PREPEND(Condition, conditions, u->conditions, c); return 0; } -static int config_parse_condition_kernel( +int config_parse_unit_condition_string( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { + ConditionType cond = ltype; Unit *u = data; - bool negate; + bool trigger, negate; Condition *c; assert(filename); @@ -1473,28 +1593,32 @@ static int config_parse_condition_kernel( assert(rvalue); assert(data); + if ((trigger = rvalue[0] == '|')) + rvalue++; + if ((negate = rvalue[0] == '!')) rvalue++; - if (!(c = condition_new(CONDITION_KERNEL_COMMAND_LINE, rvalue, negate))) + if (!(c = condition_new(cond, rvalue, trigger, negate))) return -ENOMEM; - LIST_PREPEND(Condition, conditions, u->meta.conditions, c); + LIST_PREPEND(Condition, conditions, u->conditions, c); return 0; } -static int config_parse_condition_null( +int config_parse_unit_condition_null( const char *filename, unsigned line, const char *section, const char *lvalue, + int ltype, const char *rvalue, void *data, void *userdata) { Unit *u = data; Condition *c; - bool negate; + bool trigger, negate; int b; assert(filename); @@ -1502,6 +1626,9 @@ static int config_parse_condition_null( assert(rvalue); assert(data); + if ((trigger = rvalue[0] == '|')) + rvalue++; + if ((negate = rvalue[0] == '!')) rvalue++; @@ -1513,14 +1640,383 @@ static int config_parse_condition_null( if (!b) negate = !negate; - if (!(c = condition_new(CONDITION_NULL, NULL, negate))) + if (!(c = condition_new(CONDITION_NULL, NULL, trigger, negate))) return -ENOMEM; - LIST_PREPEND(Condition, conditions, u->meta.conditions, c); + LIST_PREPEND(Condition, conditions, u->conditions, c); + return 0; +} + +DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier"); + +int config_parse_unit_cgroup_attr( + const char *filename, + unsigned line, + const char *section, + const char *lvalue, + int ltype, + const char *rvalue, + void *data, + void *userdata) { + + Unit *u = data; + char **l; + int r; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + l = strv_split_quoted(rvalue); + if (!l) + return -ENOMEM; + + if (strv_length(l) != 2) { + log_error("[%s:%u] Failed to parse cgroup attribute value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + r = unit_add_cgroup_attribute(u, NULL, l[0], l[1], NULL); + strv_free(l); + + if (r < 0) { + log_error("[%s:%u] Failed to add cgroup attribute value, ignoring: %s", filename, line, rvalue); + return 0; + } + + return 0; +} + +int config_parse_unit_cpu_shares(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { + Unit *u = data; + int r; + unsigned long ul; + char *t; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + if (safe_atolu(rvalue, &ul) < 0 || ul < 1) { + log_error("[%s:%u] Failed to parse CPU shares value, ignoring: %s", filename, line, rvalue); + return 0; + } + + if (asprintf(&t, "%lu", ul) < 0) + return -ENOMEM; + + r = unit_add_cgroup_attribute(u, "cpu", "cpu.shares", t, NULL); + free(t); + + if (r < 0) { + log_error("[%s:%u] Failed to add cgroup attribute value, ignoring: %s", filename, line, rvalue); + return 0; + } + + return 0; +} + +int config_parse_unit_memory_limit(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { + Unit *u = data; + int r; + off_t sz; + char *t; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + if (parse_bytes(rvalue, &sz) < 0 || sz <= 0) { + log_error("[%s:%u] Failed to parse memory limit value, ignoring: %s", filename, line, rvalue); + return 0; + } + + if (asprintf(&t, "%llu", (unsigned long long) sz) < 0) + return -ENOMEM; + + r = unit_add_cgroup_attribute(u, + "memory", + streq(lvalue, "MemorySoftLimit") ? "memory.soft_limit_in_bytes" : "memory.limit_in_bytes", + t, NULL); + free(t); + + if (r < 0) { + log_error("[%s:%u] Failed to add cgroup attribute value, ignoring: %s", filename, line, rvalue); + return 0; + } + + return 0; +} + +static int device_map(const char *controller, const char *name, const char *value, char **ret) { + char **l; + + assert(controller); + assert(name); + assert(value); + assert(ret); + + l = strv_split_quoted(value); + if (!l) + return -ENOMEM; + + assert(strv_length(l) >= 1); + + if (streq(l[0], "*")) { + + if (asprintf(ret, "a *:*%s%s", + isempty(l[1]) ? "" : " ", strempty(l[1])) < 0) { + strv_free(l); + return -ENOMEM; + } + + } else { + struct stat st; + + if (stat(l[0], &st) < 0) { + log_warning("Couldn't stat device %s", l[0]); + strv_free(l); + return -errno; + } + + if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) { + log_warning("%s is not a device.", l[0]); + strv_free(l); + return -ENODEV; + } + + if (asprintf(ret, "%c %u:%u%s%s", + S_ISCHR(st.st_mode) ? 'c' : 'b', + major(st.st_rdev), minor(st.st_rdev), + isempty(l[1]) ? "" : " ", strempty(l[1])) < 0) { + + strv_free(l); + return -ENOMEM; + } + } + + strv_free(l); + return 0; +} + +int config_parse_unit_device_allow(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { + Unit *u = data; + char **l; + int r; + unsigned k; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + l = strv_split_quoted(rvalue); + if (!l) + return -ENOMEM; + + k = strv_length(l); + if (k < 1 || k > 2) { + log_error("[%s:%u] Failed to parse device value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (!streq(l[0], "*") && !path_startswith(l[0], "/dev")) { + log_error("[%s:%u] Device node path not absolute, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (!isempty(l[1]) && !in_charset(l[1], "rwm")) { + log_error("[%s:%u] Device access string invalid, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + strv_free(l); + + r = unit_add_cgroup_attribute(u, "devices", + streq(lvalue, "DeviceAllow") ? "devices.allow" : "devices.deny", + rvalue, device_map); + + if (r < 0) { + log_error("[%s:%u] Failed to add cgroup attribute value, ignoring: %s", filename, line, rvalue); + return 0; + } + + return 0; +} + +static int blkio_map(const char *controller, const char *name, const char *value, char **ret) { + struct stat st; + char **l; + dev_t d; + + assert(controller); + assert(name); + assert(value); + assert(ret); + + l = strv_split_quoted(value); + if (!l) + return -ENOMEM; + + assert(strv_length(l) == 2); + + if (stat(l[0], &st) < 0) { + log_warning("Couldn't stat device %s", l[0]); + strv_free(l); + return -errno; + } + + if (S_ISBLK(st.st_mode)) + d = st.st_rdev; + else if (major(st.st_dev) != 0) { + /* If this is not a device node then find the block + * device this file is stored on */ + d = st.st_dev; + + /* If this is a partition, try to get the originating + * block device */ + block_get_whole_disk(d, &d); + } else { + log_warning("%s is not a block device and file system block device cannot be determined or is not local.", l[0]); + strv_free(l); + return -ENODEV; + } + + if (asprintf(ret, "%u:%u %s", major(d), minor(d), l[1]) < 0) { + strv_free(l); + return -ENOMEM; + } + + strv_free(l); + return 0; +} + +int config_parse_unit_blkio_weight(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { + Unit *u = data; + int r; + unsigned long ul; + const char *device = NULL, *weight; + unsigned k; + char *t, **l; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + l = strv_split_quoted(rvalue); + if (!l) + return -ENOMEM; + + k = strv_length(l); + if (k < 1 || k > 2) { + log_error("[%s:%u] Failed to parse weight value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (k == 1) + weight = l[0]; + else { + device = l[0]; + weight = l[1]; + } + + if (device && !path_is_absolute(device)) { + log_error("[%s:%u] Failed to parse block device node value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (safe_atolu(weight, &ul) < 0 || ul < 10 || ul > 1000) { + log_error("[%s:%u] Failed to parse block IO weight value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (device) + r = asprintf(&t, "%s %lu", device, ul); + else + r = asprintf(&t, "%lu", ul); + strv_free(l); + + if (r < 0) + return -ENOMEM; + + if (device) + r = unit_add_cgroup_attribute(u, "blkio", "blkio.weight_device", t, blkio_map); + else + r = unit_add_cgroup_attribute(u, "blkio", "blkio.weight", t, NULL); + free(t); + + if (r < 0) { + log_error("[%s:%u] Failed to add cgroup attribute value, ignoring: %s", filename, line, rvalue); + return 0; + } + + return 0; +} + +int config_parse_unit_blkio_bandwidth(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata) { + Unit *u = data; + int r; + off_t bytes; + unsigned k; + char *t, **l; + + assert(filename); + assert(lvalue); + assert(rvalue); + assert(data); + + l = strv_split_quoted(rvalue); + if (!l) + return -ENOMEM; + + k = strv_length(l); + if (k != 2) { + log_error("[%s:%u] Failed to parse bandwidth value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (!path_is_absolute(l[0])) { + log_error("[%s:%u] Failed to parse block device node value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + if (parse_bytes(l[1], &bytes) < 0 || bytes <= 0) { + log_error("[%s:%u] Failed to parse block IO bandwith value, ignoring: %s", filename, line, rvalue); + strv_free(l); + return 0; + } + + r = asprintf(&t, "%s %llu", l[0], (unsigned long long) bytes); + strv_free(l); + + if (r < 0) + return -ENOMEM; + + r = unit_add_cgroup_attribute(u, "blkio", + streq(lvalue, "BlockIOReadBandwidth") ? "blkio.read_bps_device" : "blkio.write_bps_device", + t, blkio_map); + free(t); + + if (r < 0) { + log_error("[%s:%u] Failed to add cgroup attribute value, ignoring: %s", filename, line, rvalue); + return 0; + } + return 0; } -static DEFINE_CONFIG_PARSE_ENUM(config_parse_notify_access, notify_access, NotifyAccess, "Failed to parse notify access specifier"); #define FOLLOW_MAX 8 @@ -1551,13 +2047,16 @@ static int open_follow(char **filename, FILE **_f, Set *names, char **_final) { * unit name. */ name = file_name_from_path(*filename); - if (unit_name_is_valid(name, false)) { - if (!(id = set_get(names, name))) { + if (unit_name_is_valid(name, true)) { - if (!(id = strdup(name))) + id = set_get(names, name); + if (!id) { + id = strdup(name); + if (!id) return -ENOMEM; - if ((r = set_put(names, id)) < 0) { + r = set_put(names, id); + if (r < 0) { free(id); return r; } @@ -1610,7 +2109,7 @@ static int merge_by_names(Unit **u, Set *names, const char *id) { * ours? Then let's try it the other way * round */ - other = manager_get_unit((*u)->meta.manager, k); + other = manager_get_unit((*u)->manager, k); free(k); if (other) @@ -1631,285 +2130,7 @@ static int merge_by_names(Unit **u, Set *names, const char *id) { return 0; } -static void dump_items(FILE *f, const ConfigItem *items) { - const ConfigItem *i; - const char *prev_section = NULL; - bool not_first = false; - - struct { - ConfigParserCallback callback; - const char *rvalue; - } table[] = { - { config_parse_int, "INTEGER" }, - { config_parse_unsigned, "UNSIGNED" }, - { config_parse_size, "SIZE" }, - { config_parse_bool, "BOOLEAN" }, - { config_parse_string, "STRING" }, - { config_parse_path, "PATH" }, - { config_parse_strv, "STRING [...]" }, - { config_parse_nice, "NICE" }, - { config_parse_oom_score_adjust, "OOMSCOREADJUST" }, - { config_parse_io_class, "IOCLASS" }, - { config_parse_io_priority, "IOPRIORITY" }, - { config_parse_cpu_sched_policy, "CPUSCHEDPOLICY" }, - { config_parse_cpu_sched_prio, "CPUSCHEDPRIO" }, - { config_parse_cpu_affinity, "CPUAFFINITY" }, - { config_parse_mode, "MODE" }, - { config_parse_env_file, "FILE" }, - { config_parse_output, "OUTPUT" }, - { config_parse_input, "INPUT" }, - { config_parse_facility, "FACILITY" }, - { config_parse_level, "LEVEL" }, - { config_parse_capabilities, "CAPABILITIES" }, - { config_parse_secure_bits, "SECUREBITS" }, - { config_parse_bounding_set, "BOUNDINGSET" }, - { config_parse_timer_slack_nsec, "TIMERSLACK" }, - { config_parse_limit, "LIMIT" }, - { config_parse_cgroup, "CGROUP [...]" }, - { config_parse_deps, "UNIT [...]" }, - { config_parse_names, "UNIT [...]" }, - { config_parse_exec, "PATH [ARGUMENT [...]]" }, - { config_parse_service_type, "SERVICETYPE" }, - { config_parse_service_restart, "SERVICERESTART" }, -#ifdef HAVE_SYSV_COMPAT - { config_parse_sysv_priority, "SYSVPRIORITY" }, -#else - { config_parse_warn_compat, "NOTSUPPORTED" }, -#endif - { config_parse_kill_mode, "KILLMODE" }, - { config_parse_kill_signal, "SIGNAL" }, - { config_parse_listen, "SOCKET [...]" }, - { config_parse_socket_bind, "SOCKETBIND" }, - { config_parse_bindtodevice, "NETWORKINTERFACE" }, - { config_parse_usec, "SECONDS" }, - { config_parse_path_strv, "PATH [...]" }, - { config_parse_mount_flags, "MOUNTFLAG [...]" }, - { config_parse_string_printf, "STRING" }, - { config_parse_timer, "TIMER" }, - { config_parse_timer_unit, "NAME" }, - { config_parse_path_spec, "PATH" }, - { config_parse_path_unit, "UNIT" }, - { config_parse_notify_access, "ACCESS" }, - { config_parse_ip_tos, "TOS" }, - { config_parse_condition_path, "CONDITION" }, - { config_parse_condition_kernel, "CONDITION" }, - { config_parse_condition_null, "CONDITION" }, - }; - - assert(f); - assert(items); - - for (i = items; i->lvalue; i++) { - unsigned j; - const char *rvalue = "OTHER"; - - if (!streq_ptr(i->section, prev_section)) { - if (!not_first) - not_first = true; - else - fputc('\n', f); - - fprintf(f, "[%s]\n", i->section); - prev_section = i->section; - } - - for (j = 0; j < ELEMENTSOF(table); j++) - if (i->parse == table[j].callback) { - rvalue = table[j].rvalue; - break; - } - - fprintf(f, "%s=%s\n", i->lvalue, rvalue); - } -} - static int load_from_path(Unit *u, const char *path) { - - static const char* const section_table[_UNIT_TYPE_MAX] = { - [UNIT_SERVICE] = "Service", - [UNIT_TIMER] = "Timer", - [UNIT_SOCKET] = "Socket", - [UNIT_TARGET] = "Target", - [UNIT_DEVICE] = "Device", - [UNIT_MOUNT] = "Mount", - [UNIT_AUTOMOUNT] = "Automount", - [UNIT_SNAPSHOT] = "Snapshot", - [UNIT_SWAP] = "Swap", - [UNIT_PATH] = "Path" - }; - -#define EXEC_CONTEXT_CONFIG_ITEMS(context, section) \ - { "WorkingDirectory", config_parse_path, &(context).working_directory, section }, \ - { "RootDirectory", config_parse_path, &(context).root_directory, section }, \ - { "User", config_parse_string_printf, &(context).user, section }, \ - { "Group", config_parse_string_printf, &(context).group, section }, \ - { "SupplementaryGroups", config_parse_strv, &(context).supplementary_groups, section }, \ - { "Nice", config_parse_nice, &(context), section }, \ - { "OOMScoreAdjust", config_parse_oom_score_adjust,&(context), section }, \ - { "IOSchedulingClass", config_parse_io_class, &(context), section }, \ - { "IOSchedulingPriority", config_parse_io_priority, &(context), section }, \ - { "CPUSchedulingPolicy", config_parse_cpu_sched_policy,&(context), section }, \ - { "CPUSchedulingPriority", config_parse_cpu_sched_prio, &(context), section }, \ - { "CPUSchedulingResetOnFork", config_parse_bool, &(context).cpu_sched_reset_on_fork, section }, \ - { "CPUAffinity", config_parse_cpu_affinity, &(context), section }, \ - { "UMask", config_parse_mode, &(context).umask, section }, \ - { "Environment", config_parse_strv, &(context).environment, section }, \ - { "EnvironmentFile", config_parse_env_file, &(context).environment, section }, \ - { "StandardInput", config_parse_input, &(context).std_input, section }, \ - { "StandardOutput", config_parse_output, &(context).std_output, section }, \ - { "StandardError", config_parse_output, &(context).std_error, section }, \ - { "TTYPath", config_parse_path, &(context).tty_path, section }, \ - { "SyslogIdentifier", config_parse_string_printf, &(context).syslog_identifier, section }, \ - { "SyslogFacility", config_parse_facility, &(context).syslog_priority, section }, \ - { "SyslogLevel", config_parse_level, &(context).syslog_priority, section }, \ - { "SyslogLevelPrefix", config_parse_bool, &(context).syslog_level_prefix, section }, \ - { "Capabilities", config_parse_capabilities, &(context), section }, \ - { "SecureBits", config_parse_secure_bits, &(context), section }, \ - { "CapabilityBoundingSetDrop", config_parse_bounding_set, &(context), section }, \ - { "TimerSlackNSec", config_parse_timer_slack_nsec,&(context), section }, \ - { "LimitCPU", config_parse_limit, &(context).rlimit[RLIMIT_CPU], section }, \ - { "LimitFSIZE", config_parse_limit, &(context).rlimit[RLIMIT_FSIZE], section }, \ - { "LimitDATA", config_parse_limit, &(context).rlimit[RLIMIT_DATA], section }, \ - { "LimitSTACK", config_parse_limit, &(context).rlimit[RLIMIT_STACK], section }, \ - { "LimitCORE", config_parse_limit, &(context).rlimit[RLIMIT_CORE], section }, \ - { "LimitRSS", config_parse_limit, &(context).rlimit[RLIMIT_RSS], section }, \ - { "LimitNOFILE", config_parse_limit, &(context).rlimit[RLIMIT_NOFILE], section }, \ - { "LimitAS", config_parse_limit, &(context).rlimit[RLIMIT_AS], section }, \ - { "LimitNPROC", config_parse_limit, &(context).rlimit[RLIMIT_NPROC], section }, \ - { "LimitMEMLOCK", config_parse_limit, &(context).rlimit[RLIMIT_MEMLOCK], section }, \ - { "LimitLOCKS", config_parse_limit, &(context).rlimit[RLIMIT_LOCKS], section }, \ - { "LimitSIGPENDING", config_parse_limit, &(context).rlimit[RLIMIT_SIGPENDING], section }, \ - { "LimitMSGQUEUE", config_parse_limit, &(context).rlimit[RLIMIT_MSGQUEUE], section }, \ - { "LimitNICE", config_parse_limit, &(context).rlimit[RLIMIT_NICE], section }, \ - { "LimitRTPRIO", config_parse_limit, &(context).rlimit[RLIMIT_RTPRIO], section }, \ - { "LimitRTTIME", config_parse_limit, &(context).rlimit[RLIMIT_RTTIME], section }, \ - { "ControlGroup", config_parse_cgroup, u, section }, \ - { "ReadWriteDirectories", config_parse_path_strv, &(context).read_write_dirs, section }, \ - { "ReadOnlyDirectories", config_parse_path_strv, &(context).read_only_dirs, section }, \ - { "InaccessibleDirectories",config_parse_path_strv, &(context).inaccessible_dirs, section }, \ - { "PrivateTmp", config_parse_bool, &(context).private_tmp, section }, \ - { "MountFlags", config_parse_mount_flags, &(context), section }, \ - { "TCPWrapName", config_parse_string_printf, &(context).tcpwrap_name, section }, \ - { "PAMName", config_parse_string_printf, &(context).pam_name, section }, \ - { "KillMode", config_parse_kill_mode, &(context).kill_mode, section }, \ - { "KillSignal", config_parse_kill_signal, &(context).kill_signal, section }, \ - { "UtmpIdentifier", config_parse_string_printf, &(context).utmp_id, section } - - const ConfigItem items[] = { - { "Names", config_parse_names, u, "Unit" }, - { "Description", config_parse_string_printf, &u->meta.description, "Unit" }, - { "Requires", config_parse_deps, UINT_TO_PTR(UNIT_REQUIRES), "Unit" }, - { "RequiresOverridable", config_parse_deps, UINT_TO_PTR(UNIT_REQUIRES_OVERRIDABLE), "Unit" }, - { "Requisite", config_parse_deps, UINT_TO_PTR(UNIT_REQUISITE), "Unit" }, - { "RequisiteOverridable", config_parse_deps, UINT_TO_PTR(UNIT_REQUISITE_OVERRIDABLE), "Unit" }, - { "Wants", config_parse_deps, UINT_TO_PTR(UNIT_WANTS), "Unit" }, - { "BindTo", config_parse_deps, UINT_TO_PTR(UNIT_BIND_TO), "Unit" }, - { "Conflicts", config_parse_deps, UINT_TO_PTR(UNIT_CONFLICTS), "Unit" }, - { "Before", config_parse_deps, UINT_TO_PTR(UNIT_BEFORE), "Unit" }, - { "After", config_parse_deps, UINT_TO_PTR(UNIT_AFTER), "Unit" }, - { "OnFailure", config_parse_deps, UINT_TO_PTR(UNIT_ON_FAILURE), "Unit" }, - { "StopWhenUnneeded", config_parse_bool, &u->meta.stop_when_unneeded, "Unit" }, - { "RefuseManualStart", config_parse_bool, &u->meta.refuse_manual_start, "Unit" }, - { "RefuseManualStop", config_parse_bool, &u->meta.refuse_manual_stop, "Unit" }, - { "AllowIsolate", config_parse_bool, &u->meta.allow_isolate, "Unit" }, - { "DefaultDependencies", config_parse_bool, &u->meta.default_dependencies, "Unit" }, - { "JobTimeoutSec", config_parse_usec, &u->meta.job_timeout, "Unit" }, - { "ConditionPathExists", config_parse_condition_path, u, "Unit" }, - { "ConditionKernelCommandLine", config_parse_condition_kernel, u, "Unit" }, - { "ConditionNull", config_parse_condition_null, u, "Unit" }, - - { "PIDFile", config_parse_path, &u->service.pid_file, "Service" }, - { "ExecStartPre", config_parse_exec, u->service.exec_command+SERVICE_EXEC_START_PRE, "Service" }, - { "ExecStart", config_parse_exec, u->service.exec_command+SERVICE_EXEC_START, "Service" }, - { "ExecStartPost", config_parse_exec, u->service.exec_command+SERVICE_EXEC_START_POST, "Service" }, - { "ExecReload", config_parse_exec, u->service.exec_command+SERVICE_EXEC_RELOAD, "Service" }, - { "ExecStop", config_parse_exec, u->service.exec_command+SERVICE_EXEC_STOP, "Service" }, - { "ExecStopPost", config_parse_exec, u->service.exec_command+SERVICE_EXEC_STOP_POST, "Service" }, - { "RestartSec", config_parse_usec, &u->service.restart_usec, "Service" }, - { "TimeoutSec", config_parse_usec, &u->service.timeout_usec, "Service" }, - { "Type", config_parse_service_type, &u->service.type, "Service" }, - { "Restart", config_parse_service_restart, &u->service.restart, "Service" }, - { "PermissionsStartOnly", config_parse_bool, &u->service.permissions_start_only, "Service" }, - { "RootDirectoryStartOnly", config_parse_bool, &u->service.root_directory_start_only, "Service" }, - { "RemainAfterExit", config_parse_bool, &u->service.remain_after_exit, "Service" }, -#ifdef HAVE_SYSV_COMPAT - { "SysVStartPriority", config_parse_sysv_priority, &u->service.sysv_start_priority, "Service" }, -#else - { "SysVStartPriority", config_parse_warn_compat, NULL, "Service" }, -#endif - { "NonBlocking", config_parse_bool, &u->service.exec_context.non_blocking, "Service" }, - { "BusName", config_parse_string_printf, &u->service.bus_name, "Service" }, - { "NotifyAccess", config_parse_notify_access, &u->service.notify_access, "Service" }, - { "Sockets", config_parse_service_sockets, &u->service, "Service" }, - { "FsckPassNo", config_parse_fsck_passno, &u->service.fsck_passno, "Service" }, - EXEC_CONTEXT_CONFIG_ITEMS(u->service.exec_context, "Service"), - - { "ListenStream", config_parse_listen, &u->socket, "Socket" }, - { "ListenDatagram", config_parse_listen, &u->socket, "Socket" }, - { "ListenSequentialPacket", config_parse_listen, &u->socket, "Socket" }, - { "ListenFIFO", config_parse_listen, &u->socket, "Socket" }, - { "BindIPv6Only", config_parse_socket_bind, &u->socket, "Socket" }, - { "Backlog", config_parse_unsigned, &u->socket.backlog, "Socket" }, - { "BindToDevice", config_parse_bindtodevice, &u->socket, "Socket" }, - { "ExecStartPre", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_START_PRE, "Socket" }, - { "ExecStartPost", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_START_POST, "Socket" }, - { "ExecStopPre", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_STOP_PRE, "Socket" }, - { "ExecStopPost", config_parse_exec, u->socket.exec_command+SOCKET_EXEC_STOP_POST, "Socket" }, - { "TimeoutSec", config_parse_usec, &u->socket.timeout_usec, "Socket" }, - { "DirectoryMode", config_parse_mode, &u->socket.directory_mode, "Socket" }, - { "SocketMode", config_parse_mode, &u->socket.socket_mode, "Socket" }, - { "Accept", config_parse_bool, &u->socket.accept, "Socket" }, - { "MaxConnections", config_parse_unsigned, &u->socket.max_connections, "Socket" }, - { "KeepAlive", config_parse_bool, &u->socket.keep_alive, "Socket" }, - { "Priority", config_parse_int, &u->socket.priority, "Socket" }, - { "ReceiveBuffer", config_parse_size, &u->socket.receive_buffer, "Socket" }, - { "SendBuffer", config_parse_size, &u->socket.send_buffer, "Socket" }, - { "IPTOS", config_parse_ip_tos, &u->socket.ip_tos, "Socket" }, - { "IPTTL", config_parse_int, &u->socket.ip_ttl, "Socket" }, - { "Mark", config_parse_int, &u->socket.mark, "Socket" }, - { "PipeSize", config_parse_size, &u->socket.pipe_size, "Socket" }, - { "FreeBind", config_parse_bool, &u->socket.free_bind, "Socket" }, - { "TCPCongestion", config_parse_string, &u->socket.tcp_congestion, "Socket" }, - { "Service", config_parse_socket_service, &u->socket, "Socket" }, - EXEC_CONTEXT_CONFIG_ITEMS(u->socket.exec_context, "Socket"), - - { "What", config_parse_string, &u->mount.parameters_fragment.what, "Mount" }, - { "Where", config_parse_path, &u->mount.where, "Mount" }, - { "Options", config_parse_string, &u->mount.parameters_fragment.options, "Mount" }, - { "Type", config_parse_string, &u->mount.parameters_fragment.fstype, "Mount" }, - { "TimeoutSec", config_parse_usec, &u->mount.timeout_usec, "Mount" }, - { "DirectoryMode", config_parse_mode, &u->mount.directory_mode, "Mount" }, - EXEC_CONTEXT_CONFIG_ITEMS(u->mount.exec_context, "Mount"), - - { "Where", config_parse_path, &u->automount.where, "Automount" }, - { "DirectoryMode", config_parse_mode, &u->automount.directory_mode, "Automount" }, - - { "What", config_parse_path, &u->swap.parameters_fragment.what, "Swap" }, - { "Priority", config_parse_int, &u->swap.parameters_fragment.priority, "Swap" }, - - { "OnActiveSec", config_parse_timer, &u->timer, "Timer" }, - { "OnBootSec", config_parse_timer, &u->timer, "Timer" }, - { "OnStartupSec", config_parse_timer, &u->timer, "Timer" }, - { "OnUnitActiveSec", config_parse_timer, &u->timer, "Timer" }, - { "OnUnitInactiveSec", config_parse_timer, &u->timer, "Timer" }, - { "Unit", config_parse_timer_unit, &u->timer, "Timer" }, - - { "PathExists", config_parse_path_spec, &u->path, "Path" }, - { "PathChanged", config_parse_path_spec, &u->path, "Path" }, - { "DirectoryNotEmpty", config_parse_path_spec, &u->path, "Path" }, - { "Unit", config_parse_path_unit, &u->path, "Path" }, - - /* The [Install] section is ignored here. */ - { "Alias", NULL, NULL, "Install" }, - { "WantedBy", NULL, NULL, "Install" }, - { "Also", NULL, NULL, "Install" }, - - { NULL, NULL, NULL, NULL } - }; - -#undef EXEC_CONTEXT_CONFIG_ITEMS - - const char *sections[4]; int r; Set *symlink_names; FILE *f = NULL; @@ -1917,21 +2138,11 @@ static int load_from_path(Unit *u, const char *path) { Unit *merged; struct stat st; - if (!u) { - /* Dirty dirty hack. */ - dump_items((FILE*) path, items); - return 0; - } - assert(u); assert(path); - sections[0] = "Unit"; - sections[1] = section_table[u->meta.type]; - sections[2] = "Install"; - sections[3] = NULL; - - if (!(symlink_names = set_new(string_hash_func, string_compare_func))) + symlink_names = set_new(string_hash_func, string_compare_func); + if (!symlink_names) return -ENOMEM; if (path_is_absolute(path)) { @@ -1952,7 +2163,7 @@ static int load_from_path(Unit *u, const char *path) { } else { char **p; - STRV_FOREACH(p, u->meta.manager->lookup_paths.unit_path) { + STRV_FOREACH(p, u->manager->lookup_paths.unit_path) { /* Instead of opening the path right away, we manually * follow all symlinks and add their name to our unit @@ -1962,8 +2173,8 @@ static int load_from_path(Unit *u, const char *path) { goto finish; } - if (u->meta.manager->unit_path_cache && - !set_get(u->meta.manager->unit_path_cache, filename)) + if (u->manager->unit_path_cache && + !set_get(u->manager->unit_path_cache, filename)) r = -ENOENT; else r = open_follow(&filename, &f, symlink_names, &id); @@ -1999,7 +2210,7 @@ static int load_from_path(Unit *u, const char *path) { goto finish; if (merged != u) { - u->meta.load_state = UNIT_MERGED; + u->load_state = UNIT_MERGED; r = 0; goto finish; } @@ -2011,20 +2222,21 @@ static int load_from_path(Unit *u, const char *path) { } if (null_or_empty(&st)) - u->meta.load_state = UNIT_MASKED; + u->load_state = UNIT_MASKED; else { /* Now, parse the file contents */ - if ((r = config_parse(filename, f, sections, items, false, u)) < 0) + r = config_parse(filename, f, UNIT_VTABLE(u)->sections, config_item_perf_lookup, (void*) load_fragment_gperf_lookup, false, u); + if (r < 0) goto finish; - u->meta.load_state = UNIT_LOADED; + u->load_state = UNIT_LOADED; } - free(u->meta.fragment_path); - u->meta.fragment_path = filename; + free(u->fragment_path); + u->fragment_path = filename; filename = NULL; - u->meta.fragment_mtime = timespec_load(&st.st_mtim); + u->fragment_mtime = timespec_load(&st.st_mtim); r = 0; @@ -2044,49 +2256,49 @@ int unit_load_fragment(Unit *u) { const char *t; assert(u); - assert(u->meta.load_state == UNIT_STUB); - assert(u->meta.id); + assert(u->load_state == UNIT_STUB); + assert(u->id); /* First, try to find the unit under its id. We always look * for unit files in the default directories, to make it easy * to override things by placing things in /etc/systemd/system */ - if ((r = load_from_path(u, u->meta.id)) < 0) + if ((r = load_from_path(u, u->id)) < 0) return r; /* Try to find an alias we can load this with */ - if (u->meta.load_state == UNIT_STUB) - SET_FOREACH(t, u->meta.names, i) { + if (u->load_state == UNIT_STUB) + SET_FOREACH(t, u->names, i) { - if (t == u->meta.id) + if (t == u->id) continue; if ((r = load_from_path(u, t)) < 0) return r; - if (u->meta.load_state != UNIT_STUB) + if (u->load_state != UNIT_STUB) break; } /* And now, try looking for it under the suggested (originally linked) path */ - if (u->meta.load_state == UNIT_STUB && u->meta.fragment_path) { + if (u->load_state == UNIT_STUB && u->fragment_path) { - if ((r = load_from_path(u, u->meta.fragment_path)) < 0) + if ((r = load_from_path(u, u->fragment_path)) < 0) return r; - if (u->meta.load_state == UNIT_STUB) { + if (u->load_state == UNIT_STUB) { /* Hmm, this didn't work? Then let's get rid * of the fragment path stored for us, so that * we don't point to an invalid location. */ - free(u->meta.fragment_path); - u->meta.fragment_path = NULL; + free(u->fragment_path); + u->fragment_path = NULL; } } /* Look for a template */ - if (u->meta.load_state == UNIT_STUB && u->meta.instance) { + if (u->load_state == UNIT_STUB && u->instance) { char *k; - if (!(k = unit_name_template(u->meta.id))) + if (!(k = unit_name_template(u->id))) return -ENOMEM; r = load_from_path(u, k); @@ -2095,10 +2307,10 @@ int unit_load_fragment(Unit *u) { if (r < 0) return r; - if (u->meta.load_state == UNIT_STUB) - SET_FOREACH(t, u->meta.names, i) { + if (u->load_state == UNIT_STUB) + SET_FOREACH(t, u->names, i) { - if (t == u->meta.id) + if (t == u->id) continue; if (!(k = unit_name_template(t))) @@ -2110,7 +2322,7 @@ int unit_load_fragment(Unit *u) { if (r < 0) return r; - if (u->meta.load_state != UNIT_STUB) + if (u->load_state != UNIT_STUB) break; } } @@ -2119,7 +2331,100 @@ int unit_load_fragment(Unit *u) { } void unit_dump_config_items(FILE *f) { - /* OK, this wins a prize for extreme ugliness. */ + static const struct { + const ConfigParserCallback callback; + const char *rvalue; + } table[] = { + { config_parse_int, "INTEGER" }, + { config_parse_unsigned, "UNSIGNED" }, + { config_parse_size, "SIZE" }, + { config_parse_bool, "BOOLEAN" }, + { config_parse_string, "STRING" }, + { config_parse_path, "PATH" }, + { config_parse_unit_path_printf, "PATH" }, + { config_parse_strv, "STRING [...]" }, + { config_parse_exec_nice, "NICE" }, + { config_parse_exec_oom_score_adjust, "OOMSCOREADJUST" }, + { config_parse_exec_io_class, "IOCLASS" }, + { config_parse_exec_io_priority, "IOPRIORITY" }, + { config_parse_exec_cpu_sched_policy, "CPUSCHEDPOLICY" }, + { config_parse_exec_cpu_sched_prio, "CPUSCHEDPRIO" }, + { config_parse_exec_cpu_affinity, "CPUAFFINITY" }, + { config_parse_mode, "MODE" }, + { config_parse_unit_env_file, "FILE" }, + { config_parse_output, "OUTPUT" }, + { config_parse_input, "INPUT" }, + { config_parse_facility, "FACILITY" }, + { config_parse_level, "LEVEL" }, + { config_parse_exec_capabilities, "CAPABILITIES" }, + { config_parse_exec_secure_bits, "SECUREBITS" }, + { config_parse_exec_bounding_set, "BOUNDINGSET" }, + { config_parse_exec_timer_slack_nsec, "TIMERSLACK" }, + { config_parse_limit, "LIMIT" }, + { config_parse_unit_cgroup, "CGROUP [...]" }, + { config_parse_unit_deps, "UNIT [...]" }, + { config_parse_unit_names, "UNIT [...]" }, + { config_parse_exec, "PATH [ARGUMENT [...]]" }, + { config_parse_service_type, "SERVICETYPE" }, + { config_parse_service_restart, "SERVICERESTART" }, +#ifdef HAVE_SYSV_COMPAT + { config_parse_sysv_priority, "SYSVPRIORITY" }, +#else + { config_parse_warn_compat, "NOTSUPPORTED" }, +#endif + { config_parse_kill_mode, "KILLMODE" }, + { config_parse_kill_signal, "SIGNAL" }, + { config_parse_socket_listen, "SOCKET [...]" }, + { config_parse_socket_bind, "SOCKETBIND" }, + { config_parse_socket_bindtodevice, "NETWORKINTERFACE" }, + { config_parse_usec, "SECONDS" }, + { config_parse_path_strv, "PATH [...]" }, + { config_parse_exec_mount_flags, "MOUNTFLAG [...]" }, + { config_parse_unit_string_printf, "STRING" }, + { config_parse_timer, "TIMER" }, + { config_parse_timer_unit, "NAME" }, + { config_parse_path_spec, "PATH" }, + { config_parse_path_unit, "UNIT" }, + { config_parse_notify_access, "ACCESS" }, + { config_parse_ip_tos, "TOS" }, + { config_parse_unit_condition_path, "CONDITION" }, + { config_parse_unit_condition_string, "CONDITION" }, + { config_parse_unit_condition_null, "CONDITION" }, + }; + + const char *prev = NULL; + const char *i; - load_from_path(NULL, (const void*) f); + assert(f); + + NULSTR_FOREACH(i, load_fragment_gperf_nulstr) { + const char *rvalue = "OTHER", *lvalue; + unsigned j; + size_t prefix_len; + const char *dot; + const ConfigPerfItem *p; + + assert_se(p = load_fragment_gperf_lookup(i, strlen(i))); + + dot = strchr(i, '.'); + lvalue = dot ? dot + 1 : i; + prefix_len = dot-i; + + if (dot) + if (!prev || strncmp(prev, i, prefix_len+1) != 0) { + if (prev) + fputc('\n', f); + + fprintf(f, "[%.*s]\n", (int) prefix_len, i); + } + + for (j = 0; j < ELEMENTSOF(table); j++) + if (p->parse == table[j].callback) { + rvalue = table[j].rvalue; + break; + } + + fprintf(f, "%s=%s\n", lvalue, rvalue); + prev = i; + } }