-/*-*- Mode: C; c-basic-offset: 8 -*-*/
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
#include "path-lookup.h"
#include "conf-parser.h"
#include "sd-daemon.h"
+#include "shutdownd.h"
static const char *arg_type = NULL;
static char **arg_property = NULL;
static bool arg_force = false;
static bool arg_defaults = false;
static char **arg_wall = NULL;
+static usec_t arg_when = 0;
static enum action {
ACTION_INVALID,
ACTION_SYSTEMCTL,
ACTION_RELOAD,
ACTION_REEXEC,
ACTION_RUNLEVEL,
+ ACTION_CANCEL_SHUTDOWN,
_ACTION_MAX
} arg_action = ACTION_SYSTEMCTL;
static enum dot {
utmp_wall(table[action]);
}
+struct unit_info {
+ const char *id;
+ const char *description;
+ const char *load_state;
+ const char *active_state;
+ const char *sub_state;
+ const char *following;
+ const char *unit_path;
+ uint32_t job_id;
+ const char *job_type;
+ const char *job_path;
+};
+
+static int compare_unit_info(const void *a, const void *b) {
+ const char *d1, *d2;
+ const struct unit_info *u = a, *v = b;
+
+ d1 = strrchr(u->id, '.');
+ d2 = strrchr(v->id, '.');
+
+ if (d1 && d2) {
+ int r;
+
+ if ((r = strcasecmp(d1, d2)) != 0)
+ return r;
+ }
+
+ return strcasecmp(u->id, v->id);
+}
+
static int list_units(DBusConnection *bus, char **args, unsigned n) {
DBusMessage *m = NULL, *reply = NULL;
DBusError error;
int r;
DBusMessageIter iter, sub, sub2;
- unsigned k = 0;
+ unsigned c = 0, k, n_units = 0;
+ struct unit_info *unit_infos = NULL;
dbus_error_init(&error);
dbus_message_iter_recurse(&iter, &sub);
- if (isatty(STDOUT_FILENO))
- printf("%-45s %-6s %-12s %-12s %-15s %s\n", "UNIT", "LOAD", "ACTIVE", "SUB", "JOB", "DESCRIPTION");
-
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
- const char *id, *description, *load_state, *active_state, *sub_state, *following, *unit_path, *job_type, *job_path, *dot;
- uint32_t job_id;
+ struct unit_info *u;
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
log_error("Failed to parse reply.");
goto finish;
}
+ if (c >= n_units) {
+ struct unit_info *w;
+
+ n_units = MAX(2*c, 16);
+ w = realloc(unit_infos, sizeof(struct unit_info) * n_units);
+
+ if (!w) {
+ log_error("Failed to allocate unit array.");
+ r = -ENOMEM;
+ goto finish;
+ }
+
+ unit_infos = w;
+ }
+
+ u = unit_infos+c;
+
dbus_message_iter_recurse(&sub, &sub2);
- if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &description, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &following, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &job_id, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &job_type, true) < 0 ||
- bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, false) < 0) {
+ if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->id, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->description, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->load_state, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->active_state, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->sub_state, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->following, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->unit_path, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &u->job_id, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->job_type, true) < 0 ||
+ bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->job_path, false) < 0) {
log_error("Failed to parse reply.");
r = -EIO;
goto finish;
}
- if ((!arg_type || ((dot = strrchr(id, '.')) &&
+ dbus_message_iter_next(&sub);
+ c++;
+ }
+
+ qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info);
+
+ if (isatty(STDOUT_FILENO))
+ printf("%-45s %-6s %-12s %-12s %-15s %s\n", "UNIT", "LOAD", "ACTIVE", "SUB", "JOB", "DESCRIPTION");
+
+ for (k = 0; k < c; k++) {
+ const char *dot;
+ struct unit_info *u = unit_infos+k;
+
+ if ((!arg_type || ((dot = strrchr(u->id, '.')) &&
streq(dot+1, arg_type))) &&
- (arg_all || !(streq(active_state, "inactive") || following[0]) || job_id > 0)) {
+ (arg_all || !(streq(u->active_state, "inactive") || u->following[0]) || u->job_id > 0)) {
char *e;
int a = 0, b = 0;
const char *on, *off;
- if (streq(active_state, "maintenance")) {
+ if (streq(u->active_state, "maintenance")) {
on = ansi_highlight(true);
off = ansi_highlight(false);
} else
on = off = "";
- e = arg_full ? NULL : ellipsize(id, 45, 33);
- printf("%-45s %-6s %s%-12s %-12s%s%n", e ? e : id, load_state, on, active_state, sub_state, off, &a);
+ e = arg_full ? NULL : ellipsize(u->id, 45, 33);
+ printf("%-45s %-6s %s%-12s %-12s%s%n", e ? e : u->id, u->load_state, on, u->active_state, u->sub_state, off, &a);
free(e);
a -= strlen(on) + strlen(off);
- if (job_id != 0)
- printf(" => %-12s%n", job_type, &b);
+ if (u->job_id != 0)
+ printf(" => %-12s%n", u->job_type, &b);
else
b = 1 + 15;
if (a + b + 2 < columns()) {
- if (job_id == 0)
+ if (u->job_id == 0)
printf(" ");
- printf(" %.*s", columns() - a - b - 2, description);
+ printf(" %.*s", columns() - a - b - 2, u->description);
}
fputs("\n", stdout);
- k++;
}
-
- dbus_message_iter_next(&sub);
}
if (isatty(STDOUT_FILENO)) {
"JOB = Job, shows pending jobs for the unit.\n");
if (arg_all)
- printf("\n%u units listed.\n", k);
+ printf("\n%u units listed.\n", c);
else
- printf("\n%u units listed. Pass --all to see inactive units, too.\n", k);
+ printf("\n%u units listed. Pass --all to see inactive units, too.\n", c);
}
r = 0;
if (reply)
dbus_message_unref(reply);
+ free(unit_infos);
+
dbus_error_free(&error);
return r;
dbus_message_iter_next(&sub);
}
+ r = 0;
+
finish:
if (m)
dbus_message_unref(m);
}
static bool need_daemon_reload(DBusConnection *bus, const char *unit) {
- DBusMessage *m, *reply;
+ DBusMessage *m = NULL, *reply = NULL;
dbus_bool_t b = FALSE;
DBusMessageIter iter, sub;
const char
}
if (!arg_no_block)
- r = wait_for_jobs(bus, s);
+ if ((r = wait_for_jobs(bus, s)) < 0)
+ goto finish;
+
+ r = 1;
finish:
if (s)
const char *description;
- const char *fragment_path;
+ const char *path;
const char *default_control_group;
bool need_daemon_reload;
printf("\n");
- if (i->fragment_path)
- printf("\t Loaded: %s (%s)\n", strna(i->load_state), i->fragment_path);
- else if (streq_ptr(i->load_state, "failed"))
- printf("\t Loaded: %s%s%s\n",
- ansi_highlight(true),
- strna(i->load_state),
- ansi_highlight(false));
+ if (streq_ptr(i->load_state, "failed")) {
+ on = ansi_highlight(true);
+ off = ansi_highlight(false);
+ } else
+ on = off = "";
+
+ if (i->path)
+ printf("\t Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, i->path);
else
- printf("\t Loaded: %s\n", strna(i->load_state));
+ printf("\t Loaded: %s%s%s\n", on, strna(i->load_state), off);
ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
else if (streq(name, "Description"))
i->description = s;
else if (streq(name, "FragmentPath"))
- i->fragment_path = s;
+ i->path = s;
+ else if (streq(name, "SysVPath"))
+ i->path = s;
else if (streq(name, "DefaultControlGroup"))
i->default_control_group = s;
else if (streq(name, "StatusText"))
const char *path = NULL;
uint32_t id;
- if (!show_properties || safe_atou32(args[i], &id) < 0) {
+ if (safe_atou32(args[i], &id) < 0) {
+
+ /* Interpret as unit name */
if (!(m = dbus_message_new_method_call(
"org.freedesktop.systemd1",
}
}
- } else {
+ } else if (show_properties) {
+
+ /* Interpret as job id */
if (!(m = dbus_message_new_method_call(
"org.freedesktop.systemd1",
goto finish;
}
+ if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
+ log_error("Failed to issue method call: %s", error.message);
+ r = -EIO;
+ goto finish;
+ }
+ } else {
+
+ /* Interpret as PID */
+
+ if (!(m = dbus_message_new_method_call(
+ "org.freedesktop.systemd1",
+ "/org/freedesktop/systemd1",
+ "org.freedesktop.systemd1.Manager",
+ "GetUnitByPID"))) {
+ log_error("Could not allocate message.");
+ r = -ENOMEM;
+ goto finish;
+ }
+
+ if (!dbus_message_append_args(m,
+ DBUS_TYPE_UINT32, &id,
+ DBUS_TYPE_INVALID)) {
+ log_error("Could not append arguments to message.");
+ r = -ENOMEM;
+ goto finish;
+ }
+
if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
log_error("Failed to issue method call: %s", error.message);
r = -EIO;
free(p);
if (r == 0)
- q = r;
+ r = q;
} else if (is_link) {
char *p, *dest, *c;
" otherwise restart if active\n"
" isolate [NAME] Start one unit and stop all others\n"
" is-active [NAME...] Check whether units are active\n"
- " status [NAME...] Show runtime status of one or more units\n"
+ " status [NAME...|PID...] Show runtime status of one or more units\n"
" show [NAME...|JOB...] Show properties of one or more\n"
" units/jobs or the manager\n"
" reset-maintenance [NAME...] Reset maintenance state for all, one,\n"
static int shutdown_help(void) {
- printf("%s [OPTIONS...] [now] [WALL...]\n\n"
+ printf("%s [OPTIONS...] [TIME] [WALL...]\n\n"
"Shut down the system.\n\n"
" --help Show this help\n"
" -H --halt Halt the machine\n"
" -r --reboot Reboot the machine\n"
" -h Equivalent to --poweroff, overriden by --halt\n"
" -k Don't halt/power-off/reboot, just send warnings\n"
- " --no-wall Don't send wall message before halt/power-off/reboot\n",
+ " --no-wall Don't send wall message before halt/power-off/reboot\n"
+ " -c Cancel a pending shutdown\n",
program_invocation_short_name);
return 0;
return 1;
}
+static int parse_time_spec(const char *t, usec_t *_u) {
+ assert(t);
+ assert(_u);
+
+ if (streq(t, "now"))
+ *_u = 0;
+ else if (t[0] == '+') {
+ uint64_t u;
+
+ if (safe_atou64(t + 1, &u) < 0)
+ return -EINVAL;
+
+ *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u;
+ } else {
+ char *e = NULL;
+ long hour, minute;
+ struct tm tm;
+ time_t s;
+ usec_t n;
+
+ errno = 0;
+ hour = strtol(t, &e, 10);
+ if (errno != 0 || *e != ':' || hour < 0 || hour > 23)
+ return -EINVAL;
+
+ minute = strtol(e+1, &e, 10);
+ if (errno != 0 || *e != 0 || minute < 0 || minute > 59)
+ return -EINVAL;
+
+ n = now(CLOCK_REALTIME);
+ s = (time_t) (n / USEC_PER_SEC);
+
+ zero(tm);
+ assert_se(localtime_r(&s, &tm));
+
+ tm.tm_hour = (int) hour;
+ tm.tm_min = (int) minute;
+ tm.tm_sec = 0;
+
+ assert_se(s = mktime(&tm));
+
+ *_u = (usec_t) s * USEC_PER_SEC;
+
+ while (*_u <= n)
+ *_u += USEC_PER_DAY;
+ }
+
+ return 0;
+}
+
static int shutdown_parse_argv(int argc, char *argv[]) {
enum {
{ NULL, 0, NULL, 0 }
};
- int c;
+ int c, r;
assert(argc >= 0);
assert(argv);
- while ((c = getopt_long(argc, argv, "HPrhkt:a", options, NULL)) >= 0) {
+ while ((c = getopt_long(argc, argv, "HPrhkt:afFc", options, NULL)) >= 0) {
switch (c) {
case ARG_HELP:
/* Compatibility nops */
break;
+ case 'c':
+ arg_action = ACTION_CANCEL_SHUTDOWN;
+ break;
+
case '?':
return -EINVAL;
}
}
- if (argc > optind && !streq(argv[optind], "now"))
- log_warning("First argument '%s' isn't 'now'. Ignoring.", argv[optind]);
+ if (argc > optind) {
+ if ((r = parse_time_spec(argv[optind], &arg_when)) < 0) {
+ log_error("Failed to parse time specification: %s", argv[optind]);
+ return r;
+ }
+ } else
+ arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE;
- /* We ignore the time argument */
+ /* We skip the time argument */
if (argc > optind + 1)
arg_wall = argv + optind + 1;
return verbs[i].dispatch(bus, argv + optind, left);
}
+static int send_shutdownd(usec_t t, char mode, bool warn, const char *message) {
+ int fd = -1;
+ struct msghdr msghdr;
+ struct iovec iovec;
+ union sockaddr_union sockaddr;
+ struct ucred *ucred;
+ union {
+ struct cmsghdr cmsghdr;
+ uint8_t buf[CMSG_SPACE(sizeof(struct ucred))];
+ } control;
+ struct shutdownd_command c;
+
+ zero(c);
+ c.elapse = t;
+ c.mode = mode;
+ c.warn_wall = warn;
+
+ if (message)
+ strncpy(c.wall_message, message, sizeof(c.wall_message));
+
+ if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0)
+ return -errno;
+
+ zero(sockaddr);
+ sockaddr.sa.sa_family = AF_UNIX;
+ sockaddr.un.sun_path[0] = 0;
+ strncpy(sockaddr.un.sun_path+1, "/org/freedesktop/systemd1/shutdownd", sizeof(sockaddr.un.sun_path)-1);
+
+ zero(iovec);
+ iovec.iov_base = (char*) &c;
+ iovec.iov_len = sizeof(c);
+
+ zero(control);
+ control.cmsghdr.cmsg_level = SOL_SOCKET;
+ control.cmsghdr.cmsg_type = SCM_CREDENTIALS;
+ control.cmsghdr.cmsg_len = CMSG_LEN(sizeof(struct ucred));
+
+ ucred = (struct ucred*) CMSG_DATA(&control.cmsghdr);
+ ucred->pid = getpid();
+ ucred->uid = getuid();
+ ucred->gid = getgid();
+
+ zero(msghdr);
+ msghdr.msg_name = &sockaddr;
+ msghdr.msg_namelen = sizeof(sa_family_t) + 1 + sizeof("/org/freedesktop/systemd1/shutdownd") - 1;
+
+ msghdr.msg_iov = &iovec;
+ msghdr.msg_iovlen = 1;
+ msghdr.msg_control = &control;
+ msghdr.msg_controllen = control.cmsghdr.cmsg_len;
+
+ if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) {
+ close_nointr_nofail(fd);
+ return -errno;
+ }
+
+ close_nointr_nofail(fd);
+ return 0;
+}
+
static int reload_with_fallback(DBusConnection *bus) {
- int r;
if (bus) {
/* First, try systemd via D-Bus. */
- if ((r = daemon_reload(bus, NULL, 0)) > 0)
+ if (daemon_reload(bus, NULL, 0) > 0)
return 0;
}
}
static int start_with_fallback(DBusConnection *bus) {
- int r;
if (bus) {
/* First, try systemd via D-Bus. */
- if ((r = start_unit(bus, NULL, 0)) > 0)
+ if (start_unit(bus, NULL, 0) > 0)
goto done;
}
/* Hmm, talking to systemd via D-Bus didn't work. Then
* let's try to talk to Upstart via D-Bus. */
- if ((r = talk_upstart()) > 0)
+ if (talk_upstart() > 0)
goto done;
/* Nothing else worked, so let's try
* /dev/initctl */
- if ((r = talk_initctl()) != 0)
+ if (talk_initctl() > 0)
goto done;
log_error("Failed to talk to init daemon.");
return -EPERM;
}
+ if (arg_when > 0) {
+ char *m;
+ char date[FORMAT_TIMESTAMP_MAX];
+
+ m = strv_join(arg_wall, " ");
+ r = send_shutdownd(arg_when,
+ arg_action == ACTION_HALT ? 'H' :
+ arg_action == ACTION_POWEROFF ? 'P' :
+ 'r',
+ !arg_no_wall,
+ m);
+ free(m);
+
+ if (r < 0)
+ log_warning("Failed to talk to shutdownd, proceeding with immediate shutdown: %s", strerror(-r));
+ else {
+ log_info("Shutdown scheduled for %s, use 'shutdown -c' to cancel.",
+ format_timestamp(date, sizeof(date), arg_when));
+ return 0;
+ }
+ }
+
if (!arg_dry && !arg_immediate)
return start_with_fallback(bus);
- if (!arg_no_wtmp)
- if ((r = utmp_put_shutdown(0)) < 0)
+ if (!arg_no_wtmp) {
+ if (sd_booted() > 0)
+ log_debug("Not writing utmp record, assuming that systemd-update-utmp is used.");
+ else if ((r = utmp_put_shutdown(0)) < 0)
log_warning("Failed to write utmp record: %s", strerror(-r));
+ }
if (!arg_no_sync)
sync();
switch (arg_action) {
case ACTION_HALT:
- log_info("Halting");
+ log_info("Halting.");
reboot(RB_HALT_SYSTEM);
break;
case ACTION_POWEROFF:
- log_info("Powering off");
+ log_info("Powering off.");
reboot(RB_POWER_OFF);
break;
case ACTION_REBOOT:
- log_info("Rebooting");
+ log_info("Rebooting.");
reboot(RB_AUTOBOOT);
break;
dbus_error_init(&error);
log_parse_environment();
+ log_open();
if ((r = parse_argv(argc, argv)) < 0)
goto finish;
retval = reload_with_fallback(bus) < 0;
break;
+ case ACTION_CANCEL_SHUTDOWN:
+ retval = send_shutdownd(0, 0, false, NULL) < 0;
+ break;
+
case ACTION_INVALID:
case ACTION_RUNLEVEL:
default:
~ianmdlvl / elogind.git / blobdiff