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         if (m->show_status_overridden != _SHOW_STATUS_INVALID)
 107                 (void) serialize_item(f, "show-status-overridden",
 108                                       show_status_to_string(m->show_status_overridden));
 109
 110         if (m->log_level_overridden)
 111                 (void) serialize_item_format(f, "log-level-override", "%i", log_get_max_level());
 112         if (m->log_target_overridden)
 113                 (void) serialize_item(f, "log-target-override", log_target_to_string(log_get_target()));
 114
 115         (void) serialize_usec(f, "runtime-watchdog-overridden", m->watchdog_overridden[WATCHDOG_RUNTIME]);
 116         (void) serialize_usec(f, "reboot-watchdog-overridden", m->watchdog_overridden[WATCHDOG_REBOOT]);
 117         (void) serialize_usec(f, "kexec-watchdog-overridden", m->watchdog_overridden[WATCHDOG_KEXEC]);
 118         (void) serialize_usec(f, "pretimeout-watchdog-overridden", m->watchdog_overridden[WATCHDOG_PRETIMEOUT]);
 119         (void) serialize_item(f, "pretimeout-watchdog-governor-overridden", m->watchdog_pretimeout_governor_overridden);
 120
 121         for (ManagerTimestamp q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
 122                 _cleanup_free_ char *joined = NULL;
 123
 124                 if (!manager_timestamp_shall_serialize(q))
 125                         continue;
 126
 127                 joined = strjoin(manager_timestamp_to_string(q), "-timestamp");
 128                 if (!joined)
 129                         return log_oom();
 130
 131                 (void) serialize_dual_timestamp(f, joined, m->timestamps + q);
 132         }
 133
 134         if (!switching_root)
 135                 (void) serialize_strv(f, "env", m->client_environment);
 136
 137         if (m->notify_fd >= 0) {
 138                 r = serialize_fd(f, fds, "notify-fd", m->notify_fd);
 139                 if (r < 0)
 140                         return r;
 141
 142                 (void) serialize_item(f, "notify-socket", m->notify_socket);
 143         }
 144
 145         if (m->cgroups_agent_fd >= 0) {
 146                 r = serialize_fd(f, fds, "cgroups-agent-fd", m->cgroups_agent_fd);
 147                 if (r < 0)
 148                         return r;
 149         }
 150
 151         if (m->user_lookup_fds[0] >= 0) {
 152                 int copy0, copy1;
 153
 154                 copy0 = fdset_put_dup(fds, m->user_lookup_fds[0]);
 155                 if (copy0 < 0)
 156                         return log_error_errno(copy0, "Failed to add user lookup fd to serialization: %m");
 157
 158                 copy1 = fdset_put_dup(fds, m->user_lookup_fds[1]);
 159                 if (copy1 < 0)
 160                         return log_error_errno(copy1, "Failed to add user lookup fd to serialization: %m");
 161
 162                 (void) serialize_item_format(f, "user-lookup", "%i %i", copy0, copy1);
 163         }
 164
 165         bus_track_serialize(m->subscribed, f, "subscribed");
 166
 167         r = dynamic_user_serialize(m, f, fds);
 168         if (r < 0)
 169                 return r;
 170
 171         manager_serialize_uid_refs(m, f);
 172         manager_serialize_gid_refs(m, f);
 173
 174         r = exec_runtime_serialize(m, f, fds);
 175         if (r < 0)
 176                 return r;
 177
 178         (void) fputc('\n', f);
 179
 180         HASHMAP_FOREACH_KEY(u, t, m->units) {
 181                 if (u->id != t)
 182                         continue;
 183
 184                 r = unit_serialize(u, f, fds, switching_root);
 185                 if (r < 0)
 186                         return r;
 187         }
 188
 189         r = fflush_and_check(f);
 190         if (r < 0)
 191                 return log_error_errno(r, "Failed to flush serialization: %m");
 192
 193         r = bus_fdset_add_all(m, fds);
 194         if (r < 0)
 195                 return log_error_errno(r, "Failed to add bus sockets to serialization: %m");
 196
 197         return 0;
 198 }
 199
 200 static int manager_deserialize_one_unit(Manager *m, const char *name, FILE *f, FDSet *fds) {
 201         Unit *u;
 202         int r;
 203
 204         r = manager_load_unit(m, name, NULL, NULL, &u);
 205         if (r < 0) {
 206                 if (r == -ENOMEM)
 207                         return r;
 208                 return log_notice_errno(r, "Failed to load unit \"%s\", skipping deserialization: %m", name);
 209         }
 210
 211         r = unit_deserialize(u, f, fds);
 212         if (r < 0) {
 213                 if (r == -ENOMEM)
 214                         return r;
 215                 return log_notice_errno(r, "Failed to deserialize unit \"%s\", skipping: %m", name);
 216         }
 217
 218         return 0;
 219 }
 220
 221 static int manager_deserialize_units(Manager *m, FILE *f, FDSet *fds) {
 222         const char *unit_name;
 223         int r;
 224
 225         for (;;) {
 226                 _cleanup_free_ char *line = NULL;
 227                 /* Start marker */
 228                 r = read_line(f, LONG_LINE_MAX, &line);
 229                 if (r < 0)
 230                         return log_error_errno(r, "Failed to read serialization line: %m");
 231                 if (r == 0)
 232                         break;
 233
 234                 unit_name = strstrip(line);
 235
 236                 r = manager_deserialize_one_unit(m, unit_name, f, fds);
 237                 if (r == -ENOMEM)
 238                         return r;
 239                 if (r < 0) {
 240                         r = unit_deserialize_skip(f);
 241                         if (r < 0)
 242                                 return r;
 243                 }
 244         }
 245
 246         return 0;
 247 }
 248
 249 static void manager_deserialize_uid_refs_one_internal(
 250                 Hashmap** uid_refs,
 251                 const char *value) {
 252
 253         uid_t uid;
 254         uint32_t c;
 255         int r;
 256
 257         assert(uid_refs);
 258         assert(value);
 259
 260         r = parse_uid(value, &uid);
 261         if (r < 0 || uid == 0) {
 262                 log_debug("Unable to parse UID/GID reference serialization: " UID_FMT, uid);
 263                 return;
 264         }
 265
 266         if (hashmap_ensure_allocated(uid_refs, &trivial_hash_ops) < 0) {
 267                 log_oom();
 268                 return;
 269         }
 270
 271         c = PTR_TO_UINT32(hashmap_get(*uid_refs, UID_TO_PTR(uid)));
 272         if (c & DESTROY_IPC_FLAG)
 273                 return;
 274
 275         c |= DESTROY_IPC_FLAG;
 276
 277         r = hashmap_replace(*uid_refs, UID_TO_PTR(uid), UINT32_TO_PTR(c));
 278         if (r < 0) {
 279                 log_debug_errno(r, "Failed to add UID/GID reference entry: %m");
 280                 return;
 281         }
 282 }
 283
 284 static void manager_deserialize_uid_refs_one(Manager *m, const char *value) {
 285         manager_deserialize_uid_refs_one_internal(&m->uid_refs, value);
 286 }
 287
 288 static void manager_deserialize_gid_refs_one(Manager *m, const char *value) {
 289         manager_deserialize_uid_refs_one_internal(&m->gid_refs, value);
 290 }
 291
 292 int manager_deserialize(Manager *m, FILE *f, FDSet *fds) {
 293         int r = 0;
 294
 295         assert(m);
 296         assert(f);
 297
 298         if (DEBUG_LOGGING) {
 299                 if (fdset_isempty(fds))
 300                         log_debug("No file descriptors passed");
 301                 else {
 302                         int fd;
 303
 304                         FDSET_FOREACH(fd, fds) {
 305                                 _cleanup_free_ char *fn = NULL;
 306
 307                                 r = fd_get_path(fd, &fn);
 308                                 if (r < 0)
 309                                         log_debug_errno(r, "Received serialized fd %i %s %m",
 310                                                         fd, special_glyph(SPECIAL_GLYPH_ARROW_RIGHT));
 311                                 else
 312                                         log_debug("Received serialized fd %i %s %s",
 313                                                   fd, special_glyph(SPECIAL_GLYPH_ARROW_RIGHT), strna(fn));
 314                         }
 315                 }
 316         }
 317
 318         log_debug("Deserializing state...");
 319
 320         /* If we are not in reload mode yet, enter it now. Not that this is recursive, a caller might already have
 321          * increased it to non-zero, which is why we just increase it by one here and down again at the end of this
 322          * call. */
 323         _cleanup_(manager_reloading_stopp) _unused_ Manager *reloading = manager_reloading_start(m);
 324
 325         for (;;) {
 326                 _cleanup_free_ char *line = NULL;
 327                 const char *val, *l;
 328
 329                 r = read_line(f, LONG_LINE_MAX, &line);
 330                 if (r < 0)
 331                         return log_error_errno(r, "Failed to read serialization line: %m");
 332                 if (r == 0)
 333                         break;
 334
 335                 l = strstrip(line);
 336                 if (isempty(l)) /* end marker */
 337                         break;
 338
 339                 if ((val = startswith(l, "current-job-id="))) {
 340                         uint32_t id;
 341
 342                         if (safe_atou32(val, &id) < 0)
 343                                 log_notice("Failed to parse current job id value '%s', ignoring.", val);
 344                         else
 345                                 m->current_job_id = MAX(m->current_job_id, id);
 346
 347                 } else if ((val = startswith(l, "n-installed-jobs="))) {
 348                         uint32_t n;
 349
 350                         if (safe_atou32(val, &n) < 0)
 351                                 log_notice("Failed to parse installed jobs counter '%s', ignoring.", val);
 352                         else
 353                                 m->n_installed_jobs += n;
 354
 355                 } else if ((val = startswith(l, "n-failed-jobs="))) {
 356                         uint32_t n;
 357
 358                         if (safe_atou32(val, &n) < 0)
 359                                 log_notice("Failed to parse failed jobs counter '%s', ignoring.", val);
 360                         else
 361                                 m->n_failed_jobs += n;
 362
 363                 } else if ((val = startswith(l, "taint-usr="))) {
 364                         int b;
 365
 366                         b = parse_boolean(val);
 367                         if (b < 0)
 368                                 log_notice("Failed to parse taint /usr flag '%s', ignoring.", val);
 369                         else
 370                                 m->taint_usr = m->taint_usr || b;
 371
 372                 } else if ((val = startswith(l, "ready-sent="))) {
 373                         int b;
 374
 375                         b = parse_boolean(val);
 376                         if (b < 0)
 377                                 log_notice("Failed to parse ready-sent flag '%s', ignoring.", val);
 378                         else
 379                                 m->ready_sent = m->ready_sent || b;
 380
 381                 } else if ((val = startswith(l, "taint-logged="))) {
 382                         int b;
 383
 384                         b = parse_boolean(val);
 385                         if (b < 0)
 386                                 log_notice("Failed to parse taint-logged flag '%s', ignoring.", val);
 387                         else
 388                                 m->taint_logged = m->taint_logged || b;
 389
 390                 } else if ((val = startswith(l, "service-watchdogs="))) {
 391                         int b;
 392
 393                         b = parse_boolean(val);
 394                         if (b < 0)
 395                                 log_notice("Failed to parse service-watchdogs flag '%s', ignoring.", val);
 396                         else
 397                                 m->service_watchdogs = b;
 398
 399                 } else if ((val = startswith(l, "show-status-overridden="))) {
 400                         ShowStatus s;
 401
 402                         s = show_status_from_string(val);
 403                         if (s < 0)
 404                                 log_notice("Failed to parse show-status-overridden flag '%s', ignoring.", val);
 405                         else
 406                                 manager_override_show_status(m, s, "deserialize");
 407
 408                 } else if ((val = startswith(l, "log-level-override="))) {
 409                         int level;
 410
 411                         level = log_level_from_string(val);
 412                         if (level < 0)
 413                                 log_notice("Failed to parse log-level-override value '%s', ignoring.", val);
 414                         else
 415                                 manager_override_log_level(m, level);
 416
 417                 } else if ((val = startswith(l, "log-target-override="))) {
 418                         LogTarget target;
 419
 420                         target = log_target_from_string(val);
 421                         if (target < 0)
 422                                 log_notice("Failed to parse log-target-override value '%s', ignoring.", val);
 423                         else
 424                                 manager_override_log_target(m, target);
 425
 426                 } else if ((val = startswith(l, "runtime-watchdog-overridden="))) {
 427                         usec_t t;
 428
 429                         if (deserialize_usec(val, &t) < 0)
 430                                 log_notice("Failed to parse runtime-watchdog-overridden value '%s', ignoring.", val);
 431                         else
 432                                 manager_override_watchdog(m, WATCHDOG_RUNTIME, t);
 433
 434                 } else if ((val = startswith(l, "reboot-watchdog-overridden="))) {
 435                         usec_t t;
 436
 437                         if (deserialize_usec(val, &t) < 0)
 438                                 log_notice("Failed to parse reboot-watchdog-overridden value '%s', ignoring.", val);
 439                         else
 440                                 manager_override_watchdog(m, WATCHDOG_REBOOT, t);
 441
 442                 } else if ((val = startswith(l, "kexec-watchdog-overridden="))) {
 443                         usec_t t;
 444
 445                         if (deserialize_usec(val, &t) < 0)
 446                                 log_notice("Failed to parse kexec-watchdog-overridden value '%s', ignoring.", val);
 447                         else
 448                                 manager_override_watchdog(m, WATCHDOG_KEXEC, t);
 449
 450                 } else if ((val = startswith(l, "pretimeout-watchdog-overridden="))) {
 451                         usec_t t;
 452
 453                         if (deserialize_usec(val, &t) < 0)
 454                                 log_notice("Failed to parse pretimeout-watchdog-overridden value '%s', ignoring.", val);
 455                         else
 456                                 manager_override_watchdog(m, WATCHDOG_PRETIMEOUT, t);
 457
 458                 } else if ((val = startswith(l, "pretimeout-watchdog-governor-overridden="))) {
 459                         r = free_and_strdup(&m->watchdog_pretimeout_governor_overridden, val);
 460                         if (r < 0)
 461                                 return r;
 462
 463                 } else if (startswith(l, "env=")) {
 464                         r = deserialize_environment(l + 4, &m->client_environment);
 465                         if (r < 0)
 466                                 log_notice_errno(r, "Failed to parse environment entry: \"%s\", ignoring: %m", l);
 467
 468                 } else if ((val = startswith(l, "notify-fd="))) {
 469                         int fd;
 470
 471                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 472                                 log_notice("Failed to parse notify fd, ignoring: \"%s\"", val);
 473                         else {
 474                                 m->notify_event_source = sd_event_source_disable_unref(m->notify_event_source);
 475                                 safe_close(m->notify_fd);
 476                                 m->notify_fd = fdset_remove(fds, fd);
 477                         }
 478
 479                 } else if ((val = startswith(l, "notify-socket="))) {
 480                         r = free_and_strdup(&m->notify_socket, val);
 481                         if (r < 0)
 482                                 return r;
 483
 484                 } else if ((val = startswith(l, "cgroups-agent-fd="))) {
 485                         int fd;
 486
 487                         if (safe_atoi(val, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 488                                 log_notice("Failed to parse cgroups agent fd, ignoring.: %s", val);
 489                         else {
 490                                 m->cgroups_agent_event_source = sd_event_source_disable_unref(m->cgroups_agent_event_source);
 491                                 safe_close(m->cgroups_agent_fd);
 492                                 m->cgroups_agent_fd = fdset_remove(fds, fd);
 493                         }
 494
 495                 } else if ((val = startswith(l, "user-lookup="))) {
 496                         int fd0, fd1;
 497
 498                         if (sscanf(val, "%i %i", &fd0, &fd1) != 2 || fd0 < 0 || fd1 < 0 || fd0 == fd1 || !fdset_contains(fds, fd0) || !fdset_contains(fds, fd1))
 499                                 log_notice("Failed to parse user lookup fd, ignoring: %s", val);
 500                         else {
 501                                 m->user_lookup_event_source = sd_event_source_disable_unref(m->user_lookup_event_source);
 502                                 safe_close_pair(m->user_lookup_fds);
 503                                 m->user_lookup_fds[0] = fdset_remove(fds, fd0);
 504                                 m->user_lookup_fds[1] = fdset_remove(fds, fd1);
 505                         }
 506
 507                 } else if ((val = startswith(l, "dynamic-user=")))
 508                         dynamic_user_deserialize_one(m, val, fds);
 509                 else if ((val = startswith(l, "destroy-ipc-uid=")))
 510                         manager_deserialize_uid_refs_one(m, val);
 511                 else if ((val = startswith(l, "destroy-ipc-gid=")))
 512                         manager_deserialize_gid_refs_one(m, val);
 513                 else if ((val = startswith(l, "exec-runtime=")))
 514                         (void) exec_runtime_deserialize_one(m, val, fds);
 515                 else if ((val = startswith(l, "subscribed="))) {
 516
 517                         if (strv_extend(&m->deserialized_subscribed, val) < 0)
 518                                 return -ENOMEM;
 519
 520                 } else {
 521                         ManagerTimestamp q;
 522
 523                         for (q = 0; q < _MANAGER_TIMESTAMP_MAX; q++) {
 524                                 val = startswith(l, manager_timestamp_to_string(q));
 525                                 if (!val)
 526                                         continue;
 527
 528                                 val = startswith(val, "-timestamp=");
 529                                 if (val)
 530                                         break;
 531                         }
 532
 533                         if (q < _MANAGER_TIMESTAMP_MAX) /* found it */
 534                                 (void) deserialize_dual_timestamp(val, m->timestamps + q);
 535                         else if (!STARTSWITH_SET(l, "kdbus-fd=", "honor-device-enumeration=")) /* ignore deprecated values */
 536                                 log_notice("Unknown serialization item '%s', ignoring.", l);
 537                 }
 538         }
 539
 540         return manager_deserialize_units(m, f, fds);
 541 }