static char **arg_states = NULL;
static char **arg_properties = NULL;
static bool arg_all = false;
-static bool original_stdout_is_tty;
static enum dependency {
DEPENDENCY_FORWARD,
DEPENDENCY_REVERSE,
static bool arg_dry = false;
static bool arg_quiet = false;
static bool arg_full = false;
+static bool arg_recursive = false;
static int arg_force = 0;
static bool arg_ask_password = true;
static bool arg_runtime = false;
static unsigned arg_lines = 10;
static OutputMode arg_output = OUTPUT_SHORT;
static bool arg_plain = false;
+
static const struct {
const char *verb;
const char *method;
{ "force-reload", "ReloadOrTryRestartUnit" }
};
+static bool original_stdout_is_tty;
+
static int daemon_reload(sd_bus *bus, char **args);
static int halt_now(enum action a);
-
static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet);
static char** strv_skip_first(char **strv) {
}
if (*p) {
- utmp_wall(p, NULL);
+ utmp_wall(p, NULL, NULL);
return;
}
}
if (!table[a])
return;
- utmp_wall(table[a], NULL);
+ utmp_wall(table[a], NULL, NULL);
}
static bool avoid_bus(void) {
static int compare_unit_info(const void *a, const void *b) {
const UnitInfo *u = a, *v = b;
const char *d1, *d2;
+ int r;
+
+ /* First, order by machine */
+ if (!u->machine && v->machine)
+ return -1;
+ if (u->machine && !v->machine)
+ return 1;
+ if (u->machine && v->machine) {
+ r = strcasecmp(u->machine, v->machine);
+ if (r != 0)
+ return r;
+ }
+ /* Second, order by unit type */
d1 = strrchr(u->id, '.');
d2 = strrchr(v->id, '.');
-
if (d1 && d2) {
- int r;
-
r = strcasecmp(d1, d2);
if (r != 0)
return r;
}
+ /* Third, order by name */
return strcasecmp(u->id, v->id);
}
static bool output_show_unit(const UnitInfo *u, char **patterns) {
const char *dot;
- if (!strv_isempty(arg_states))
- return
- strv_contains(arg_states, u->load_state) ||
- strv_contains(arg_states, u->sub_state) ||
- strv_contains(arg_states, u->active_state);
-
if (!strv_isempty(patterns)) {
char **pattern;
|| u->following[0]) || u->job_id > 0);
}
-static void output_units_list(const UnitInfo *unit_infos, unsigned c) {
- unsigned id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;
+static int output_units_list(const UnitInfo *unit_infos, unsigned c) {
+ unsigned circle_len = 0, id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;
const UnitInfo *u;
unsigned n_shown = 0;
int job_count = 0;
- max_id_len = sizeof("UNIT")-1;
- load_len = sizeof("LOAD")-1;
- active_len = sizeof("ACTIVE")-1;
- sub_len = sizeof("SUB")-1;
- job_len = sizeof("JOB")-1;
+ max_id_len = strlen("UNIT");
+ load_len = strlen("LOAD");
+ active_len = strlen("ACTIVE");
+ sub_len = strlen("SUB");
+ job_len = strlen("JOB");
desc_len = 0;
for (u = unit_infos; u < unit_infos + c; u++) {
- max_id_len = MAX(max_id_len, strlen(u->id));
+ max_id_len = MAX(max_id_len, strlen(u->id) + (u->machine ? strlen(u->machine)+1 : 0));
load_len = MAX(load_len, strlen(u->load_state));
active_len = MAX(active_len, strlen(u->active_state));
sub_len = MAX(sub_len, strlen(u->sub_state));
job_len = MAX(job_len, strlen(u->job_type));
job_count++;
}
+
+ if (!arg_no_legend &&
+ (streq(u->active_state, "failed") ||
+ STR_IN_SET(u->load_state, "error", "not-found", "masked")))
+ circle_len = 2;
}
if (!arg_full && original_stdout_is_tty) {
unsigned basic_len;
id_len = MIN(max_id_len, 25u);
- basic_len = 5 + id_len + 5 + active_len + sub_len;
+ basic_len = circle_len + 5 + id_len + 5 + active_len + sub_len;
if (job_count)
basic_len += job_len + 1;
id_len = max_id_len;
for (u = unit_infos; u < unit_infos + c; u++) {
- _cleanup_free_ char *e = NULL;
- const char *on_loaded, *off_loaded, *on = "";
- const char *on_active, *off_active, *off = "";
+ _cleanup_free_ char *e = NULL, *j = NULL;
+ const char *on_loaded = "", *off_loaded = "";
+ const char *on_active = "", *off_active = "";
+ const char *on_circle = "", *off_circle = "";
+ const char *id;
+ bool circle = false;
if (!n_shown && !arg_no_legend) {
+
+ if (circle_len > 0)
+ fputs(" ", stdout);
+
printf("%-*s %-*s %-*s %-*s ",
id_len, "UNIT",
load_len, "LOAD",
n_shown++;
- if (streq(u->load_state, "error") ||
- streq(u->load_state, "not-found")) {
- on_loaded = on = ansi_highlight_red();
- off_loaded = off = ansi_highlight_off();
- } else
- on_loaded = off_loaded = "";
+ if (STR_IN_SET(u->load_state, "error", "not-found", "masked")) {
+ on_loaded = ansi_highlight_red();
+ on_circle = ansi_highlight_yellow();
+ off_loaded = off_circle = ansi_highlight_off();
+ circle = true;
+ }
if (streq(u->active_state, "failed")) {
- on_active = on = ansi_highlight_red();
- off_active = off = ansi_highlight_off();
+ on_circle = on_active = ansi_highlight_red();
+ off_circle = off_active = ansi_highlight_off();
+ circle = true;
+ }
+
+ if (u->machine) {
+ j = strjoin(u->machine, ":", u->id, NULL);
+ if (!j)
+ return log_oom();
+
+ id = j;
} else
- on_active = off_active = "";
+ id = u->id;
+
+ if (arg_full) {
+ e = ellipsize(id, id_len, 33);
+ if (!e)
+ return log_oom();
+
+ id = e;
+ }
- e = arg_full ? NULL : ellipsize(u->id, id_len, 33);
+ if (circle_len > 0)
+ printf("%s%s%s", on_circle, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_circle);
printf("%s%-*s%s %s%-*s%s %s%-*s %-*s%s %-*s",
- on, id_len, e ? e : u->id, off,
+ on_active, id_len, id, off_active,
on_loaded, load_len, u->load_state, off_loaded,
on_active, active_len, u->active_state,
sub_len, u->sub_state, off_active,
const char *on, *off;
if (n_shown) {
- puts("\nLOAD = Reflects whether the unit definition was properly loaded.\n"
+ puts("\n"
+ "LOAD = Reflects whether the unit definition was properly loaded.\n"
"ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
"SUB = The low-level unit activation state, values depend on unit type.");
puts(job_count ? "JOB = Pending job for the unit.\n" : "");
"To show all installed unit files use 'systemctl list-unit-files'.\n",
on, n_shown, off);
}
+
+ return 0;
}
static int get_unit_list(
sd_bus *bus,
- sd_bus_message **_reply,
- UnitInfo **_unit_infos,
- char **patterns) {
+ const char *machine,
+ char **patterns,
+ UnitInfo **unit_infos,
+ int c,
+ sd_bus_message **_reply) {
+ _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
- _cleanup_free_ UnitInfo *unit_infos = NULL;
- size_t size = 0;
- int r, c = 0;
+ size_t size = c;
+ int r;
UnitInfo u;
assert(bus);
+ assert(unit_infos);
assert(_reply);
- assert(_unit_infos);
- r = sd_bus_call_method(
+ r = sd_bus_message_new_method_call(
bus,
+ &m,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
- "ListUnits",
- &error,
- &reply,
- NULL);
+ "ListUnitsFiltered");
+
+ if (r < 0)
+ return bus_log_create_error(r);
+
+ r = sd_bus_message_append_strv(m, arg_states);
+ if (r < 0)
+ return bus_log_create_error(r);
+
+ r = sd_bus_call(bus, m, 0, &error, &reply);
if (r < 0) {
log_error("Failed to list units: %s", bus_error_message(&error, r));
return r;
return bus_log_parse_error(r);
while ((r = bus_parse_unit_info(reply, &u)) > 0) {
+ u.machine = machine;
+
if (!output_show_unit(&u, patterns))
continue;
- if (!GREEDY_REALLOC(unit_infos, size, c+1))
+ if (!GREEDY_REALLOC(*unit_infos, size, c+1))
return log_oom();
- unit_infos[c++] = u;
+ (*unit_infos)[c++] = u;
}
if (r < 0)
return bus_log_parse_error(r);
*_reply = reply;
reply = NULL;
+ return c;
+}
+
+static void message_set_freep(Set **set) {
+ sd_bus_message *m;
+
+ while ((m = set_steal_first(*set)))
+ sd_bus_message_unref(m);
+
+ set_free(*set);
+}
+
+static int get_unit_list_recursive(
+ sd_bus *bus,
+ char **patterns,
+ UnitInfo **_unit_infos,
+ Set **_replies,
+ char ***_machines) {
+
+ _cleanup_free_ UnitInfo *unit_infos = NULL;
+ _cleanup_(message_set_freep) Set *replies;
+ sd_bus_message *reply;
+ int c, r;
+
+ assert(bus);
+ assert(_replies);
+ assert(_unit_infos);
+ assert(_machines);
+
+ replies = set_new(NULL, NULL);
+ if (!replies)
+ return log_oom();
+
+ c = get_unit_list(bus, NULL, patterns, &unit_infos, 0, &reply);
+ if (c < 0)
+ return c;
+
+ r = set_put(replies, reply);
+ if (r < 0) {
+ sd_bus_message_unref(reply);
+ return r;
+ }
+
+ if (arg_recursive) {
+ _cleanup_strv_free_ char **machines = NULL;
+ char **i;
+
+ r = sd_get_machine_names(&machines);
+ if (r < 0)
+ return r;
+
+ STRV_FOREACH(i, machines) {
+ _cleanup_bus_unref_ sd_bus *container = NULL;
+ int k;
+
+ r = sd_bus_open_system_container(&container, *i);
+ if (r < 0) {
+ log_error("Failed to connect to container %s: %s", *i, strerror(-r));
+ continue;
+ }
+
+ k = get_unit_list(container, *i, patterns, &unit_infos, c, &reply);
+ if (k < 0)
+ return k;
+
+ c = k;
+
+ r = set_put(replies, reply);
+ if (r < 0) {
+ sd_bus_message_unref(reply);
+ return r;
+ }
+ }
+
+ *_machines = machines;
+ machines = NULL;
+ } else
+ *_machines = NULL;
+
*_unit_infos = unit_infos;
unit_infos = NULL;
+ *_replies = replies;
+ replies = NULL;
+
return c;
}
static int list_units(sd_bus *bus, char **args) {
- _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_free_ UnitInfo *unit_infos = NULL;
+ _cleanup_(message_set_freep) Set *replies = NULL;
+ _cleanup_strv_free_ char **machines = NULL;
int r;
pager_open_if_enabled();
- r = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
+ r = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
if (r < 0)
return r;
qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);
- output_units_list(unit_infos, r);
-
- return 0;
+ return output_units_list(unit_infos, r);
}
static int get_triggered_units(
}
struct socket_info {
+ const char *machine;
const char* id;
char* type;
assert(a);
assert(b);
+ if (!a->machine && b->machine)
+ return -1;
+ if (a->machine && !b->machine)
+ return 1;
+ if (a->machine && b->machine) {
+ o = strcasecmp(a->machine, b->machine);
+ if (o != 0)
+ return o;
+ }
+
o = strcmp(a->path, b->path);
if (o == 0)
o = strcmp(a->type, b->type);
static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {
struct socket_info *s;
- unsigned pathlen = sizeof("LISTEN") - 1,
- typelen = (sizeof("TYPE") - 1) * arg_show_types,
- socklen = sizeof("UNIT") - 1,
- servlen = sizeof("ACTIVATES") - 1;
+ unsigned pathlen = strlen("LISTEN"),
+ typelen = strlen("TYPE") * arg_show_types,
+ socklen = strlen("UNIT"),
+ servlen = strlen("ACTIVATES");
const char *on, *off;
for (s = socket_infos; s < socket_infos + cs; s++) {
socklen = MAX(socklen, strlen(s->id));
if (arg_show_types)
typelen = MAX(typelen, strlen(s->type));
- pathlen = MAX(pathlen, strlen(s->path));
+ pathlen = MAX(pathlen, strlen(s->path) + (s->machine ? strlen(s->machine)+1 : 0));
STRV_FOREACH(a, s->triggered)
tmp += strlen(*a) + 2*(a != s->triggered);
"ACTIVATES");
for (s = socket_infos; s < socket_infos + cs; s++) {
+ _cleanup_free_ char *j = NULL;
+ const char *path;
char **a;
+ if (s->machine) {
+ j = strjoin(s->machine, ":", s->path, NULL);
+ if (!j)
+ return log_oom();
+ path = j;
+ } else
+ path = s->path;
+
if (arg_show_types)
printf("%-*s %-*s %-*s",
- pathlen, s->path, typelen, s->type, socklen, s->id);
+ pathlen, path, typelen, s->type, socklen, s->id);
else
printf("%-*s %-*s",
- pathlen, s->path, socklen, s->id);
+ pathlen, path, socklen, s->id);
STRV_FOREACH(a, s->triggered)
printf("%s %s",
a == s->triggered ? "" : ",", *a);
}
static int list_sockets(sd_bus *bus, char **args) {
- _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ _cleanup_(message_set_freep) Set *replies = NULL;
+ _cleanup_strv_free_ char **machines = NULL;
_cleanup_free_ UnitInfo *unit_infos = NULL;
_cleanup_free_ struct socket_info *socket_infos = NULL;
const UnitInfo *u;
pager_open_if_enabled();
- n = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
+ n = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
if (n < 0)
return n;
for (i = 0; i < c; i++)
socket_infos[cs + i] = (struct socket_info) {
+ .machine = u->machine,
.id = u->id,
.type = listening[i*2],
.path = listening[i*2 + 1],
return 0;
}
+static int get_last_trigger(
+ sd_bus *bus,
+ const char *path,
+ usec_t *last) {
+
+ _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
+ int r;
+
+ assert(bus);
+ assert(path);
+ assert(last);
+
+ r = sd_bus_get_property_trivial(
+ bus,
+ "org.freedesktop.systemd1",
+ path,
+ "org.freedesktop.systemd1.Timer",
+ "LastTriggerUSec",
+ &error,
+ 't',
+ last);
+ if (r < 0) {
+ log_error("Failed to get last trigger time: %s", bus_error_message(&error, r));
+ return r;
+ }
+
+ return 0;
+}
+
struct timer_info {
+ const char* machine;
const char* id;
usec_t next_elapse;
+ usec_t last_trigger;
char** triggered;
};
static int timer_info_compare(const struct timer_info *a, const struct timer_info *b) {
+ int o;
+
assert(a);
assert(b);
+ if (!a->machine && b->machine)
+ return -1;
+ if (a->machine && !b->machine)
+ return 1;
+ if (a->machine && b->machine) {
+ o = strcasecmp(a->machine, b->machine);
+ if (o != 0)
+ return o;
+ }
+
if (a->next_elapse < b->next_elapse)
return -1;
if (a->next_elapse > b->next_elapse)
static int output_timers_list(struct timer_info *timer_infos, unsigned n) {
struct timer_info *t;
unsigned
- nextlen = sizeof("NEXT") - 1,
- leftlen = sizeof("LEFT") - 1,
- unitlen = sizeof("UNIT") - 1,
- activatelen = sizeof("ACTIVATES") - 1;
+ nextlen = strlen("NEXT"),
+ leftlen = strlen("LEFT"),
+ lastlen = strlen("LAST"),
+ passedlen = strlen("PASSED"),
+ unitlen = strlen("UNIT"),
+ activatelen = strlen("ACTIVATES");
const char *on, *off;
leftlen = MAX(leftlen, strlen(trel));
}
- unitlen = MAX(unitlen, strlen(t->id));
+ if (t->last_trigger > 0) {
+ char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";
+
+ format_timestamp(tstamp, sizeof(tstamp), t->last_trigger);
+ lastlen = MAX(lastlen, strlen(tstamp) + 1);
+
+ format_timestamp_relative(trel, sizeof(trel), t->last_trigger);
+ passedlen = MAX(passedlen, strlen(trel));
+ }
+
+ unitlen = MAX(unitlen, strlen(t->id) + (t->machine ? strlen(t->machine)+1 : 0));
STRV_FOREACH(a, t->triggered)
ul += strlen(*a) + 2*(a != t->triggered);
+
activatelen = MAX(activatelen, ul);
}
if (n > 0) {
if (!arg_no_legend)
- printf("%-*s %-*s %-*s %s\n",
- nextlen, "NEXT",
- leftlen, "LEFT",
- unitlen, "UNIT",
- "ACTIVATES");
+ printf("%-*s %-*s %-*s %-*s %-*s %s\n",
+ nextlen, "NEXT",
+ leftlen, "LEFT",
+ lastlen, "LAST",
+ passedlen, "PASSED",
+ unitlen, "UNIT",
+ "ACTIVATES");
for (t = timer_infos; t < timer_infos + n; t++) {
- char tstamp[FORMAT_TIMESTAMP_MAX] = "n/a", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
+ _cleanup_free_ char *j = NULL;
+ const char *unit;
+ char tstamp1[FORMAT_TIMESTAMP_MAX] = "n/a", trel1[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
+ char tstamp2[FORMAT_TIMESTAMP_MAX] = "n/a", trel2[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
char **a;
- format_timestamp(tstamp, sizeof(tstamp), t->next_elapse);
- format_timestamp_relative(trel, sizeof(trel), t->next_elapse);
+ format_timestamp(tstamp1, sizeof(tstamp1), t->next_elapse);
+ format_timestamp_relative(trel1, sizeof(trel1), t->next_elapse);
- printf("%-*s %-*s %-*s",
- nextlen, tstamp, leftlen, trel, unitlen, t->id);
+ format_timestamp(tstamp2, sizeof(tstamp2), t->last_trigger);
+ format_timestamp_relative(trel2, sizeof(trel2), t->last_trigger);
+
+ if (t->machine) {
+ j = strjoin(t->machine, ":", t->id, NULL);
+ if (!j)
+ return log_oom();
+ unit = j;
+ } else
+ unit = t->id;
+
+ printf("%-*s %-*s %-*s %-*s %-*s",
+ nextlen, tstamp1, leftlen, trel1, lastlen, tstamp2, passedlen, trel2, unitlen, unit);
STRV_FOREACH(a, t->triggered)
printf("%s %s",
}
static int list_timers(sd_bus *bus, char **args) {
-
- _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
+ _cleanup_(message_set_freep) Set *replies = NULL;
+ _cleanup_strv_free_ char **machines = NULL;
_cleanup_free_ struct timer_info *timer_infos = NULL;
_cleanup_free_ UnitInfo *unit_infos = NULL;
struct timer_info *t;
pager_open_if_enabled();
- n = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
+ n = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
if (n < 0)
return n;
for (u = unit_infos; u < unit_infos + n; u++) {
_cleanup_strv_free_ char **triggered = NULL;
dual_timestamp next = {};
- usec_t m;
+ usec_t m, last = 0;
if (!endswith(u->id, ".timer"))
continue;
if (r < 0)
goto cleanup;
+ get_last_trigger(bus, u->unit_path, &last);
+
if (!GREEDY_REALLOC(timer_infos, size, c+1)) {
r = log_oom();
goto cleanup;
m = calc_next_elapse(&nw, &next);
timer_infos[c++] = (struct timer_info) {
+ .machine = u->machine,
.id = u->id,
.next_elapse = m,
+ .last_trigger = last,
.triggered = triggered,
};
}
static void output_unit_file_list(const UnitFileList *units, unsigned c) {
- unsigned max_id_len, id_cols, state_cols, n_shown = 0;
+ unsigned max_id_len, id_cols, state_cols;
const UnitFileList *u;
- max_id_len = sizeof("UNIT FILE")-1;
- state_cols = sizeof("STATE")-1;
+ max_id_len = strlen("UNIT FILE");
+ state_cols = strlen("STATE");
for (u = units; u < units + c; u++) {
max_id_len = MAX(max_id_len, strlen(basename(u->path)));
const char *on, *off;
const char *id;
- n_shown++;
-
if (u->state == UNIT_FILE_MASKED ||
u->state == UNIT_FILE_MASKED_RUNTIME ||
u->state == UNIT_FILE_DISABLED ||
}
if (!arg_no_legend)
- printf("\n%u unit files listed.\n", n_shown);
+ printf("\n%u unit files listed.\n", c);
}
static int list_unit_files(sd_bus *bus, char **args) {
printf("%s...\n",max_len % 2 ? "" : " ");
return 0;
}
- printf("%s", draw_special_char(branches & (1 << i) ? DRAW_TREE_VERT : DRAW_TREE_SPACE));
+ printf("%s", draw_special_char(branches & (1 << i) ? DRAW_TREE_VERTICAL : DRAW_TREE_SPACE));
}
len += 2;
state = check_one_unit(bus, *c, "activating\0active\0reloading\0", true);
if (state > 0)
- printf("%s%s%s", ansi_highlight_green(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
+ printf("%s%s%s ", ansi_highlight_green(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
else
- printf("%s%s%s", ansi_highlight_red(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
+ printf("%s%s%s ", ansi_highlight_red(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
r = list_dependencies_print(*c, level, branches, c[1] == NULL);
if (r < 0)
return list_dependencies_one(bus, u, 0, &units, 0);
}
+struct machine_info {
+ bool is_host;
+ char *name;
+ char *state;
+ char *control_group;
+ uint32_t n_failed_units;
+ uint32_t n_jobs;
+ usec_t timestamp;
+};
+
+static const struct bus_properties_map machine_info_property_map[] = {
+ { "SystemState", "s", NULL, offsetof(struct machine_info, state) },
+ { "NJobs", "u", NULL, offsetof(struct machine_info, n_jobs) },
+ { "NFailedUnits", "u", NULL, offsetof(struct machine_info, n_failed_units) },
+ { "ControlGroup", "s", NULL, offsetof(struct machine_info, control_group) },
+ { "UserspaceTimestamp", "t", NULL, offsetof(struct machine_info, timestamp) },
+ {}
+};
+
+static void free_machines_list(struct machine_info *machine_infos, int n) {
+ int i;
+
+ if (!machine_infos)
+ return;
+
+ for (i = 0; i < n; i++) {
+ free(machine_infos[i].name);
+ free(machine_infos[i].state);
+ free(machine_infos[i].control_group);
+ }
+
+ free(machine_infos);
+}
+
+static int compare_machine_info(const void *a, const void *b) {
+ const struct machine_info *u = a, *v = b;
+
+ if (u->is_host != v->is_host)
+ return u->is_host > v->is_host ? -1 : 1;
+
+ return strcasecmp(u->name, v->name);
+}
+
+static int get_machine_properties(sd_bus *bus, struct machine_info *mi) {
+ _cleanup_bus_unref_ sd_bus *container = NULL;
+ int r;
+
+ assert(mi);
+
+ if (!bus) {
+ r = sd_bus_open_system_container(&container, mi->name);
+ if (r < 0)
+ return r;
+
+ bus = container;
+ }
+
+ r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, mi);
+ if (r < 0)
+ return r;
+
+ return 0;
+}
+
+static bool output_show_machine(const char *name, char **patterns) {
+ char **i;
+
+ assert(name);
+
+ if (strv_isempty(patterns))
+ return true;
+
+ STRV_FOREACH(i, patterns)
+ if (fnmatch(*i, name, FNM_NOESCAPE) == 0)
+ return true;
+
+ return false;
+}
+
+static int get_machine_list(
+ sd_bus *bus,
+ struct machine_info **_machine_infos,
+ char **patterns) {
+
+ struct machine_info *machine_infos = NULL;
+ _cleanup_strv_free_ char **m = NULL;
+ _cleanup_free_ char *hn = NULL;
+ size_t sz = 0;
+ char **i;
+ int c = 0;
+
+ hn = gethostname_malloc();
+ if (!hn)
+ return log_oom();
+
+ if (output_show_machine(hn, patterns)) {
+ if (!GREEDY_REALLOC0(machine_infos, sz, c+1))
+ return log_oom();
+
+ machine_infos[c].is_host = true;
+ machine_infos[c].name = hn;
+ hn = NULL;
+
+ get_machine_properties(bus, &machine_infos[c]);
+ c++;
+ }
+
+ sd_get_machine_names(&m);
+ STRV_FOREACH(i, m) {
+ _cleanup_free_ char *class = NULL;
+
+ if (!output_show_machine(*i, patterns))
+ continue;
+
+ sd_machine_get_class(*i, &class);
+ if (!streq_ptr(class, "container"))
+ continue;
+
+ if (!GREEDY_REALLOC0(machine_infos, sz, c+1)) {
+ free_machines_list(machine_infos, c);
+ return log_oom();
+ }
+
+ machine_infos[c].is_host = false;
+ machine_infos[c].name = strdup(*i);
+ if (!machine_infos[c].name) {
+ free_machines_list(machine_infos, c);
+ return log_oom();
+ }
+
+ get_machine_properties(NULL, &machine_infos[c]);
+ c++;
+ }
+
+ *_machine_infos = machine_infos;
+ return c;
+}
+
+static void output_machines_list(struct machine_info *machine_infos, unsigned n) {
+ struct machine_info *m;
+ unsigned
+ circle_len = 0,
+ namelen = sizeof("NAME") - 1,
+ statelen = sizeof("STATE") - 1,
+ failedlen = sizeof("FAILED") - 1,
+ jobslen = sizeof("JOBS") - 1;
+
+ assert(machine_infos || n == 0);
+
+ for (m = machine_infos; m < machine_infos + n; m++) {
+ namelen = MAX(namelen, strlen(m->name) + (m->is_host ? sizeof(" (host)") - 1 : 0));
+ statelen = MAX(statelen, m->state ? strlen(m->state) : 0);
+ failedlen = MAX(failedlen, DECIMAL_STR_WIDTH(m->n_failed_units));
+ jobslen = MAX(jobslen, DECIMAL_STR_WIDTH(m->n_jobs));
+
+ if (!arg_no_legend && !streq_ptr(m->state, "running"))
+ circle_len = 2;
+ }
+
+ if (!arg_no_legend) {
+ if (circle_len > 0)
+ fputs(" ", stdout);
+
+ printf("%-*s %-*s %-*s %-*s\n",
+ namelen, "NAME",
+ statelen, "STATE",
+ failedlen, "FAILED",
+ jobslen, "JOBS");
+ }
+
+ for (m = machine_infos; m < machine_infos + n; m++) {
+ const char *on_state = "", *off_state = "";
+ const char *on_failed = "", *off_failed = "";
+ bool circle = false;
+
+ if (streq_ptr(m->state, "degraded")) {
+ on_state = ansi_highlight_red();
+ off_state = ansi_highlight_off();
+ circle = true;
+ } else if (!streq_ptr(m->state, "running")) {
+ on_state = ansi_highlight_yellow();
+ off_state = ansi_highlight_off();
+ circle = true;
+ }
+
+ if (m->n_failed_units > 0) {
+ on_failed = ansi_highlight_red();
+ off_failed = ansi_highlight_off();
+ } else
+ on_failed = off_failed = "";
+
+ if (circle_len > 0)
+ printf("%s%s%s ", on_state, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_state);
+
+ if (m->is_host)
+ printf("%-*s (host) %s%-*s%s %s%*u%s %*u\n",
+ (int) (namelen - (sizeof(" (host)")-1)), strna(m->name),
+ on_state, statelen, strna(m->state), off_state,
+ on_failed, failedlen, m->n_failed_units, off_failed,
+ jobslen, m->n_jobs);
+ else
+ printf("%-*s %s%-*s%s %s%*u%s %*u\n",
+ namelen, strna(m->name),
+ on_state, statelen, strna(m->state), off_state,
+ on_failed, failedlen, m->n_failed_units, off_failed,
+ jobslen, m->n_jobs);
+ }
+
+ if (!arg_no_legend)
+ printf("\n%u machines listed.\n", n);
+}
+
+static int list_machines(sd_bus *bus, char **args) {
+ struct machine_info *machine_infos = NULL;
+ int r;
+
+ assert(bus);
+
+ if (geteuid() != 0) {
+ log_error("Must be root.");
+ return -EPERM;
+ }
+
+ pager_open_if_enabled();
+
+ r = get_machine_list(bus, &machine_infos, strv_skip_first(args));
+ if (r < 0)
+ return r;
+
+ qsort_safe(machine_infos, r, sizeof(struct machine_info), compare_machine_info);
+ output_machines_list(machine_infos, r);
+ free_machines_list(machine_infos, r);
+
+ return 0;
+}
+
static int get_default(sd_bus *bus, char **args) {
_cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
return log_oom();
if (!bus || avoid_bus()) {
- r = unit_file_set_default(arg_scope, arg_root, unit, arg_force, &changes, &n_changes);
+ r = unit_file_set_default(arg_scope, arg_root, unit, true, &changes, &n_changes);
if (r < 0) {
log_error("Failed to set default target: %s", strerror(-r));
return r;
"SetDefaultTarget",
&error,
&reply,
- "sb", unit, arg_force);
+ "sb", unit, true);
if (r < 0) {
log_error("Failed to set default target: %s", bus_error_message(&error, -r));
return r;
if (r < 0)
return r;
- /* Try to reload if enabeld */
+ /* Try to reload if enabled */
if (!arg_no_reload)
r = daemon_reload(bus, args);
else
pager_open_if_enabled();
- id_len = sizeof("JOB")-1;
- unit_len = sizeof("UNIT")-1;
- type_len = sizeof("TYPE")-1;
- state_len = sizeof("STATE")-1;
+ id_len = strlen("JOB");
+ unit_len = strlen("UNIT");
+ type_len = strlen("TYPE");
+ state_len = strlen("STATE");
for (j = jobs; j < jobs + n; j++) {
uint32_t id = j->id;
}
static bool output_show_job(struct job_info *job, char **patterns) {
- if (!strv_isempty(patterns)) {
- char **pattern;
+ char **pattern;
- STRV_FOREACH(pattern, patterns)
- if (fnmatch(*pattern, job->name, FNM_NOESCAPE) == 0)
- return true;
- return false;
- }
+ assert(job);
- return true;
+ if (strv_isempty(patterns))
+ return true;
+
+ STRV_FOREACH(pattern, patterns)
+ if (fnmatch(*pattern, job->name, FNM_NOESCAPE) == 0)
+ return true;
+ return false;
}
static int list_jobs(sd_bus *bus, char **args) {
r = sd_bus_add_match(
bus,
+ NULL,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
}
static int wait_for_jobs(sd_bus *bus, Set *s) {
+ _cleanup_bus_slot_unref_ sd_bus_slot *slot = NULL;
WaitData d = { .set = s };
int r = 0, q;
assert(bus);
assert(s);
- q = sd_bus_add_filter(bus, wait_filter, &d);
+ q = sd_bus_add_filter(bus, &slot, wait_filter, &d);
if (q < 0)
return log_oom();
d.result = NULL;
}
- q = sd_bus_remove_filter(bus, wait_filter, &d);
- if (q < 0 && r == 0)
- r = q;
-
return r;
}
static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {
- _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_strv_free_ char **mangled = NULL, **globs = NULL;
char **name;
int r = 0, i;
/* Query the manager only if any of the names are a glob, since
* this is fairly expensive */
if (!strv_isempty(globs)) {
+ _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
_cleanup_free_ UnitInfo *unit_infos = NULL;
- r = get_unit_list(bus, &reply, &unit_infos, globs);
+ r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);
if (r < 0)
return r;
*ret = mangled;
mangled = NULL; /* do not free */
+
return 0;
}
get_process_comm(pid, &comm);
user = uid_to_name(uid);
- log_warning("Operation inhibited by \"%s\" (PID %lu \"%s\", user %s), reason is \"%s\".",
- who, (unsigned long) pid, strna(comm), strna(user), why);
+ log_warning("Operation inhibited by \"%s\" (PID "PID_FMT" \"%s\", user %s), reason is \"%s\".",
+ who, pid, strna(comm), strna(user), why);
c++;
}
bool *ellipsized) {
ExecStatusInfo *p;
- const char *on, *off, *ss;
+ const char *active_on, *active_off, *on, *off, *ss;
usec_t timestamp;
char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
char since2[FORMAT_TIMESTAMP_MAX], *s2;
/* This shows pretty information about a unit. See
* print_property() for a low-level property printer */
- printf("%s", strna(i->id));
+ if (streq_ptr(i->active_state, "failed")) {
+ active_on = ansi_highlight_red();
+ active_off = ansi_highlight_off();
+ } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
+ active_on = ansi_highlight_green();
+ active_off = ansi_highlight_off();
+ } else
+ active_on = active_off = "";
+
+ printf("%s%s%s %s", active_on, draw_special_char(DRAW_BLACK_CIRCLE), active_off, strna(i->id));
if (i->description && !streq_ptr(i->id, i->description))
printf(" - %s", i->description);
}
ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
-
- if (streq_ptr(i->active_state, "failed")) {
- on = ansi_highlight_red();
- off = ansi_highlight_off();
- } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
- on = ansi_highlight_green();
- off = ansi_highlight_off();
- } else
- on = off = "";
-
if (ss)
printf(" Active: %s%s (%s)%s",
- on, strna(i->active_state), ss, off);
+ active_on, strna(i->active_state), ss, active_off);
else
printf(" Active: %s%s%s",
- on, strna(i->active_state), off);
+ active_on, strna(i->active_state), active_off);
if (!isempty(i->result) && !streq(i->result, "success"))
printf(" (Result: %s)", i->result);
printf(" Status: \"%s\"\n", i->status_text);
if (i->control_group &&
- (i->main_pid > 0 || i->control_pid > 0 || cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, i->control_group, false) == 0)) {
+ (i->main_pid > 0 || i->control_pid > 0 ||
+ ((arg_transport != BUS_TRANSPORT_LOCAL && arg_transport != BUS_TRANSPORT_CONTAINER) || cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, i->control_group, false) == 0))) {
unsigned c;
printf(" CGroup: %s\n", i->control_group);
if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
unsigned k = 0;
pid_t extra[2];
- char prefix[] = " ";
+ static const char prefix[] = " ";
c = columns();
if (c > sizeof(prefix) - 1)
if (i->control_pid > 0)
extra[k++] = i->control_pid;
- show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, i->control_group, prefix,
- c, false, extra, k, flags);
+ show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, i->control_group, prefix, c, false, extra, k, flags);
}
}
if (i->id && arg_transport == BUS_TRANSPORT_LOCAL) {
- printf("\n");
show_journal_by_unit(stdout,
i->id,
arg_output,
i->inactive_exit_timestamp_monotonic,
arg_lines,
getuid(),
- flags,
+ flags | OUTPUT_BEGIN_NEWLINE,
arg_scope == UNIT_FILE_SYSTEM,
ellipsized);
}
&reply,
"u", pid);
if (r < 0) {
- log_error("Failed to get unit for PID %lu: %s", (unsigned long) pid, bus_error_message(&error, r));
+ log_error("Failed to get unit for PID "PID_FMT": %s", pid, bus_error_message(&error, r));
return r;
}
_cleanup_free_ UnitInfo *unit_infos = NULL;
const UnitInfo *u;
unsigned c;
- int r;
+ int r, ret = 0;
- r = get_unit_list(bus, &reply, &unit_infos, NULL);
+ r = get_unit_list(bus, NULL, NULL, &unit_infos, 0, &reply);
if (r < 0)
return r;
return log_oom();
r = show_one(verb, bus, p, show_properties, new_line, ellipsized);
- if (r != 0)
+ if (r < 0)
return r;
+ else if (r > 0 && ret == 0)
+ ret = r;
+ }
+
+ return ret;
+}
+
+static int show_system_status(sd_bus *bus) {
+ char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], since2[FORMAT_TIMESTAMP_MAX];
+ _cleanup_free_ char *hn = NULL;
+ struct machine_info mi = {};
+ const char *on, *off;
+ int r;
+
+ hn = gethostname_malloc();
+ if (!hn)
+ return log_oom();
+
+ r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, &mi);
+ if (r < 0) {
+ log_error("Failed to read server status: %s", strerror(-r));
+ return r;
}
+ if (streq_ptr(mi.state, "degraded")) {
+ on = ansi_highlight_red();
+ off = ansi_highlight_off();
+ } else if (!streq_ptr(mi.state, "running")) {
+ on = ansi_highlight_yellow();
+ off = ansi_highlight_off();
+ } else
+ on = off = "";
+
+ printf("%s%s%s %s\n", on, draw_special_char(DRAW_BLACK_CIRCLE), off, arg_host ? arg_host : hn);
+
+ printf(" State: %s%s%s\n",
+ on, strna(mi.state), off);
+
+ printf(" Jobs: %u queued\n", mi.n_jobs);
+ printf(" Failed: %u units\n", mi.n_failed_units);
+
+ printf(" Since: %s; %s\n",
+ format_timestamp(since2, sizeof(since2), mi.timestamp),
+ format_timestamp_relative(since1, sizeof(since1), mi.timestamp));
+
+ printf(" CGroup: %s\n", mi.control_group ?: "/");
+ if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
+ int flags =
+ arg_all * OUTPUT_SHOW_ALL |
+ (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
+ on_tty() * OUTPUT_COLOR |
+ !arg_quiet * OUTPUT_WARN_CUTOFF |
+ arg_full * OUTPUT_FULL_WIDTH;
+
+ static const char prefix[] = " ";
+ unsigned c;
+
+ c = columns();
+ if (c > sizeof(prefix) - 1)
+ c -= sizeof(prefix) - 1;
+ else
+ c = 0;
+
+ show_cgroup(SYSTEMD_CGROUP_CONTROLLER, strempty(mi.control_group), prefix, c, false, flags);
+ }
+
+ free(mi.state);
+ free(mi.control_group);
+
return 0;
}
+static int show(sd_bus *bus, char **args) {
+ bool show_properties, show_status, new_line = false;
+ bool ellipsized = false;
+ int r, ret = 0;
+
+ assert(bus);
+ assert(args);
+
+ show_properties = streq(args[0], "show");
+ show_status = streq(args[0], "status");
+
+ if (show_properties)
+ pager_open_if_enabled();
+
+ /* If no argument is specified inspect the manager itself */
+
+ if (show_properties && strv_length(args) <= 1)
+ return show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line, &ellipsized);
+
+ if (show_status && strv_length(args) <= 1) {
+
+ pager_open_if_enabled();
+ show_system_status(bus);
+ new_line = true;
+
+ if (arg_all)
+ ret = show_all(args[0], bus, false, &new_line, &ellipsized);
+ } else {
+ _cleanup_free_ char **patterns = NULL;
+ char **name;
+
+ STRV_FOREACH(name, args + 1) {
+ _cleanup_free_ char *unit = NULL;
+ uint32_t id;
+
+ if (safe_atou32(*name, &id) < 0) {
+ if (strv_push(&patterns, *name) < 0)
+ return log_oom();
+
+ continue;
+ } else if (show_properties) {
+ /* Interpret as job id */
+ if (asprintf(&unit, "/org/freedesktop/systemd1/job/%u", id) < 0)
+ return log_oom();
+
+ } else {
+ /* Interpret as PID */
+ r = get_unit_dbus_path_by_pid(bus, id, &unit);
+ if (r < 0) {
+ ret = r;
+ continue;
+ }
+ }
+
+ r = show_one(args[0], bus, unit, show_properties,
+ &new_line, &ellipsized);
+ if (r < 0)
+ return r;
+ else if (r > 0 && ret == 0)
+ ret = r;
+ }
+
+ if (!strv_isempty(patterns)) {
+ _cleanup_strv_free_ char **names = NULL;
+
+ r = expand_names(bus, patterns, NULL, &names);
+ if (r < 0)
+ log_error("Failed to expand names: %s", strerror(-r));
+
+ STRV_FOREACH(name, names) {
+ _cleanup_free_ char *unit;
+
+ unit = unit_dbus_path_from_name(*name);
+ if (!unit)
+ return log_oom();
+
+ r = show_one(args[0], bus, unit, show_properties,
+ &new_line, &ellipsized);
+ if (r < 0)
+ return r;
+ else if (r > 0 && ret == 0)
+ ret = r;
+ }
+ }
+ }
+
+ if (ellipsized && !arg_quiet)
+ printf("Hint: Some lines were ellipsized, use -l to show in full.\n");
+
+ return ret;
+}
+
static int cat(sd_bus *bus, char **args) {
_cleanup_free_ char *unit = NULL;
_cleanup_strv_free_ char **names = NULL;
return r < 0 ? r : 0;
}
-static int show(sd_bus *bus, char **args) {
- bool show_properties, show_status, new_line = false;
- bool ellipsized = false;
- int r, ret = 0;
-
- assert(bus);
- assert(args);
-
- show_properties = streq(args[0], "show");
- show_status = streq(args[0], "status");
-
- if (show_properties)
- pager_open_if_enabled();
-
- /* If no argument is specified inspect the manager itself */
-
- if (show_properties && strv_length(args) <= 1)
- return show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line, &ellipsized);
-
- if (show_status && strv_length(args) <= 1)
- ret = show_all(args[0], bus, false, &new_line, &ellipsized);
- else {
- _cleanup_free_ char **patterns = NULL;
- char **name;
-
- STRV_FOREACH(name, args + 1) {
- _cleanup_free_ char *unit = NULL;
- uint32_t id;
-
- if (safe_atou32(*name, &id) < 0) {
- if (strv_push(&patterns, *name) < 0)
- return log_oom();
-
- continue;
- } else if (show_properties) {
- /* Interpret as job id */
- if (asprintf(&unit, "/org/freedesktop/systemd1/job/%u", id) < 0)
- return log_oom();
-
- } else {
- /* Interpret as PID */
- r = get_unit_dbus_path_by_pid(bus, id, &unit);
- if (r < 0) {
- ret = r;
- continue;
- }
- }
-
- show_one(args[0], bus, unit, show_properties, &new_line, &ellipsized);
- }
-
- if (!strv_isempty(patterns)) {
- _cleanup_strv_free_ char **names = NULL;
-
- r = expand_names(bus, patterns, NULL, &names);
- if (r < 0)
- log_error("Failed to expand names: %s", strerror(-r));
-
- STRV_FOREACH(name, names) {
- _cleanup_free_ char *unit;
-
- unit = unit_dbus_path_from_name(*name);
- if (!unit)
- return log_oom();
-
- show_one(args[0], bus, unit, show_properties, &new_line, &ellipsized);
- }
- }
- }
-
- if (ellipsized && !arg_quiet)
- printf("Hint: Some lines were ellipsized, use -l to show in full.\n");
-
- return ret;
-}
-
static int set_property(sd_bus *bus, char **args) {
_cleanup_bus_message_unref_ sd_bus_message *m = NULL;
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
/* Processes all SysV units, and reshuffles the array so that
* afterwards only the native units remain */
- r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, NULL, NULL, NULL);
+ r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, arg_root, NULL, NULL, NULL);
if (r < 0)
return r;
r = 0;
for (f = 0; args[f]; f++) {
const char *name;
- _cleanup_free_ char *p = NULL, *q = NULL;
+ _cleanup_free_ char *p = NULL, *q = NULL, *l = NULL;
bool found_native = false, found_sysv;
unsigned c = 1;
const char *argv[6] = { "/sbin/chkconfig", NULL, NULL, NULL, NULL };
- char **k, *l;
+ char **k;
int j;
pid_t pid;
siginfo_t status;
continue;
STRV_FOREACH(k, paths.unit_path) {
+ _cleanup_free_ char *path = NULL;
+
if (!isempty(arg_root))
- asprintf(&p, "%s/%s/%s", arg_root, *k, name);
+ asprintf(&path, "%s/%s/%s", arg_root, *k, name);
else
- asprintf(&p, "%s/%s", *k, name);
+ asprintf(&path, "%s/%s", *k, name);
- if (!p) {
+ if (!path) {
r = log_oom();
goto finish;
}
- found_native = access(p, F_OK) >= 0;
- free(p);
- p = NULL;
-
+ found_native = access(path, F_OK) >= 0;
if (found_native)
break;
}
goto finish;
}
- p[strlen(p) - sizeof(".service") + 1] = 0;
+ p[strlen(p) - strlen(".service")] = 0;
found_sysv = access(p, F_OK) >= 0;
-
if (!found_sysv)
continue;
}
log_info("Executing %s", l);
- free(l);
pid = fork();
if (pid < 0) {
if (r < 0)
return r;
- /* Try to reload if enabeld */
+ /* Try to reload if enabled */
if (!arg_no_reload)
r = daemon_reload(bus, args);
else
" ones. To list all units installed on the system, use\n"
" the 'list-unit-files' command instead.\n"
" -l --full Don't ellipsize unit names on output\n"
+ " -r --recursive Show unit list of host and local containers\n"
" --reverse Show reverse dependencies with 'list-dependencies'\n"
" --job-mode=MODE Specify how to deal with already queued jobs, when\n"
" queueing a new job\n"
" otherwise restart if active\n"
" isolate NAME Start one unit and stop all others\n"
" kill NAME... Send signal to processes of a unit\n"
- " is-active NAME... Check whether units are active\n"
- " is-failed NAME... Check whether units are failed\n"
- " status [NAME...|PID...] Show runtime status of one or more units\n"
- " show [NAME...|JOB...] Show properties of one or more\n"
+ " is-active PATTERN... Check whether units are active\n"
+ " is-failed PATTERN... Check whether units are failed\n"
+ " status [PATTERN...|PID...] Show runtime status of one or more units\n"
+ " show [PATTERN...|JOB...] Show properties of one or more\n"
" units/jobs or the manager\n"
- " cat NAME... Show files and drop-ins of one or more units\n"
+ " cat PATTERN... Show files and drop-ins of one or more units\n"
" set-property NAME ASSIGNMENT... Sets one or more properties of a unit\n"
- " help NAME...|PID... Show manual for one or more units\n"
- " reset-failed [NAME...] Reset failed state for all, one, or more\n"
+ " help PATTERN...|PID... Show manual for one or more units\n"
+ " reset-failed [PATTERN...] Reset failed state for all, one, or more\n"
" units\n"
" list-dependencies [NAME] Recursively show units which are required\n"
" or wanted by this unit or by which this\n"
" the search path\n"
" get-default Get the name of the default target\n"
" set-default NAME Set the default target\n\n"
+ "Machine Commands:\n"
+ " list-machines [PATTERN...] List local containers and host\n\n"
"Job Commands:\n"
" list-jobs [PATTERN...] List jobs\n"
" cancel [JOB...] Cancel all, one, or more jobs\n\n"
{ "output", required_argument, NULL, 'o' },
{ "plain", no_argument, NULL, ARG_PLAIN },
{ "state", required_argument, NULL, ARG_STATE },
+ { "recursive", no_argument, NULL, 'r' },
{}
};
assert(argc >= 0);
assert(argv);
- while ((c = getopt_long(argc, argv, "ht:p:alqfs:H:M:n:o:i", options, NULL)) >= 0) {
+ while ((c = getopt_long(argc, argv, "ht:p:alqfs:H:M:n:o:ir", options, NULL)) >= 0) {
switch (c) {
break;
}
+ case 'r':
+ if (geteuid() != 0) {
+ log_error("--recursive requires root privileges.");
+ return -EPERM;
+ }
+
+ arg_recursive = true;
+ break;
+
case '?':
return -EINVAL;
}
}
- if (arg_action == ACTION_REBOOT && argc == optind + 1) {
- r = write_string_file(REBOOT_PARAM_FILE, argv[optind]);
- if (r < 0) {
- log_error("Failed to write reboot param to "
- REBOOT_PARAM_FILE": %s", strerror(-r));
+ if (arg_action == ACTION_REBOOT && (argc == optind || argc == optind + 1)) {
+ r = update_reboot_param_file(argc == optind + 1 ? argv[optind] : NULL);
+ if (r < 0)
return r;
- }
} else if (optind < argc) {
log_error("Too many arguments.");
return -EINVAL;
{ "list-sockets", MORE, 1, list_sockets },
{ "list-timers", MORE, 1, list_timers },
{ "list-jobs", MORE, 1, list_jobs },
+ { "list-machines", MORE, 1, list_machines },
{ "clear-jobs", EQUAL, 1, daemon_reload },
{ "cancel", MORE, 2, cancel_job },
{ "start", MORE, 2, start_unit },
struct msghdr msghdr = {
.msg_name = &sockaddr,
.msg_namelen = offsetof(struct sockaddr_un, sun_path)
- + sizeof("/run/systemd/shutdownd") - 1,
+ + strlen("/run/systemd/shutdownd"),
.msg_iov = iovec,
.msg_iovlen = 1,
};
~ianmdlvl / elogind.git / blobdiff