src/systemctl/systemctl-start-unit.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "sd-bus.h"
   4
   5 #include "bus-common-errors.h"
   6 #include "bus-error.h"
   7 #include "bus-locator.h"
   8 #include "bus-util.h"
   9 #include "bus-wait-for-jobs.h"
  10 #include "bus-wait-for-units.h"
  11 #include "macro.h"
  12 #include "special.h"
  13 #include "string-util.h"
  14 #include "systemctl-start-unit.h"
  15 #include "systemctl-util.h"
  16 #include "systemctl.h"
  17 #include "terminal-util.h"
  18
  19 static const struct {
  20         const char *verb;      /* systemctl verb */
  21         const char *method;    /* Name of the specific D-Bus method */
  22         const char *job_type;  /* Job type when passing to the generic EnqueueUnitJob() method */
  23 } unit_actions[] = {
  24         { "start",                 "StartUnit",              "start"                 },
  25         { "stop",                  "StopUnit",               "stop"                  },
  26         { "condstop",              "StopUnit",               "stop"                  }, /* legacy alias */
  27         { "reload",                "ReloadUnit",             "reload"                },
  28         { "restart",               "RestartUnit",            "restart"               },
  29         { "try-restart",           "TryRestartUnit",         "try-restart"           },
  30         { "condrestart",           "TryRestartUnit",         "try-restart"           }, /* legacy alias */
  31         { "reload-or-restart",     "ReloadOrRestartUnit",    "reload-or-restart"     },
  32         { "try-reload-or-restart", "ReloadOrTryRestartUnit", "reload-or-try-restart" },
  33         { "reload-or-try-restart", "ReloadOrTryRestartUnit", "reload-or-try-restart" }, /* legacy alias */
  34         { "condreload",            "ReloadOrTryRestartUnit", "reload-or-try-restart" }, /* legacy alias */
  35         { "force-reload",          "ReloadOrTryRestartUnit", "reload-or-try-restart" }, /* legacy alias */
  36 };
  37
  38 static const char *verb_to_method(const char *verb) {
  39        for (size_t i = 0; i < ELEMENTSOF(unit_actions); i++)
  40                 if (streq_ptr(unit_actions[i].verb, verb))
  41                         return unit_actions[i].method;
  42
  43        return "StartUnit";
  44 }
  45
  46 static const char *verb_to_job_type(const char *verb) {
  47        for (size_t i = 0; i < ELEMENTSOF(unit_actions); i++)
  48                 if (streq_ptr(unit_actions[i].verb, verb))
  49                         return unit_actions[i].job_type;
  50
  51        return "start";
  52 }
  53
  54 static int start_unit_one(
  55                 sd_bus *bus,
  56                 const char *method,    /* When using classic per-job bus methods */
  57                 const char *job_type,  /* When using new-style EnqueueUnitJob() */
  58                 const char *name,
  59                 const char *mode,
  60                 sd_bus_error *error,
  61                 BusWaitForJobs *w,
  62                 BusWaitForUnits *wu) {
  63
  64         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
  65         const char *path;
  66         bool done = false;
  67         int r;
  68
  69         assert(method);
  70         assert(name);
  71         assert(mode);
  72         assert(error);
  73
  74         log_debug("%s dbus call org.freedesktop.systemd1.Manager %s(%s, %s)",
  75                   arg_dry_run ? "Would execute" : "Executing",
  76                   method, name, mode);
  77
  78         if (arg_dry_run)
  79                 return 0;
  80
  81         if (arg_show_transaction) {
  82                 _cleanup_(sd_bus_error_free) sd_bus_error enqueue_error = SD_BUS_ERROR_NULL;
  83
  84                 /* Use the new, fancy EnqueueUnitJob() API if the user wants us to print the transaction */
  85                 r = bus_call_method(
  86                                 bus,
  87                                 bus_systemd_mgr,
  88                                 "EnqueueUnitJob",
  89                                 &enqueue_error,
  90                                 &reply,
  91                                 "sss",
  92                                 name, job_type, mode);
  93                 if (r < 0) {
  94                         if (!sd_bus_error_has_name(&enqueue_error, SD_BUS_ERROR_UNKNOWN_METHOD)) {
  95                                 (void) sd_bus_error_move(error, &enqueue_error);
  96                                 goto fail;
  97                         }
  98
  99                         /* Hmm, the API is not yet available. Let's use the classic API instead (see below). */
 100                         log_notice("--show-transaction not supported by this service manager, proceeding without.");
 101                 } else {
 102                         const char *u, *jt;
 103                         uint32_t id;
 104
 105                         r = sd_bus_message_read(reply, "uosos", &id, &path, &u, NULL, &jt);
 106                         if (r < 0)
 107                                 return bus_log_parse_error(r);
 108
 109                         log_info("Enqueued anchor job %" PRIu32 " %s/%s.", id, u, jt);
 110
 111                         r = sd_bus_message_enter_container(reply, 'a', "(uosos)");
 112                         if (r < 0)
 113                                 return bus_log_parse_error(r);
 114                         for (;;) {
 115                                 r = sd_bus_message_read(reply, "(uosos)", &id, NULL, &u, NULL, &jt);
 116                                 if (r < 0)
 117                                         return bus_log_parse_error(r);
 118                                 if (r == 0)
 119                                         break;
 120
 121                                 log_info("Enqueued auxiliary job %" PRIu32 " %s/%s.", id, u, jt);
 122                         }
 123
 124                         r = sd_bus_message_exit_container(reply);
 125                         if (r < 0)
 126                                 return bus_log_parse_error(r);
 127
 128                         done = true;
 129                 }
 130         }
 131
 132         if (!done) {
 133                 r = bus_call_method(bus, bus_systemd_mgr, method, error, &reply, "ss", name, mode);
 134                 if (r < 0)
 135                         goto fail;
 136
 137                 r = sd_bus_message_read(reply, "o", &path);
 138                 if (r < 0)
 139                         return bus_log_parse_error(r);
 140         }
 141
 142         if (need_daemon_reload(bus, name) > 0)
 143                 warn_unit_file_changed(name);
 144
 145         if (w) {
 146                 log_debug("Adding %s to the set", path);
 147                 r = bus_wait_for_jobs_add(w, path);
 148                 if (r < 0)
 149                         return log_error_errno(r, "Failed to watch job for %s: %m", name);
 150         }
 151
 152         if (wu) {
 153                 r = bus_wait_for_units_add_unit(wu, name, BUS_WAIT_FOR_INACTIVE|BUS_WAIT_NO_JOB, NULL, NULL);
 154                 if (r < 0)
 155                         return log_error_errno(r, "Failed to watch unit %s: %m", name);
 156         }
 157
 158         return 0;
 159
 160 fail:
 161         /* There's always a fallback possible for legacy actions. */
 162         if (arg_action != ACTION_SYSTEMCTL)
 163                 return r;
 164
 165         log_error_errno(r, "Failed to %s %s: %s", job_type, name, bus_error_message(error, r));
 166
 167         if (!sd_bus_error_has_names(error, BUS_ERROR_NO_SUCH_UNIT,
 168                                            BUS_ERROR_UNIT_MASKED,
 169                                            BUS_ERROR_JOB_TYPE_NOT_APPLICABLE))
 170                 log_error("See %s logs and 'systemctl%s status%s %s' for details.",
 171                           arg_scope == UNIT_FILE_SYSTEM ? "system" : "user",
 172                           arg_scope == UNIT_FILE_SYSTEM ? "" : " --user",
 173                           name[0] == '-' ? " --" : "",
 174                           name);
 175
 176         return r;
 177 }
 178
 179 static int enqueue_marked_jobs(
 180                 sd_bus *bus,
 181                 BusWaitForJobs *w) {
 182
 183         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 184         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 185         int r;
 186
 187         log_debug("%s dbus call org.freedesktop.systemd1.Manager EnqueueMarkedJobs()",
 188                   arg_dry_run ? "Would execute" : "Executing");
 189
 190         if (arg_dry_run)
 191                 return 0;
 192
 193         r = bus_call_method(bus, bus_systemd_mgr, "EnqueueMarkedJobs", &error, &reply, NULL);
 194         if (r < 0)
 195                 return log_error_errno(r, "Failed to start jobs: %s", bus_error_message(&error, r));
 196
 197         _cleanup_strv_free_ char **paths = NULL;
 198         r = sd_bus_message_read_strv(reply, &paths);
 199         if (r < 0)
 200                 return bus_log_parse_error(r);
 201
 202         if (w) {
 203                 char **path;
 204
 205                 STRV_FOREACH(path, paths) {
 206                         log_debug("Adding %s to the set", *path);
 207                         r = bus_wait_for_jobs_add(w, *path);
 208                         if (r < 0)
 209                                 return log_error_errno(r, "Failed to watch job %s: %m", *path);
 210                 }
 211         }
 212
 213         return 0;
 214 }
 215
 216 const struct action_metadata action_table[_ACTION_MAX] = {
 217         [ACTION_HALT]                   = { SPECIAL_HALT_TARGET,                   "halt",                   "replace-irreversibly" },
 218         [ACTION_POWEROFF]               = { SPECIAL_POWEROFF_TARGET,               "poweroff",               "replace-irreversibly" },
 219         [ACTION_REBOOT]                 = { SPECIAL_REBOOT_TARGET,                 "reboot",                 "replace-irreversibly" },
 220         [ACTION_KEXEC]                  = { SPECIAL_KEXEC_TARGET,                  "kexec",                  "replace-irreversibly" },
 221         [ACTION_RUNLEVEL2]              = { SPECIAL_MULTI_USER_TARGET,             NULL,                     "isolate"              },
 222         [ACTION_RUNLEVEL3]              = { SPECIAL_MULTI_USER_TARGET,             NULL,                     "isolate"              },
 223         [ACTION_RUNLEVEL4]              = { SPECIAL_MULTI_USER_TARGET,             NULL,                     "isolate"              },
 224         [ACTION_RUNLEVEL5]              = { SPECIAL_GRAPHICAL_TARGET,              NULL,                     "isolate"              },
 225         [ACTION_RESCUE]                 = { SPECIAL_RESCUE_TARGET,                 "rescue",                 "isolate"              },
 226         [ACTION_EMERGENCY]              = { SPECIAL_EMERGENCY_TARGET,              "emergency",              "isolate"              },
 227         [ACTION_DEFAULT]                = { SPECIAL_DEFAULT_TARGET,                "default",                "isolate"              },
 228         [ACTION_EXIT]                   = { SPECIAL_EXIT_TARGET,                   "exit",                   "replace-irreversibly" },
 229         [ACTION_SUSPEND]                = { SPECIAL_SUSPEND_TARGET,                "suspend",                "replace-irreversibly" },
 230         [ACTION_HIBERNATE]              = { SPECIAL_HIBERNATE_TARGET,              "hibernate",              "replace-irreversibly" },
 231         [ACTION_HYBRID_SLEEP]           = { SPECIAL_HYBRID_SLEEP_TARGET,           "hybrid-sleep",           "replace-irreversibly" },
 232         [ACTION_SUSPEND_THEN_HIBERNATE] = { SPECIAL_SUSPEND_THEN_HIBERNATE_TARGET, "suspend-then-hibernate", "replace-irreversibly" },
 233 };
 234
 235 enum action verb_to_action(const char *verb) {
 236         for (enum action i = 0; i < _ACTION_MAX; i++)
 237                 if (streq_ptr(action_table[i].verb, verb))
 238                         return i;
 239
 240         return _ACTION_INVALID;
 241 }
 242
 243 static const char** make_extra_args(const char *extra_args[static 4]) {
 244         size_t n = 0;
 245
 246         assert(extra_args);
 247
 248         if (arg_scope != UNIT_FILE_SYSTEM)
 249                 extra_args[n++] = "--user";
 250
 251         if (arg_transport == BUS_TRANSPORT_REMOTE) {
 252                 extra_args[n++] = "-H";
 253                 extra_args[n++] = arg_host;
 254         } else if (arg_transport == BUS_TRANSPORT_MACHINE) {
 255                 extra_args[n++] = "-M";
 256                 extra_args[n++] = arg_host;
 257         } else
 258                 assert(arg_transport == BUS_TRANSPORT_LOCAL);
 259
 260         extra_args[n] = NULL;
 261         return extra_args;
 262 }
 263
 264 int start_unit(int argc, char *argv[], void *userdata) {
 265         _cleanup_(bus_wait_for_units_freep) BusWaitForUnits *wu = NULL;
 266         _cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
 267         const char *method, *job_type, *mode, *one_name, *suffix = NULL;
 268         _cleanup_free_ char **stopped_units = NULL; /* Do not use _cleanup_strv_free_ */
 269         _cleanup_strv_free_ char **names = NULL;
 270         int r, ret = EXIT_SUCCESS;
 271         sd_bus *bus;
 272         char **name;
 273
 274         if (arg_wait && !STR_IN_SET(argv[0], "start", "restart"))
 275                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 276                                        "--wait may only be used with the 'start' or 'restart' commands.");
 277
 278         /* We cannot do sender tracking on the private bus, so we need the full one for RefUnit to implement
 279          * --wait */
 280         r = acquire_bus(arg_wait ? BUS_FULL : BUS_MANAGER, &bus);
 281         if (r < 0)
 282                 return r;
 283
 284         ask_password_agent_open_maybe();
 285         polkit_agent_open_maybe();
 286
 287         if (arg_action == ACTION_SYSTEMCTL) {
 288                 enum action action;
 289
 290                 action = verb_to_action(argv[0]);
 291
 292                 if (action != _ACTION_INVALID) {
 293                         /* A command in style "systemctl reboot", "systemctl poweroff", … */
 294                         method = "StartUnit";
 295                         job_type = "start";
 296                         mode = action_table[action].mode;
 297                         one_name = action_table[action].target;
 298                 } else {
 299                         if (streq(argv[0], "isolate")) {
 300                                 /* A "systemctl isolate <unit1> <unit2> …" command */
 301                                 method = "StartUnit";
 302                                 job_type = "start";
 303                                 mode = "isolate";
 304                                 suffix = ".target";
 305                         } else if (!arg_marked) {
 306                                 /* A command in style of "systemctl start <unit1> <unit2> …", "sysemctl stop <unit1> <unit2> …" and so on */
 307                                 method = verb_to_method(argv[0]);
 308                                 job_type = verb_to_job_type(argv[0]);
 309                                 mode = arg_job_mode;
 310                         } else
 311                                 method = job_type = mode = NULL;
 312
 313                         one_name = NULL;
 314                 }
 315         } else {
 316                 /* A SysV legacy command such as "halt", "reboot", "poweroff", … */
 317                 assert(arg_action >= 0 && arg_action < _ACTION_MAX);
 318                 assert(action_table[arg_action].target);
 319                 assert(action_table[arg_action].mode);
 320
 321                 method = "StartUnit";
 322                 job_type = "start";
 323                 mode = action_table[arg_action].mode;
 324                 one_name = action_table[arg_action].target;
 325         }
 326
 327         if (one_name) {
 328                 names = strv_new(one_name);
 329                 if (!names)
 330                         return log_oom();
 331         } else if (!arg_marked) {
 332                 bool expanded;
 333
 334                 r = expand_unit_names(bus, strv_skip(argv, 1), suffix, &names, &expanded);
 335                 if (r < 0)
 336                         return log_error_errno(r, "Failed to expand names: %m");
 337
 338                 if (!arg_all && expanded && streq(job_type, "start") && !arg_quiet) {
 339                         log_warning("Warning: %ssystemctl start called with a glob pattern.%s",
 340                                     ansi_highlight_red(),
 341                                     ansi_normal());
 342                         log_notice("Hint: unit globs expand to loaded units, so start will usually have no effect.\n"
 343                                    "      Passing --all will also load units which are pulled in by other units.\n"
 344                                    "      See systemctl(1) for more details.");
 345                 }
 346         }
 347
 348         if (!arg_no_block) {
 349                 r = bus_wait_for_jobs_new(bus, &w);
 350                 if (r < 0)
 351                         return log_error_errno(r, "Could not watch jobs: %m");
 352         }
 353
 354         if (arg_wait) {
 355                 r = bus_call_method_async(bus, NULL, bus_systemd_mgr, "Subscribe", NULL, NULL, NULL);
 356                 if (r < 0)
 357                         return log_error_errno(r, "Failed to enable subscription: %m");
 358
 359                 r = bus_wait_for_units_new(bus, &wu);
 360                 if (r < 0)
 361                         return log_error_errno(r, "Failed to allocate unit watch context: %m");
 362         }
 363
 364         if (arg_marked)
 365                 ret = enqueue_marked_jobs(bus, w);
 366
 367         else
 368                 STRV_FOREACH(name, names) {
 369                         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 370
 371                         r = start_unit_one(bus, method, job_type, *name, mode, &error, w, wu);
 372                         if (ret == EXIT_SUCCESS && r < 0)
 373                                 ret = translate_bus_error_to_exit_status(r, &error);
 374
 375                         if (r >= 0 && streq(method, "StopUnit")) {
 376                                 r = strv_push(&stopped_units, *name);
 377                                 if (r < 0)
 378                                         return log_oom();
 379                         }
 380                 }
 381
 382         if (!arg_no_block) {
 383                 const char* extra_args[4];
 384
 385                 r = bus_wait_for_jobs(w, arg_quiet, make_extra_args(extra_args));
 386                 if (r < 0)
 387                         return r;
 388
 389                 /* When stopping units, warn if they can still be triggered by
 390                  * another active unit (socket, path, timer) */
 391                 if (!arg_quiet)
 392                         STRV_FOREACH(name, stopped_units)
 393                                 (void) check_triggering_units(bus, *name);
 394         }
 395
 396         if (arg_wait) {
 397                 r = bus_wait_for_units_run(wu);
 398                 if (r < 0)
 399                         return log_error_errno(r, "Failed to wait for units: %m");
 400                 if (r == BUS_WAIT_FAILURE && ret == EXIT_SUCCESS)
 401                         ret = EXIT_FAILURE;
 402         }
 403
 404         return ret;
 405 }