src/machine/machined.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <errno.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6
   7 #include "sd-daemon.h"
   8
   9 #include "alloc-util.h"
  10 #include "bus-error.h"
  11 #include "bus-util.h"
  12 #include "cgroup-util.h"
  13 #include "dirent-util.h"
  14 #include "fd-util.h"
  15 #include "format-util.h"
  16 #include "hostname-util.h"
  17 #include "label.h"
  18 #include "machine-image.h"
  19 #include "machined.h"
  20 #include "process-util.h"
  21 #include "signal-util.h"
  22 #include "special.h"
  23
  24 static Manager* manager_unref(Manager *m);
  25 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_unref);
  26
  27 static int manager_new(Manager **ret) {
  28         _cleanup_(manager_unrefp) Manager *m = NULL;
  29         int r;
  30
  31         assert(ret);
  32
  33         m = new0(Manager, 1);
  34         if (!m)
  35                 return -ENOMEM;
  36
  37         m->machines = hashmap_new(&string_hash_ops);
  38         m->machine_units = hashmap_new(&string_hash_ops);
  39         m->machine_leaders = hashmap_new(NULL);
  40
  41         if (!m->machines || !m->machine_units || !m->machine_leaders)
  42                 return -ENOMEM;
  43
  44         r = sd_event_default(&m->event);
  45         if (r < 0)
  46                 return r;
  47
  48         r = sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
  49         if (r < 0)
  50                 return r;
  51
  52         r = sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
  53         if (r < 0)
  54                 return r;
  55
  56         (void) sd_event_set_watchdog(m->event, true);
  57
  58         *ret = TAKE_PTR(m);
  59         return 0;
  60 }
  61
  62 static Manager* manager_unref(Manager *m) {
  63         Machine *machine;
  64
  65         if (!m)
  66                 return NULL;
  67
  68         while (m->operations)
  69                 operation_free(m->operations);
  70
  71         assert(m->n_operations == 0);
  72
  73         while ((machine = hashmap_first(m->machines)))
  74                 machine_free(machine);
  75
  76         hashmap_free(m->machines);
  77         hashmap_free(m->machine_units);
  78         hashmap_free(m->machine_leaders);
  79
  80         hashmap_free_with_destructor(m->image_cache, image_unref);
  81
  82         sd_event_source_unref(m->image_cache_defer_event);
  83
  84         bus_verify_polkit_async_registry_free(m->polkit_registry);
  85
  86         sd_bus_unref(m->bus);
  87         sd_event_unref(m->event);
  88
  89         return mfree(m);
  90 }
  91
  92 static int manager_add_host_machine(Manager *m) {
  93         _cleanup_free_ char *rd = NULL, *unit = NULL;
  94         sd_id128_t mid;
  95         Machine *t;
  96         int r;
  97
  98         if (m->host_machine)
  99                 return 0;
 100
 101         r = sd_id128_get_machine(&mid);
 102         if (r < 0)
 103                 return log_error_errno(r, "Failed to get machine ID: %m");
 104
 105         rd = strdup("/");
 106         if (!rd)
 107                 return log_oom();
 108
 109         unit = strdup(SPECIAL_ROOT_SLICE);
 110         if (!unit)
 111                 return log_oom();
 112
 113         t = machine_new(m, MACHINE_HOST, ".host");
 114         if (!t)
 115                 return log_oom();
 116
 117         t->leader = 1;
 118         t->id = mid;
 119
 120         t->root_directory = TAKE_PTR(rd);
 121         t->unit = TAKE_PTR(unit);
 122
 123         dual_timestamp_from_boottime_or_monotonic(&t->timestamp, 0);
 124
 125         m->host_machine = t;
 126
 127         return 0;
 128 }
 129
 130 static int manager_enumerate_machines(Manager *m) {
 131         _cleanup_closedir_ DIR *d = NULL;
 132         struct dirent *de;
 133         int r = 0;
 134
 135         assert(m);
 136
 137         r = manager_add_host_machine(m);
 138         if (r < 0)
 139                 return r;
 140
 141         /* Read in machine data stored on disk */
 142         d = opendir("/run/systemd/machines");
 143         if (!d) {
 144                 if (errno == ENOENT)
 145                         return 0;
 146
 147                 return log_error_errno(errno, "Failed to open /run/systemd/machines: %m");
 148         }
 149
 150         FOREACH_DIRENT(de, d, return -errno) {
 151                 struct Machine *machine;
 152                 int k;
 153
 154                 if (!dirent_is_file(de))
 155                         continue;
 156
 157                 /* Ignore symlinks that map the unit name to the machine */
 158                 if (startswith(de->d_name, "unit:"))
 159                         continue;
 160
 161                 if (!machine_name_is_valid(de->d_name))
 162                         continue;
 163
 164                 k = manager_add_machine(m, de->d_name, &machine);
 165                 if (k < 0) {
 166                         r = log_error_errno(k, "Failed to add machine by file name %s: %m", de->d_name);
 167                         continue;
 168                 }
 169
 170                 machine_add_to_gc_queue(machine);
 171
 172                 k = machine_load(machine);
 173                 if (k < 0)
 174                         r = k;
 175         }
 176
 177         return r;
 178 }
 179
 180 static int manager_connect_bus(Manager *m) {
 181         int r;
 182
 183         assert(m);
 184         assert(!m->bus);
 185
 186         r = sd_bus_default_system(&m->bus);
 187         if (r < 0)
 188                 return log_error_errno(r, "Failed to connect to system bus: %m");
 189
 190         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/machine1", "org.freedesktop.machine1.Manager", manager_vtable, m);
 191         if (r < 0)
 192                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 193
 194         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/machine1/machine", "org.freedesktop.machine1.Machine", machine_vtable, machine_object_find, m);
 195         if (r < 0)
 196                 return log_error_errno(r, "Failed to add machine object vtable: %m");
 197
 198         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/machine1/machine", machine_node_enumerator, m);
 199         if (r < 0)
 200                 return log_error_errno(r, "Failed to add machine enumerator: %m");
 201
 202         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/machine1/image", "org.freedesktop.machine1.Image", image_vtable, image_object_find, m);
 203         if (r < 0)
 204                 return log_error_errno(r, "Failed to add image object vtable: %m");
 205
 206         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/machine1/image", image_node_enumerator, m);
 207         if (r < 0)
 208                 return log_error_errno(r, "Failed to add image enumerator: %m");
 209
 210         r = sd_bus_match_signal_async(
 211                         m->bus,
 212                         NULL,
 213                         "org.freedesktop.systemd1",
 214                         "/org/freedesktop/systemd1",
 215                         "org.freedesktop.systemd1.Manager",
 216                         "JobRemoved",
 217                         match_job_removed, NULL, m);
 218         if (r < 0)
 219                 return log_error_errno(r, "Failed to add match for JobRemoved: %m");
 220
 221         r = sd_bus_match_signal_async(
 222                         m->bus,
 223                         NULL,
 224                         "org.freedesktop.systemd1",
 225                         "/org/freedesktop/systemd1",
 226                         "org.freedesktop.systemd1.Manager",
 227                         "UnitRemoved",
 228                         match_unit_removed, NULL, m);
 229         if (r < 0)
 230                 return log_error_errno(r, "Failed to request match for UnitRemoved: %m");
 231
 232         r = sd_bus_match_signal_async(
 233                         m->bus,
 234                         NULL,
 235                         "org.freedesktop.systemd1",
 236                         NULL,
 237                         "org.freedesktop.DBus.Properties",
 238                         "PropertiesChanged",
 239                         match_properties_changed, NULL, m);
 240         if (r < 0)
 241                 return log_error_errno(r, "Failed to request match for PropertiesChanged: %m");
 242
 243         r = sd_bus_match_signal_async(
 244                         m->bus,
 245                         NULL,
 246                         "org.freedesktop.systemd1",
 247                         "/org/freedesktop/systemd1",
 248                         "org.freedesktop.systemd1.Manager",
 249                         "Reloading",
 250                         match_reloading, NULL, m);
 251         if (r < 0)
 252                 return log_error_errno(r, "Failed to request match for Reloading: %m");
 253
 254         r = sd_bus_call_method_async(
 255                         m->bus,
 256                         NULL,
 257                         "org.freedesktop.systemd1",
 258                         "/org/freedesktop/systemd1",
 259                         "org.freedesktop.systemd1.Manager",
 260                         "Subscribe",
 261                         NULL, NULL,
 262                         NULL);
 263         if (r < 0)
 264                 return log_error_errno(r, "Failed to enable subscription: %m");
 265
 266         r = sd_bus_request_name_async(m->bus, NULL, "org.freedesktop.machine1", 0, NULL, NULL);
 267         if (r < 0)
 268                 return log_error_errno(r, "Failed to request name: %m");
 269
 270         r = sd_bus_attach_event(m->bus, m->event, 0);
 271         if (r < 0)
 272                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 273
 274         return 0;
 275 }
 276
 277 static void manager_gc(Manager *m, bool drop_not_started) {
 278         Machine *machine;
 279
 280         assert(m);
 281
 282         while ((machine = m->machine_gc_queue)) {
 283                 LIST_REMOVE(gc_queue, m->machine_gc_queue, machine);
 284                 machine->in_gc_queue = false;
 285
 286                 /* First, if we are not closing yet, initiate stopping */
 287                 if (machine_may_gc(machine, drop_not_started) &&
 288                     machine_get_state(machine) != MACHINE_CLOSING)
 289                         machine_stop(machine);
 290
 291                 /* Now, the stop probably made this referenced
 292                  * again, but if it didn't, then it's time to let it
 293                  * go entirely. */
 294                 if (machine_may_gc(machine, drop_not_started)) {
 295                         machine_finalize(machine);
 296                         machine_free(machine);
 297                 }
 298         }
 299 }
 300
 301 static int manager_startup(Manager *m) {
 302         Machine *machine;
 303         Iterator i;
 304         int r;
 305
 306         assert(m);
 307
 308         /* Connect to the bus */
 309         r = manager_connect_bus(m);
 310         if (r < 0)
 311                 return r;
 312
 313         /* Deserialize state */
 314         manager_enumerate_machines(m);
 315
 316         /* Remove stale objects before we start them */
 317         manager_gc(m, false);
 318
 319         /* And start everything */
 320         HASHMAP_FOREACH(machine, m->machines, i)
 321                 machine_start(machine, NULL, NULL);
 322
 323         return 0;
 324 }
 325
 326 static bool check_idle(void *userdata) {
 327         Manager *m = userdata;
 328
 329         if (m->operations)
 330                 return false;
 331
 332         manager_gc(m, true);
 333
 334         return hashmap_isempty(m->machines);
 335 }
 336
 337 static int manager_run(Manager *m) {
 338         assert(m);
 339
 340         return bus_event_loop_with_idle(
 341                         m->event,
 342                         m->bus,
 343                         "org.freedesktop.machine1",
 344                         DEFAULT_EXIT_USEC,
 345                         check_idle, m);
 346 }
 347
 348 int main(int argc, char *argv[]) {
 349         _cleanup_(manager_unrefp) Manager *m = NULL;
 350         int r;
 351
 352         log_set_target(LOG_TARGET_AUTO);
 353         log_set_facility(LOG_AUTH);
 354         log_parse_environment();
 355         log_open();
 356
 357         umask(0022);
 358
 359         if (argc != 1) {
 360                 log_error("This program takes no arguments.");
 361                 r = -EINVAL;
 362                 goto finish;
 363         }
 364
 365         /* Always create the directories people can create inotify watches in. Note that some applications might check
 366          * for the existence of /run/systemd/machines/ to determine whether machined is available, so please always
 367          * make sure this check stays in. */
 368         (void) mkdir_label("/run/systemd/machines", 0755);
 369
 370         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, SIGTERM, SIGINT, -1) >= 0);
 371
 372         r = manager_new(&m);
 373         if (r < 0) {
 374                 log_error_errno(r, "Failed to allocate manager object: %m");
 375                 goto finish;
 376         }
 377
 378         r = manager_startup(m);
 379         if (r < 0) {
 380                 log_error_errno(r, "Failed to fully start up daemon: %m");
 381                 goto finish;
 382         }
 383
 384         log_debug("systemd-machined running as pid "PID_FMT, getpid_cached());
 385
 386         (void) sd_notify(false,
 387                          "READY=1\n"
 388                          "STATUS=Processing requests...");
 389
 390         r = manager_run(m);
 391
 392         log_debug("systemd-machined stopped as pid "PID_FMT, getpid_cached());
 393
 394         (void) sd_notify(false,
 395                          "STOPPING=1\n"
 396                          "STATUS=Shutting down...");
 397
 398 finish:
 399         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 400 }