src/core/manager-serialize.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "clean-ipc.h"
   4 #include "dbus.h"
   5 #include "fd-util.h"
   6 #include "fileio.h"
   7 #include "format-util.h"
   8 #include "macro.h"
   9 #include "manager-serialize.h"
  10 #include "manager.h"
  11 #include "parse-util.h"
  12 #include "serialize.h"
  13 #include "syslog-util.h"
  14 #include "unit-serialize.h"
  15 #include "user-util.h"
  16
  17 int manager_open_serialization(Manager *m, FILE **ret_f) {
  18         _cleanup_close_ int fd = -1;
  19         FILE *f;
  20
  21         assert(ret_f);
  22
  23         fd = open_serialization_fd("systemd-state");
  24         if (fd < 0)
  25                 return fd;
  26
  27         f = take_fdopen(&fd, "w+");
  28         if (!f)
  29                 return -errno;
  30
  31         *ret_f = f;
  32         return 0;
  33 }
  34
  35 static bool manager_timestamp_shall_serialize(ManagerTimestamp t) {
  36         if (!in_initrd())
  37                 return true;
  38
  39         /* The following timestamps only apply to the host system, hence only serialize them there */
  40         return !IN_SET(t,
  41                        MANAGER_TIMESTAMP_USERSPACE, MANAGER_TIMESTAMP_FINISH,
  42                        MANAGER_TIMESTAMP_SECURITY_START, MANAGER_TIMESTAMP_SECURITY_FINISH,
  43                        MANAGER_TIMESTAMP_GENERATORS_START, MANAGER_TIMESTAMP_GENERATORS_FINISH,
  44                        MANAGER_TIMESTAMP_UNITS_LOAD_START, MANAGER_TIMESTAMP_UNITS_LOAD_FINISH);
  45 }
  46
  47 static void manager_serialize_uid_refs_internal(
  48                 FILE *f,
  49                 Hashmap *uid_refs,
  50                 const char *field_name) {
  51
  52         void *p, *k;
  53
  54         assert(f);
  55         assert(field_name);
  56
  57         /* Serialize the UID reference table. Or actually, just the IPC destruction flag of it, as
  58          * the actual counter of it is better rebuild after a reload/reexec. */
  59
  60         HASHMAP_FOREACH_KEY(p, k, uid_refs) {
  61                 uint32_t c;
  62                 uid_t uid;
  63
  64                 uid = PTR_TO_UID(k);
  65                 c = PTR_TO_UINT32(p);
  66
  67                 if (!(c & DESTROY_IPC_FLAG))
  68                         continue;
  69
  70                 (void) serialize_item_format(f, field_name, UID_FMT, uid);
  71         }
  72 }
  73
  74 static void manager_serialize_uid_refs(Manager *m, FILE *f) {
  75         manager_serialize_uid_refs_internal(f, m->uid_refs, "destroy-ipc-uid");
  76 }
  77
  78 static void manager_serialize_gid_refs(Manager *m, FILE *f) {
  79         manager_serialize_uid_refs_internal(f, m->gid_refs, "destroy-ipc-gid");
  80 }
  81
  82 int manager_serialize(
  83                 Manager *m,
  84                 FILE *f,
  85                 FDSet *fds,
  86                 bool switching_root) {
  87
  88         const char *t;
  89         Unit *u;
  90         int r;
  91
  92         assert(m);
  93         assert(f);
  94         assert(fds);
  95
  96         _cleanup_(manager_reloading_stopp) _unused_ Manager *reloading = manager_reloading_start(m);
  97
  98         (void) serialize_item_format(f, "current-job-id", "%" PRIu32, m->current_job_id);
  99         (void) serialize_item_format(f, "n-installed-jobs", "%u", m->n_installed_jobs);
 100         (void) serialize_item_format(f, "n-failed-jobs", "%u", m->n_failed_jobs);
 101         (void) serialize_bool(f, "taint-usr", m->taint_usr);
 102         (void) serialize_bool(f, "ready-sent", m->ready_sent);
 103         (void) serialize_bool(f, "taint-logged", m->taint_logged);
 104         (void) serialize_bool(f, "service-watchdogs", m->service_watchdogs);
 105
 106         /* After switching root, udevd has not been started yet. So, enumeration results should not be emitted. */
 107         (void) serialize_bool(f, "honor-device-enumeration", !switching_root);
 108
 109         if (m->show_status_overridden != _SHOW_STATUS_INVALID)
 110                 (void) serialize_item(f, "show-status-overridden",
 111                                       show_status_to_string(m->show_status_overridden));
 112
 113         if (m->log_level_overridden)
 114                 (void) serialize_item_format(f, "log-level-override", "%i", log_get_max_level());
 115         if (m->log_target_overridden)
 116                 (void) serialize_item(f, "log-target-override", log_target_to_string(log_get_target()));
 117
 118         (void) serialize_usec(f, "runtime-watchdog-overridden", m->watchdog_overridden[WATCHDOG_RUNTIME]);
 119         (void) serialize_usec(f, "reboot-watchdog-overridden", m->watchdog_overridden[WATCHDOG_REBOOT]);
 120         (void) serialize_usec(f, "kexec-watchdog-overridden", m->watchdog_overridden[WATCHDOG_KEXEC]);
 121
 122         for (ManagerTimestamp q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
 123                 _cleanup_free_ char *joined = NULL;
 124
 125                 if (!manager_timestamp_shall_serialize(q))
 126                         continue;
 127
 128                 joined = strjoin(manager_timestamp_to_string(q), "-timestamp");
 129                 if (!joined)
 130                         return log_oom();
 131
 132                 (void) serialize_dual_timestamp(f, joined, m->timestamps + q);
 133         }
 134
 135         if (!switching_root)
 136                 (void) serialize_strv(f, "env", m->client_environment);
 137
 138         if (m->notify_fd >= 0) {
 139                 r = serialize_fd(f, fds, "notify-fd", m->notify_fd);
 140                 if (r < 0)
 141                         return r;
 142
 143                 (void) serialize_item(f, "notify-socket", m->notify_socket);
 144         }
 145
 146         if (m->cgroups_agent_fd >= 0) {
 147                 r = serialize_fd(f, fds, "cgroups-agent-fd", m->cgroups_agent_fd);
 148                 if (r < 0)
 149                         return r;
 150         }
 151
 152         if (m->user_lookup_fds[0] >= 0) {
 153                 int copy0, copy1;
 154
 155                 copy0 = fdset_put_dup(fds, m->user_lookup_fds[0]);
 156                 if (copy0 < 0)
 157                         return log_error_errno(copy0, "Failed to add user lookup fd to serialization: %m");
 158
 159                 copy1 = fdset_put_dup(fds, m->user_lookup_fds[1]);
 160                 if (copy1 < 0)
 161                         return log_error_errno(copy1, "Failed to add user lookup fd to serialization: %m");
 162
 163                 (void) serialize_item_format(f, "user-lookup", "%i %i", copy0, copy1);
 164         }
 165
 166         bus_track_serialize(m->subscribed, f, "subscribed");
 167
 168         r = dynamic_user_serialize(m, f, fds);
 169         if (r < 0)
 170                 return r;
 171
 172         manager_serialize_uid_refs(m, f);
 173         manager_serialize_gid_refs(m, f);
 174
 175         r = exec_runtime_serialize(m, f, fds);
 176         if (r < 0)
 177                 return r;
 178
 179         (void) fputc('\n', f);
 180
 181         HASHMAP_FOREACH_KEY(u, t, m->units) {
 182                 if (u->id != t)
 183                         continue;
 184
 185                 r = unit_serialize(u, f, fds, switching_root);
 186                 if (r < 0)
 187                         return r;
 188         }
 189
 190         r = fflush_and_check(f);
 191         if (r < 0)
 192                 return log_error_errno(r, "Failed to flush serialization: %m");
 193
 194         r = bus_fdset_add_all(m, fds);
 195         if (r < 0)
 196                 return log_error_errno(r, "Failed to add bus sockets to serialization: %m");
 197
 198         return 0;
 199 }
 200
 201 static int manager_deserialize_one_unit(Manager *m, const char *name, FILE *f, FDSet *fds) {
 202         Unit *u;
 203         int r;
 204
 205         r = manager_load_unit(m, name, NULL, NULL, &u);
 206         if (r < 0) {
 207                 if (r == -ENOMEM)
 208                         return r;
 209                 return log_notice_errno(r, "Failed to load unit \"%s\", skipping deserialization: %m", name);
 210         }
 211
 212         r = unit_deserialize(u, f, fds);
 213         if (r < 0) {
 214                 if (r == -ENOMEM)
 215                         return r;
 216                 return log_notice_errno(r, "Failed to deserialize unit \"%s\", skipping: %m", name);
 217         }
 218
 219         return 0;
 220 }
 221
 222 static int manager_deserialize_units(Manager *m, FILE *f, FDSet *fds) {
 223         const char *unit_name;
 224         int r;
 225
 226         for (;;) {
 227                 _cleanup_free_ char *line = NULL;
 228                 /* Start marker */
 229                 r = read_line(f, LONG_LINE_MAX, &line);
 230                 if (r < 0)
 231                         return log_error_errno(r, "Failed to read serialization line: %m");
 232                 if (r == 0)
 233                         break;
 234
 235                 unit_name = strstrip(line);
 236
 237                 r = manager_deserialize_one_unit(m, unit_name, f, fds);
 238                 if (r == -ENOMEM)
 239                         return r;
 240                 if (r < 0) {
 241                         r = unit_deserialize_skip(f);
 242                         if (r < 0)
 243                                 return r;
 244                 }
 245         }
 246
 247         return 0;
 248 }
 249
 250 static void manager_deserialize_uid_refs_one_internal(
 251                 Hashmap** uid_refs,
 252                 const char *value) {
 253
 254         uid_t uid;
 255         uint32_t c;
 256         int r;
 257
 258         assert(uid_refs);
 259         assert(value);
 260
 261         r = parse_uid(value, &uid);
 262         if (r < 0 || uid == 0) {
 263                 log_debug("Unable to parse UID/GID reference serialization: " UID_FMT, uid);
 264                 return;
 265         }
 266
 267         if (hashmap_ensure_allocated(uid_refs, &trivial_hash_ops) < 0) {
 268                 log_oom();
 269                 return;
 270         }
 271
 272         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
 273         if (c & DESTROY_IPC_FLAG)
 274                 return;
 275
 276         c |= DESTROY_IPC_FLAG;
 277
 278         r = hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
 279         if (r < 0) {
 280                 log_debug_errno(r, "Failed to add UID/GID reference entry: %m");
 281                 return;
 282         }
 283 }
 284
 285 static void manager_deserialize_uid_refs_one(Manager *m, const char *value) {
 286         manager_deserialize_uid_refs_one_internal(&m->uid_refs, value);
 287 }
 288
 289 static void manager_deserialize_gid_refs_one(Manager *m, const char *value) {
 290         manager_deserialize_uid_refs_one_internal(&m->gid_refs, value);
 291 }
 292
 293 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
 294         int r = 0;
 295
 296         assert(m);
 297         assert(f);
 298
 299         if (DEBUG_LOGGING) {
 300                 if (fdset_isempty(fds))
 301                         log_debug("No file descriptors passed");
 302                 else {
 303                         int fd;
 304
 305                         FDSET_FOREACH(fd, fds) {
 306                                 _cleanup_free_ char *fn = NULL;
 307
 308                                 r = fd_get_path(fd, &fn);
 309                                 if (r < 0)
 310                                         log_debug_errno(r, "Received serialized fd %i → %m", fd);
 311                                 else
 312                                         log_debug("Received serialized fd %i → %s", fd, strna(fn));
 313                         }
 314                 }
 315         }
 316
 317         log_debug("Deserializing state...");
 318
 319         /* If we are not in reload mode yet, enter it now. Not that this is recursive, a caller might already have
 320          * increased it to non-zero, which is why we just increase it by one here and down again at the end of this
 321          * call. */
 322         _cleanup_(manager_reloading_stopp) _unused_ Manager *reloading = manager_reloading_start(m);
 323
 324         for (;;) {
 325                 _cleanup_free_ char *line = NULL;
 326                 const char *val, *l;
 327
 328                 r = read_line(f, LONG_LINE_MAX, &line);
 329                 if (r < 0)
 330                         return log_error_errno(r, "Failed to read serialization line: %m");
 331                 if (r == 0)
 332                         break;
 333
 334                 l = strstrip(line);
 335                 if (isempty(l)) /* end marker */
 336                         break;
 337
 338                 if ((val = startswith(l, "current-job-id="))) {
 339                         uint32_t id;
 340
 341                         if (safe_atou32(val, &id) < 0)
 342                                 log_notice("Failed to parse current job id value '%s', ignoring.", val);
 343                         else
 344                                 m->current_job_id = MAX(m->current_job_id, id);
 345
 346                 } else if ((val = startswith(l, "n-installed-jobs="))) {
 347                         uint32_t n;
 348
 349                         if (safe_atou32(val, &n) < 0)
 350                                 log_notice("Failed to parse installed jobs counter '%s', ignoring.", val);
 351                         else
 352                                 m->n_installed_jobs += n;
 353
 354                 } else if ((val = startswith(l, "n-failed-jobs="))) {
 355                         uint32_t n;
 356
 357                         if (safe_atou32(val, &n) < 0)
 358                                 log_notice("Failed to parse failed jobs counter '%s', ignoring.", val);
 359                         else
 360                                 m->n_failed_jobs += n;
 361
 362                 } else if ((val = startswith(l, "taint-usr="))) {
 363                         int b;
 364
 365                         b = parse_boolean(val);
 366                         if (b < 0)
 367                                 log_notice("Failed to parse taint /usr flag '%s', ignoring.", val);
 368                         else
 369                                 m->taint_usr = m->taint_usr || b;
 370
 371                 } else if ((val = startswith(l, "ready-sent="))) {
 372                         int b;
 373
 374                         b = parse_boolean(val);
 375                         if (b < 0)
 376                                 log_notice("Failed to parse ready-sent flag '%s', ignoring.", val);
 377                         else
 378                                 m->ready_sent = m->ready_sent || b;
 379
 380                 } else if ((val = startswith(l, "taint-logged="))) {
 381                         int b;
 382
 383                         b = parse_boolean(val);
 384                         if (b < 0)
 385                                 log_notice("Failed to parse taint-logged flag '%s', ignoring.", val);
 386                         else
 387                                 m->taint_logged = m->taint_logged || b;
 388
 389                 } else if ((val = startswith(l, "service-watchdogs="))) {
 390                         int b;
 391
 392                         b = parse_boolean(val);
 393                         if (b < 0)
 394                                 log_notice("Failed to parse service-watchdogs flag '%s', ignoring.", val);
 395                         else
 396                                 m->service_watchdogs = b;
 397
 398                 } else if ((val = startswith(l, "honor-device-enumeration="))) {
 399                         int b;
 400
 401                         b = parse_boolean(val);
 402                         if (b < 0)
 403                                 log_notice("Failed to parse honor-device-enumeration flag '%s', ignoring.", val);
 404                         else
 405                                 m->honor_device_enumeration = b;
 406
 407                 } else if ((val = startswith(l, "show-status-overridden="))) {
 408                         ShowStatus s;
 409
 410                         s = show_status_from_string(val);
 411                         if (s < 0)
 412                                 log_notice("Failed to parse show-status-overridden flag '%s', ignoring.", val);
 413                         else
 414                                 manager_override_show_status(m, s, "deserialize");
 415
 416                 } else if ((val = startswith(l, "log-level-override="))) {
 417                         int level;
 418
 419                         level = log_level_from_string(val);
 420                         if (level < 0)
 421                                 log_notice("Failed to parse log-level-override value '%s', ignoring.", val);
 422                         else
 423                                 manager_override_log_level(m, level);
 424
 425                 } else if ((val = startswith(l, "log-target-override="))) {
 426                         LogTarget target;
 427
 428                         target = log_target_from_string(val);
 429                         if (target < 0)
 430                                 log_notice("Failed to parse log-target-override value '%s', ignoring.", val);
 431                         else
 432                                 manager_override_log_target(m, target);
 433
 434                 } else if ((val = startswith(l, "runtime-watchdog-overridden="))) {
 435                         usec_t t;
 436
 437                         if (deserialize_usec(val, &t) < 0)
 438                                 log_notice("Failed to parse runtime-watchdog-overridden value '%s', ignoring.", val);
 439                         else
 440                                 manager_override_watchdog(m, WATCHDOG_RUNTIME, t);
 441
 442                 } else if ((val = startswith(l, "reboot-watchdog-overridden="))) {
 443                         usec_t t;
 444
 445                         if (deserialize_usec(val, &t) < 0)
 446                                 log_notice("Failed to parse reboot-watchdog-overridden value '%s', ignoring.", val);
 447                         else
 448                                 manager_override_watchdog(m, WATCHDOG_REBOOT, t);
 449
 450                 } else if ((val = startswith(l, "kexec-watchdog-overridden="))) {
 451                         usec_t t;
 452
 453                         if (deserialize_usec(val, &t) < 0)
 454                                 log_notice("Failed to parse kexec-watchdog-overridden value '%s', ignoring.", val);
 455                         else
 456                                 manager_override_watchdog(m, WATCHDOG_KEXEC, t);
 457
 458                 } else if (startswith(l, "env=")) {
 459                         r = deserialize_environment(l + 4, &m->client_environment);
 460                         if (r < 0)
 461                                 log_notice_errno(r, "Failed to parse environment entry: \"%s\", ignoring: %m", l);
 462
 463                 } else if ((val = startswith(l, "notify-fd="))) {
 464                         int fd;
 465
 466                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 467                                 log_notice("Failed to parse notify fd, ignoring: \"%s\"", val);
 468                         else {
 469                                 m->notify_event_source = sd_event_source_disable_unref(m->notify_event_source);
 470                                 safe_close(m->notify_fd);
 471                                 m->notify_fd = fdset_remove(fds, fd);
 472                         }
 473
 474                 } else if ((val = startswith(l, "notify-socket="))) {
 475                         r = free_and_strdup(&m->notify_socket, val);
 476                         if (r < 0)
 477                                 return r;
 478
 479                 } else if ((val = startswith(l, "cgroups-agent-fd="))) {
 480                         int fd;
 481
 482                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 483                                 log_notice("Failed to parse cgroups agent fd, ignoring.: %s", val);
 484                         else {
 485                                 m->cgroups_agent_event_source = sd_event_source_disable_unref(m->cgroups_agent_event_source);
 486                                 safe_close(m->cgroups_agent_fd);
 487                                 m->cgroups_agent_fd = fdset_remove(fds, fd);
 488                         }
 489
 490                 } else if ((val = startswith(l, "user-lookup="))) {
 491                         int fd0, fd1;
 492
 493                         if (sscanf(val, "%i %i", &fd0, &fd1) != 2 || fd0 < 0 || fd1 < 0 || fd0 == fd1 || !fdset_contains(fds, fd0) || !fdset_contains(fds, fd1))
 494                                 log_notice("Failed to parse user lookup fd, ignoring: %s", val);
 495                         else {
 496                                 m->user_lookup_event_source = sd_event_source_disable_unref(m->user_lookup_event_source);
 497                                 safe_close_pair(m->user_lookup_fds);
 498                                 m->user_lookup_fds[0] = fdset_remove(fds, fd0);
 499                                 m->user_lookup_fds[1] = fdset_remove(fds, fd1);
 500                         }
 501
 502                 } else if ((val = startswith(l, "dynamic-user=")))
 503                         dynamic_user_deserialize_one(m, val, fds);
 504                 else if ((val = startswith(l, "destroy-ipc-uid=")))
 505                         manager_deserialize_uid_refs_one(m, val);
 506                 else if ((val = startswith(l, "destroy-ipc-gid=")))
 507                         manager_deserialize_gid_refs_one(m, val);
 508                 else if ((val = startswith(l, "exec-runtime=")))
 509                         (void) exec_runtime_deserialize_one(m, val, fds);
 510                 else if ((val = startswith(l, "subscribed="))) {
 511
 512                         if (strv_extend(&m->deserialized_subscribed, val) < 0)
 513                                 return -ENOMEM;
 514
 515                 } else {
 516                         ManagerTimestamp q;
 517
 518                         for (q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
 519                                 val = startswith(l, manager_timestamp_to_string(q));
 520                                 if (!val)
 521                                         continue;
 522
 523                                 val = startswith(val, "-timestamp=");
 524                                 if (val)
 525                                         break;
 526                         }
 527
 528                         if (q < _MANAGER_TIMESTAMP_MAX) /* found it */
 529                                 (void) deserialize_dual_timestamp(val, m->timestamps + q);
 530                         else if (!startswith(l, "kdbus-fd=")) /* ignore kdbus */
 531                                 log_notice("Unknown serialization item '%s', ignoring.", l);
 532                 }
 533         }
 534
 535         return manager_deserialize_units(m, f, fds);
 536 }