src/core/swap.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <limits.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <sys/epoll.h>
  27 #include <sys/stat.h>
  28 #include <sys/swap.h>
  29 #include <libudev.h>
  30
  31 #include "unit.h"
  32 #include "swap.h"
  33 #include "load-fragment.h"
  34 #include "load-dropin.h"
  35 #include "unit-name.h"
  36 #include "dbus-swap.h"
  37 #include "special.h"
  38 #include "bus-errors.h"
  39 #include "exit-status.h"
  40 #include "def.h"
  41 #include "path-util.h"
  42 #include "virt.h"
  43 #include "udev-util.h"
  44
  45 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
  46         [SWAP_DEAD] = UNIT_INACTIVE,
  47         [SWAP_ACTIVATING] = UNIT_ACTIVATING,
  48         [SWAP_ACTIVATING_DONE] = UNIT_ACTIVE,
  49         [SWAP_ACTIVE] = UNIT_ACTIVE,
  50         [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
  51         [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
  52         [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
  53         [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
  54         [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
  55         [SWAP_FAILED] = UNIT_FAILED
  56 };
  57
  58 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  59 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  60
  61 static void swap_unset_proc_swaps(Swap *s) {
  62         assert(s);
  63
  64         if (!s->from_proc_swaps)
  65                 return;
  66
  67         free(s->parameters_proc_swaps.what);
  68         s->parameters_proc_swaps.what = NULL;
  69
  70         s->from_proc_swaps = false;
  71 }
  72
  73 static int swap_set_devnode(Swap *s, const char *devnode) {
  74         Hashmap *swaps;
  75         Swap *first;
  76         int r;
  77
  78         assert(s);
  79
  80         r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, string_hash_func, string_compare_func);
  81         if (r < 0)
  82                 return r;
  83
  84         swaps = UNIT(s)->manager->swaps_by_devnode;
  85
  86         if (s->devnode) {
  87                 first = hashmap_get(swaps, s->devnode);
  88
  89                 LIST_REMOVE(same_devnode, first, s);
  90                 if (first)
  91                         hashmap_replace(swaps, first->devnode, first);
  92                 else
  93                         hashmap_remove(swaps, s->devnode);
  94
  95                 free(s->devnode);
  96                 s->devnode = NULL;
  97         }
  98
  99         if (devnode) {
 100                 s->devnode = strdup(devnode);
 101                 if (!s->devnode)
 102                         return -ENOMEM;
 103
 104                 first = hashmap_get(swaps, s->devnode);
 105                 LIST_PREPEND(same_devnode, first, s);
 106
 107                 return hashmap_replace(swaps, first->devnode, first);
 108         }
 109
 110         return 0;
 111 }
 112
 113 static void swap_init(Unit *u) {
 114         Swap *s = SWAP(u);
 115
 116         assert(s);
 117         assert(UNIT(s)->load_state == UNIT_STUB);
 118
 119         s->timeout_usec = u->manager->default_timeout_start_usec;
 120
 121         exec_context_init(&s->exec_context);
 122         s->exec_context.std_output = u->manager->default_std_output;
 123         s->exec_context.std_error = u->manager->default_std_error;
 124         kill_context_init(&s->kill_context);
 125         cgroup_context_init(&s->cgroup_context);
 126
 127         s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
 128
 129         s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 130
 131         u->ignore_on_isolate = true;
 132 }
 133
 134 static void swap_unwatch_control_pid(Swap *s) {
 135         assert(s);
 136
 137         if (s->control_pid <= 0)
 138                 return;
 139
 140         unit_unwatch_pid(UNIT(s), s->control_pid);
 141         s->control_pid = 0;
 142 }
 143
 144 static void swap_done(Unit *u) {
 145         Swap *s = SWAP(u);
 146
 147         assert(s);
 148
 149         swap_unset_proc_swaps(s);
 150         swap_set_devnode(s, NULL);
 151
 152         free(s->what);
 153         s->what = NULL;
 154
 155         free(s->parameters_fragment.what);
 156         s->parameters_fragment.what = NULL;
 157
 158         exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
 159         exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
 160         s->control_command = NULL;
 161
 162         cgroup_context_done(&s->cgroup_context);
 163
 164         swap_unwatch_control_pid(s);
 165
 166         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 167 }
 168
 169 static int swap_arm_timer(Swap *s) {
 170         int r;
 171
 172         assert(s);
 173
 174         if (s->timeout_usec <= 0) {
 175                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 176                 return 0;
 177         }
 178
 179         if (s->timer_event_source) {
 180                 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
 181                 if (r < 0)
 182                         return r;
 183
 184                 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
 185         }
 186
 187         return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, swap_dispatch_timer, s, &s->timer_event_source);
 188 }
 189
 190 static int swap_add_device_links(Swap *s) {
 191         SwapParameters *p;
 192
 193         assert(s);
 194
 195         if (!s->what)
 196                 return 0;
 197
 198         if (s->from_fragment)
 199                 p = &s->parameters_fragment;
 200         else
 201                 return 0;
 202
 203         if (is_device_path(s->what))
 204                 return unit_add_node_link(UNIT(s), s->what, !p->noauto && UNIT(s)->manager->running_as == SYSTEMD_SYSTEM);
 205         else
 206                 /* File based swap devices need to be ordered after
 207                  * systemd-remount-fs.service, since they might need a
 208                  * writable file system. */
 209                 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
 210 }
 211
 212 static int swap_add_default_dependencies(Swap *s) {
 213         bool nofail = false, noauto = false;
 214         int r;
 215
 216         assert(s);
 217
 218         if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
 219                 return 0;
 220
 221         if (detect_container(NULL) > 0)
 222                 return 0;
 223
 224         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
 225         if (r < 0)
 226                 return r;
 227
 228         if (s->from_fragment) {
 229                 SwapParameters *p = &s->parameters_fragment;
 230
 231                 nofail = p->nofail;
 232                 noauto = p->noauto;
 233         }
 234
 235         if (!noauto) {
 236                 if (nofail)
 237                         r = unit_add_dependency_by_name_inverse(UNIT(s), UNIT_WANTS, SPECIAL_SWAP_TARGET, NULL, true);
 238                 else
 239                         r = unit_add_two_dependencies_by_name_inverse(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SWAP_TARGET, NULL, true);
 240                 if (r < 0)
 241                         return r;
 242         }
 243
 244         return 0;
 245 }
 246
 247 static int swap_verify(Swap *s) {
 248         bool b;
 249         _cleanup_free_ char *e = NULL;
 250
 251         if (UNIT(s)->load_state != UNIT_LOADED)
 252                 return 0;
 253
 254         e = unit_name_from_path(s->what, ".swap");
 255         if (!e)
 256                 return log_oom();
 257
 258         b = unit_has_name(UNIT(s), e);
 259         if (!b) {
 260                 log_error_unit(UNIT(s)->id, "%s: Value of \"What\" and unit name do not match, not loading.", UNIT(s)->id);
 261                 return -EINVAL;
 262         }
 263
 264         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 265                 log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.", UNIT(s)->id);
 266                 return -EINVAL;
 267         }
 268
 269         return 0;
 270 }
 271
 272 static int swap_load_devnode(Swap *s) {
 273         _cleanup_udev_device_unref_ struct udev_device *d = NULL;
 274         struct stat st;
 275         const char *p;
 276
 277         assert(s);
 278
 279         if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
 280                 return 0;
 281
 282         d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev);
 283         if (!d)
 284                 return 0;
 285
 286         p = udev_device_get_devnode(d);
 287         if (!p)
 288                 return 0;
 289
 290         return swap_set_devnode(s, p);
 291 }
 292
 293 static int swap_load(Unit *u) {
 294         int r;
 295         Swap *s = SWAP(u);
 296
 297         assert(s);
 298         assert(u->load_state == UNIT_STUB);
 299
 300         /* Load a .swap file */
 301         r = unit_load_fragment_and_dropin_optional(u);
 302         if (r < 0)
 303                 return r;
 304
 305         if (u->load_state == UNIT_LOADED) {
 306                 r = unit_add_exec_dependencies(u, &s->exec_context);
 307                 if (r < 0)
 308                         return r;
 309
 310                 if (UNIT(s)->fragment_path)
 311                         s->from_fragment = true;
 312
 313                 if (!s->what) {
 314                         if (s->parameters_fragment.what)
 315                                 s->what = strdup(s->parameters_fragment.what);
 316                         else if (s->parameters_proc_swaps.what)
 317                                 s->what = strdup(s->parameters_proc_swaps.what);
 318                         else
 319                                 s->what = unit_name_to_path(u->id);
 320
 321                         if (!s->what)
 322                                 return -ENOMEM;
 323                 }
 324
 325                 path_kill_slashes(s->what);
 326
 327                 if (!UNIT(s)->description) {
 328                         r = unit_set_description(u, s->what);
 329                         if (r < 0)
 330                                 return r;
 331                 }
 332
 333                 r = unit_require_mounts_for(UNIT(s), s->what);
 334                 if (r < 0)
 335                         return r;
 336
 337                 r = swap_add_device_links(s);
 338                 if (r < 0)
 339                         return r;
 340
 341                 r = swap_load_devnode(s);
 342                 if (r < 0)
 343                         return r;
 344
 345                 r = unit_add_default_slice(u);
 346                 if (r < 0)
 347                         return r;
 348
 349                 if (UNIT(s)->default_dependencies) {
 350                         r = swap_add_default_dependencies(s);
 351                         if (r < 0)
 352                                 return r;
 353                 }
 354
 355                 r = unit_exec_context_defaults(u, &s->exec_context);
 356                 if (r < 0)
 357                         return r;
 358         }
 359
 360         return swap_verify(s);
 361 }
 362
 363 static int swap_add_one(
 364                 Manager *m,
 365                 const char *what,
 366                 const char *what_proc_swaps,
 367                 int priority,
 368                 bool noauto,
 369                 bool nofail,
 370                 bool set_flags) {
 371
 372         _cleanup_free_ char *e = NULL;
 373         bool delete = false;
 374         Unit *u = NULL;
 375         int r;
 376         SwapParameters *p;
 377
 378         assert(m);
 379         assert(what);
 380         assert(what_proc_swaps);
 381
 382         e = unit_name_from_path(what, ".swap");
 383         if (!e)
 384                 return log_oom();
 385
 386         u = manager_get_unit(m, e);
 387
 388         if (u &&
 389             SWAP(u)->from_proc_swaps &&
 390             !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
 391                 return -EEXIST;
 392
 393         if (!u) {
 394                 delete = true;
 395
 396                 u = unit_new(m, sizeof(Swap));
 397                 if (!u)
 398                         return log_oom();
 399
 400                 r = unit_add_name(u, e);
 401                 if (r < 0)
 402                         goto fail;
 403
 404                 SWAP(u)->what = strdup(what);
 405                 if (!SWAP(u)->what) {
 406                         r = log_oom();
 407                         goto fail;
 408                 }
 409
 410                 unit_add_to_load_queue(u);
 411         } else
 412                 delete = false;
 413
 414         p = &SWAP(u)->parameters_proc_swaps;
 415
 416         if (!p->what) {
 417                 p->what = strdup(what_proc_swaps);
 418                 if (!p->what) {
 419                         r = -ENOMEM;
 420                         goto fail;
 421                 }
 422         }
 423
 424         if (set_flags) {
 425                 SWAP(u)->is_active = true;
 426                 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
 427         }
 428
 429         SWAP(u)->from_proc_swaps = true;
 430
 431         p->priority = priority;
 432         p->noauto = noauto;
 433         p->nofail = nofail;
 434
 435         unit_add_to_dbus_queue(u);
 436
 437         return 0;
 438
 439 fail:
 440         log_warning_unit(e, "Failed to load swap unit: %s", strerror(-r));
 441
 442         if (delete && u)
 443                 unit_free(u);
 444
 445         return r;
 446 }
 447
 448 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
 449         _cleanup_udev_device_unref_ struct udev_device *d = NULL;
 450         struct udev_list_entry *item = NULL, *first = NULL;
 451         const char *dn;
 452         struct stat st;
 453         int r;
 454
 455         assert(m);
 456
 457         r = swap_add_one(m, device, device, prio, false, false, set_flags);
 458         if (r < 0)
 459                 return r;
 460
 461         /* If this is a block device, then let's add duplicates for
 462          * all other names of this block device */
 463         if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
 464                 return 0;
 465
 466         d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
 467         if (!d)
 468                 return 0;
 469
 470         /* Add the main device node */
 471         dn = udev_device_get_devnode(d);
 472         if (dn && !streq(dn, device))
 473                 swap_add_one(m, dn, device, prio, false, false, set_flags);
 474
 475         /* Add additional units for all symlinks */
 476         first = udev_device_get_devlinks_list_entry(d);
 477         udev_list_entry_foreach(item, first) {
 478                 const char *p;
 479
 480                 /* Don't bother with the /dev/block links */
 481                 p = udev_list_entry_get_name(item);
 482
 483                 if (streq(p, device))
 484                         continue;
 485
 486                 if (path_startswith(p, "/dev/block/"))
 487                         continue;
 488
 489                 if (stat(p, &st) >= 0)
 490                         if (!S_ISBLK(st.st_mode) ||
 491                             st.st_rdev != udev_device_get_devnum(d))
 492                                 continue;
 493
 494                 swap_add_one(m, p, device, prio, false, false, set_flags);
 495         }
 496
 497         return r;
 498 }
 499
 500 static void swap_set_state(Swap *s, SwapState state) {
 501         SwapState old_state;
 502
 503         assert(s);
 504
 505         old_state = s->state;
 506         s->state = state;
 507
 508         if (state != SWAP_ACTIVATING &&
 509             state != SWAP_ACTIVATING_SIGTERM &&
 510             state != SWAP_ACTIVATING_SIGKILL &&
 511             state != SWAP_ACTIVATING_DONE &&
 512             state != SWAP_DEACTIVATING &&
 513             state != SWAP_DEACTIVATING_SIGTERM &&
 514             state != SWAP_DEACTIVATING_SIGKILL) {
 515                 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 516                 swap_unwatch_control_pid(s);
 517                 s->control_command = NULL;
 518                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 519         }
 520
 521         if (state != old_state)
 522                 log_debug_unit(UNIT(s)->id,
 523                                "%s changed %s -> %s",
 524                                UNIT(s)->id,
 525                                swap_state_to_string(old_state),
 526                                swap_state_to_string(state));
 527
 528         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
 529 }
 530
 531 static int swap_coldplug(Unit *u) {
 532         Swap *s = SWAP(u);
 533         SwapState new_state = SWAP_DEAD;
 534         int r;
 535
 536         assert(s);
 537         assert(s->state == SWAP_DEAD);
 538
 539         if (s->deserialized_state != s->state)
 540                 new_state = s->deserialized_state;
 541         else if (s->from_proc_swaps)
 542                 new_state = SWAP_ACTIVE;
 543
 544         if (new_state == s->state)
 545                 return 0;
 546
 547         if (new_state == SWAP_ACTIVATING ||
 548             new_state == SWAP_ACTIVATING_SIGTERM ||
 549             new_state == SWAP_ACTIVATING_SIGKILL ||
 550             new_state == SWAP_ACTIVATING_DONE ||
 551             new_state == SWAP_DEACTIVATING ||
 552             new_state == SWAP_DEACTIVATING_SIGTERM ||
 553             new_state == SWAP_DEACTIVATING_SIGKILL) {
 554
 555                 if (s->control_pid <= 0)
 556                         return -EBADMSG;
 557
 558                 r = unit_watch_pid(UNIT(s), s->control_pid);
 559                 if (r < 0)
 560                         return r;
 561
 562                 r = swap_arm_timer(s);
 563                 if (r < 0)
 564                         return r;
 565         }
 566
 567         swap_set_state(s, new_state);
 568         return 0;
 569 }
 570
 571 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
 572         Swap *s = SWAP(u);
 573         SwapParameters *p;
 574
 575         assert(s);
 576         assert(f);
 577
 578         if (s->from_proc_swaps)
 579                 p = &s->parameters_proc_swaps;
 580         else if (s->from_fragment)
 581                 p = &s->parameters_fragment;
 582         else
 583                 p = NULL;
 584
 585         fprintf(f,
 586                 "%sSwap State: %s\n"
 587                 "%sResult: %s\n"
 588                 "%sWhat: %s\n"
 589                 "%sFrom /proc/swaps: %s\n"
 590                 "%sFrom fragment: %s\n",
 591                 prefix, swap_state_to_string(s->state),
 592                 prefix, swap_result_to_string(s->result),
 593                 prefix, s->what,
 594                 prefix, yes_no(s->from_proc_swaps),
 595                 prefix, yes_no(s->from_fragment));
 596
 597         if (s->devnode)
 598                 fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
 599
 600         if (p)
 601                 fprintf(f,
 602                         "%sPriority: %i\n"
 603                         "%sNoAuto: %s\n"
 604                         "%sNoFail: %s\n",
 605                         prefix, p->priority,
 606                         prefix, yes_no(p->noauto),
 607                         prefix, yes_no(p->nofail));
 608
 609         if (s->control_pid > 0)
 610                 fprintf(f,
 611                         "%sControl PID: %lu\n",
 612                         prefix, (unsigned long) s->control_pid);
 613
 614         exec_context_dump(&s->exec_context, f, prefix);
 615         kill_context_dump(&s->kill_context, f, prefix);
 616 }
 617
 618 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
 619         pid_t pid;
 620         int r;
 621
 622         assert(s);
 623         assert(c);
 624         assert(_pid);
 625
 626         unit_realize_cgroup(UNIT(s));
 627
 628         r = swap_arm_timer(s);
 629         if (r < 0)
 630                 goto fail;
 631
 632         r = exec_spawn(c,
 633                        NULL,
 634                        &s->exec_context,
 635                        NULL, 0,
 636                        UNIT(s)->manager->environment,
 637                        true,
 638                        true,
 639                        true,
 640                        UNIT(s)->manager->confirm_spawn,
 641                        UNIT(s)->manager->cgroup_supported,
 642                        UNIT(s)->cgroup_path,
 643                        UNIT(s)->id,
 644                        NULL,
 645                        &pid);
 646         if (r < 0)
 647                 goto fail;
 648
 649         r = unit_watch_pid(UNIT(s), pid);
 650         if (r < 0)
 651                 /* FIXME: we need to do something here */
 652                 goto fail;
 653
 654         *_pid = pid;
 655
 656         return 0;
 657
 658 fail:
 659         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
 660
 661         return r;
 662 }
 663
 664 static void swap_enter_dead(Swap *s, SwapResult f) {
 665         assert(s);
 666
 667         if (f != SWAP_SUCCESS)
 668                 s->result = f;
 669
 670         exec_context_tmp_dirs_done(&s->exec_context);
 671         swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
 672 }
 673
 674 static void swap_enter_active(Swap *s, SwapResult f) {
 675         assert(s);
 676
 677         if (f != SWAP_SUCCESS)
 678                 s->result = f;
 679
 680         swap_set_state(s, SWAP_ACTIVE);
 681 }
 682
 683 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
 684         int r;
 685
 686         assert(s);
 687
 688         if (f != SWAP_SUCCESS)
 689                 s->result = f;
 690
 691         r = unit_kill_context(
 692                         UNIT(s),
 693                         &s->kill_context,
 694                         state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM,
 695                         -1,
 696                         s->control_pid,
 697                         false);
 698         if (r < 0)
 699                 goto fail;
 700
 701         if (r > 0) {
 702                 r = swap_arm_timer(s);
 703                 if (r < 0)
 704                         goto fail;
 705
 706                 swap_set_state(s, state);
 707         } else
 708                 swap_enter_dead(s, SWAP_SUCCESS);
 709
 710         return;
 711
 712 fail:
 713         log_warning_unit(UNIT(s)->id,
 714                          "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
 715
 716         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
 717 }
 718
 719 static void swap_enter_activating(Swap *s) {
 720         int r, priority;
 721
 722         assert(s);
 723
 724         s->control_command_id = SWAP_EXEC_ACTIVATE;
 725         s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
 726
 727         if (s->from_fragment)
 728                 priority = s->parameters_fragment.priority;
 729         else
 730                 priority = -1;
 731
 732         if (priority >= 0) {
 733                 char p[DECIMAL_STR_MAX(int)];
 734
 735                 sprintf(p, "%i", priority);
 736
 737                 r = exec_command_set(
 738                                 s->control_command,
 739                                 "/sbin/swapon",
 740                                 "-p",
 741                                 p,
 742                                 s->what,
 743                                 NULL);
 744         } else
 745                 r = exec_command_set(
 746                                 s->control_command,
 747                                 "/sbin/swapon",
 748                                 s->what,
 749                                 NULL);
 750
 751         if (r < 0)
 752                 goto fail;
 753
 754         swap_unwatch_control_pid(s);
 755
 756         r = swap_spawn(s, s->control_command, &s->control_pid);
 757         if (r < 0)
 758                 goto fail;
 759
 760         swap_set_state(s, SWAP_ACTIVATING);
 761
 762         return;
 763
 764 fail:
 765         log_warning_unit(UNIT(s)->id,
 766                          "%s failed to run 'swapon' task: %s",
 767                          UNIT(s)->id, strerror(-r));
 768         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
 769 }
 770
 771 static void swap_enter_deactivating(Swap *s) {
 772         int r;
 773
 774         assert(s);
 775
 776         s->control_command_id = SWAP_EXEC_DEACTIVATE;
 777         s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
 778
 779         r = exec_command_set(s->control_command,
 780                              "/sbin/swapoff",
 781                              s->what,
 782                              NULL);
 783         if (r < 0)
 784                 goto fail;
 785
 786         swap_unwatch_control_pid(s);
 787
 788         r = swap_spawn(s, s->control_command, &s->control_pid);
 789         if (r < 0)
 790                 goto fail;
 791
 792         swap_set_state(s, SWAP_DEACTIVATING);
 793
 794         return;
 795
 796 fail:
 797         log_warning_unit(UNIT(s)->id,
 798                          "%s failed to run 'swapoff' task: %s",
 799                          UNIT(s)->id, strerror(-r));
 800         swap_enter_active(s, SWAP_FAILURE_RESOURCES);
 801 }
 802
 803 static int swap_start(Unit *u) {
 804         Swap *s = SWAP(u);
 805
 806         assert(s);
 807
 808         /* We cannot fulfill this request right now, try again later
 809          * please! */
 810
 811         if (s->state == SWAP_DEACTIVATING ||
 812             s->state == SWAP_DEACTIVATING_SIGTERM ||
 813             s->state == SWAP_DEACTIVATING_SIGKILL ||
 814             s->state == SWAP_ACTIVATING_SIGTERM ||
 815             s->state == SWAP_ACTIVATING_SIGKILL)
 816                 return -EAGAIN;
 817
 818         if (s->state == SWAP_ACTIVATING)
 819                 return 0;
 820
 821         assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
 822
 823         if (detect_container(NULL) > 0)
 824                 return -EPERM;
 825
 826         s->result = SWAP_SUCCESS;
 827         swap_enter_activating(s);
 828         return 0;
 829 }
 830
 831 static int swap_stop(Unit *u) {
 832         Swap *s = SWAP(u);
 833
 834         assert(s);
 835
 836         if (s->state == SWAP_DEACTIVATING ||
 837             s->state == SWAP_DEACTIVATING_SIGTERM ||
 838             s->state == SWAP_DEACTIVATING_SIGKILL ||
 839             s->state == SWAP_ACTIVATING_SIGTERM ||
 840             s->state == SWAP_ACTIVATING_SIGKILL)
 841                 return 0;
 842
 843         assert(s->state == SWAP_ACTIVATING ||
 844                s->state == SWAP_ACTIVATING_DONE ||
 845                s->state == SWAP_ACTIVE);
 846
 847         if (detect_container(NULL) > 0)
 848                 return -EPERM;
 849
 850         swap_enter_deactivating(s);
 851         return 0;
 852 }
 853
 854 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
 855         Swap *s = SWAP(u);
 856
 857         assert(s);
 858         assert(f);
 859         assert(fds);
 860
 861         unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
 862         unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
 863
 864         if (s->control_pid > 0)
 865                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
 866
 867         if (s->control_command_id >= 0)
 868                 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
 869
 870         exec_context_serialize(&s->exec_context, UNIT(s), f);
 871
 872         return 0;
 873 }
 874
 875 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 876         Swap *s = SWAP(u);
 877
 878         assert(s);
 879         assert(fds);
 880
 881         if (streq(key, "state")) {
 882                 SwapState state;
 883
 884                 state = swap_state_from_string(value);
 885                 if (state < 0)
 886                         log_debug_unit(u->id, "Failed to parse state value %s", value);
 887                 else
 888                         s->deserialized_state = state;
 889         } else if (streq(key, "result")) {
 890                 SwapResult f;
 891
 892                 f = swap_result_from_string(value);
 893                 if (f < 0)
 894                         log_debug_unit(u->id, "Failed to parse result value %s", value);
 895                 else if (f != SWAP_SUCCESS)
 896                         s->result = f;
 897         } else if (streq(key, "control-pid")) {
 898                 pid_t pid;
 899
 900                 if (parse_pid(value, &pid) < 0)
 901                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
 902                 else
 903                         s->control_pid = pid;
 904
 905         } else if (streq(key, "control-command")) {
 906                 SwapExecCommand id;
 907
 908                 id = swap_exec_command_from_string(value);
 909                 if (id < 0)
 910                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
 911                 else {
 912                         s->control_command_id = id;
 913                         s->control_command = s->exec_command + id;
 914                 }
 915         } else if (streq(key, "tmp-dir")) {
 916                 char *t;
 917
 918                 t = strdup(value);
 919                 if (!t)
 920                         return log_oom();
 921
 922                 s->exec_context.tmp_dir = t;
 923         } else if (streq(key, "var-tmp-dir")) {
 924                 char *t;
 925
 926                 t = strdup(value);
 927                 if (!t)
 928                         return log_oom();
 929
 930                 s->exec_context.var_tmp_dir = t;
 931         } else
 932                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
 933
 934         return 0;
 935 }
 936
 937 _pure_ static UnitActiveState swap_active_state(Unit *u) {
 938         assert(u);
 939
 940         return state_translation_table[SWAP(u)->state];
 941 }
 942
 943 _pure_ static const char *swap_sub_state_to_string(Unit *u) {
 944         assert(u);
 945
 946         return swap_state_to_string(SWAP(u)->state);
 947 }
 948
 949 _pure_ static bool swap_check_gc(Unit *u) {
 950         Swap *s = SWAP(u);
 951
 952         assert(s);
 953
 954         return s->from_proc_swaps;
 955 }
 956
 957 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 958         Swap *s = SWAP(u);
 959         SwapResult f;
 960
 961         assert(s);
 962         assert(pid >= 0);
 963
 964         if (pid != s->control_pid)
 965                 return;
 966
 967         s->control_pid = 0;
 968
 969         if (is_clean_exit(code, status, NULL))
 970                 f = SWAP_SUCCESS;
 971         else if (code == CLD_EXITED)
 972                 f = SWAP_FAILURE_EXIT_CODE;
 973         else if (code == CLD_KILLED)
 974                 f = SWAP_FAILURE_SIGNAL;
 975         else if (code == CLD_DUMPED)
 976                 f = SWAP_FAILURE_CORE_DUMP;
 977         else
 978                 assert_not_reached("Unknown code");
 979
 980         if (f != SWAP_SUCCESS)
 981                 s->result = f;
 982
 983         if (s->control_command) {
 984                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
 985
 986                 s->control_command = NULL;
 987                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
 988         }
 989
 990         log_full_unit(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 991                       u->id,
 992                       "%s swap process exited, code=%s status=%i",
 993                       u->id, sigchld_code_to_string(code), status);
 994
 995         switch (s->state) {
 996
 997         case SWAP_ACTIVATING:
 998         case SWAP_ACTIVATING_DONE:
 999         case SWAP_ACTIVATING_SIGTERM:
1000         case SWAP_ACTIVATING_SIGKILL:
1001
1002                 if (f == SWAP_SUCCESS)
1003                         swap_enter_active(s, f);
1004                 else
1005                         swap_enter_dead(s, f);
1006                 break;
1007
1008         case SWAP_DEACTIVATING:
1009         case SWAP_DEACTIVATING_SIGKILL:
1010         case SWAP_DEACTIVATING_SIGTERM:
1011
1012                 if (f == SWAP_SUCCESS)
1013                         swap_enter_dead(s, f);
1014                 else
1015                         swap_enter_dead(s, f);
1016                 break;
1017
1018         default:
1019                 assert_not_reached("Uh, control process died at wrong time.");
1020         }
1021
1022         /* Notify clients about changed exit status */
1023         unit_add_to_dbus_queue(u);
1024 }
1025
1026 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1027         Swap *s = SWAP(userdata);
1028
1029         assert(s);
1030         assert(s->timer_event_source == source);
1031
1032         switch (s->state) {
1033
1034         case SWAP_ACTIVATING:
1035         case SWAP_ACTIVATING_DONE:
1036                 log_warning_unit(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id);
1037                 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1038                 break;
1039
1040         case SWAP_DEACTIVATING:
1041                 log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id);
1042                 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1043                 break;
1044
1045         case SWAP_ACTIVATING_SIGTERM:
1046                 if (s->kill_context.send_sigkill) {
1047                         log_warning_unit(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id);
1048                         swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1049                 } else {
1050                         log_warning_unit(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1051                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1052                 }
1053                 break;
1054
1055         case SWAP_DEACTIVATING_SIGTERM:
1056                 if (s->kill_context.send_sigkill) {
1057                         log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id);
1058                         swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1059                 } else {
1060                         log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1061                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1062                 }
1063                 break;
1064
1065         case SWAP_ACTIVATING_SIGKILL:
1066         case SWAP_DEACTIVATING_SIGKILL:
1067                 log_warning_unit(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id);
1068                 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1069                 break;
1070
1071         default:
1072                 assert_not_reached("Timeout at wrong time.");
1073         }
1074
1075         return 0;
1076 }
1077
1078 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1079         unsigned i;
1080         int r = 0;
1081
1082         assert(m);
1083
1084         rewind(m->proc_swaps);
1085
1086         (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1087
1088         for (i = 1;; i++) {
1089                 _cleanup_free_ char *dev = NULL, *d = NULL;
1090                 int prio = 0, k;
1091
1092                 k = fscanf(m->proc_swaps,
1093                            "%ms "  /* device/file */
1094                            "%*s "  /* type of swap */
1095                            "%*s "  /* swap size */
1096                            "%*s "  /* used */
1097                            "%i\n", /* priority */
1098                            &dev, &prio);
1099                 if (k != 2) {
1100                         if (k == EOF)
1101                                 break;
1102
1103                         log_warning("Failed to parse /proc/swaps:%u", i);
1104                         continue;
1105                 }
1106
1107                 d = cunescape(dev);
1108                 if (!d)
1109                         return -ENOMEM;
1110
1111                 k = swap_process_new_swap(m, d, prio, set_flags);
1112                 if (k < 0)
1113                         r = k;
1114         }
1115
1116         return r;
1117 }
1118
1119 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1120         Manager *m = userdata;
1121         Unit *u;
1122         int r;
1123
1124         assert(m);
1125         assert(revents & EPOLLPRI);
1126
1127         r = swap_load_proc_swaps(m, true);
1128         if (r < 0) {
1129                 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1130
1131                 /* Reset flags, just in case, for late calls */
1132                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1133                         Swap *swap = SWAP(u);
1134
1135                         swap->is_active = swap->just_activated = false;
1136                 }
1137
1138                 return 0;
1139         }
1140
1141         manager_dispatch_load_queue(m);
1142
1143         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1144                 Swap *swap = SWAP(u);
1145
1146                 if (!swap->is_active) {
1147                         /* This has just been deactivated */
1148
1149                         swap_unset_proc_swaps(swap);
1150
1151                         switch (swap->state) {
1152
1153                         case SWAP_ACTIVE:
1154                                 swap_enter_dead(swap, SWAP_SUCCESS);
1155                                 break;
1156
1157                         default:
1158                                 /* Fire again */
1159                                 swap_set_state(swap, swap->state);
1160                                 break;
1161                         }
1162
1163                 } else if (swap->just_activated) {
1164
1165                         /* New swap entry */
1166
1167                         switch (swap->state) {
1168
1169                         case SWAP_DEAD:
1170                         case SWAP_FAILED:
1171                                 swap_enter_active(swap, SWAP_SUCCESS);
1172                                 break;
1173
1174                         case SWAP_ACTIVATING:
1175                                 swap_set_state(swap, SWAP_ACTIVATING_DONE);
1176                                 break;
1177
1178                         default:
1179                                 /* Nothing really changed, but let's
1180                                  * issue an notification call
1181                                  * nonetheless, in case somebody is
1182                                  * waiting for this. */
1183                                 swap_set_state(swap, swap->state);
1184                                 break;
1185                         }
1186                 }
1187
1188                 /* Reset the flags for later calls */
1189                 swap->is_active = swap->just_activated = false;
1190         }
1191
1192         return 1;
1193 }
1194
1195 static Unit *swap_following(Unit *u) {
1196         _cleanup_free_ char *p = NULL;
1197         Swap *s = SWAP(u);
1198         Swap *other, *first = NULL;
1199
1200         assert(s);
1201
1202         if (streq_ptr(s->what, s->devnode))
1203                 return NULL;
1204
1205         /* Make everybody follow the unit that's named after the swap
1206          * device in the kernel */
1207
1208         LIST_FOREACH_AFTER(same_devnode, other, s)
1209                 if (streq_ptr(other->what, other->devnode))
1210                         return UNIT(other);
1211
1212         LIST_FOREACH_BEFORE(same_devnode, other, s) {
1213                 if (streq_ptr(other->what, other->devnode))
1214                         return UNIT(other);
1215
1216                 first = other;
1217         }
1218
1219         return UNIT(first);
1220 }
1221
1222 static int swap_following_set(Unit *u, Set **_set) {
1223         Swap *s = SWAP(u), *other;
1224         Set *set;
1225         int r;
1226
1227         assert(s);
1228         assert(_set);
1229
1230         if (LIST_JUST_US(same_devnode, s)) {
1231                 *_set = NULL;
1232                 return 0;
1233         }
1234
1235         set = set_new(NULL, NULL);
1236         if (!set)
1237                 return -ENOMEM;
1238
1239         LIST_FOREACH_AFTER(same_devnode, other, s) {
1240                 r = set_put(set, other);
1241                 if (r < 0)
1242                         goto fail;
1243         }
1244
1245         LIST_FOREACH_BEFORE(same_devnode, other, s) {
1246                 r = set_put(set, other);
1247                 if (r < 0)
1248                         goto fail;
1249         }
1250
1251         *_set = set;
1252         return 1;
1253
1254 fail:
1255         set_free(set);
1256         return r;
1257 }
1258
1259 static void swap_shutdown(Manager *m) {
1260         assert(m);
1261
1262         m->swap_event_source = sd_event_source_unref(m->swap_event_source);
1263
1264         if (m->proc_swaps) {
1265                 fclose(m->proc_swaps);
1266                 m->proc_swaps = NULL;
1267         }
1268
1269         hashmap_free(m->swaps_by_devnode);
1270         m->swaps_by_devnode = NULL;
1271 }
1272
1273 static int swap_enumerate(Manager *m) {
1274         int r;
1275
1276         assert(m);
1277
1278         if (!m->proc_swaps) {
1279                 m->proc_swaps = fopen("/proc/swaps", "re");
1280                 if (!m->proc_swaps)
1281                         return errno == ENOENT ? 0 : -errno;
1282
1283                 r = sd_event_add_io(m->event, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m, &m->swap_event_source);
1284                 if (r < 0)
1285                         goto fail;
1286
1287                 /* Dispatch this before we dispatch SIGCHLD, so that
1288                  * we always get the events from /proc/swaps before
1289                  * the SIGCHLD of /sbin/swapon. */
1290                 r = sd_event_source_set_priority(m->swap_event_source, -10);
1291                 if (r < 0)
1292                         goto fail;
1293         }
1294
1295         r = swap_load_proc_swaps(m, false);
1296         if (r < 0)
1297                 goto fail;
1298
1299         return 0;
1300
1301 fail:
1302         swap_shutdown(m);
1303         return r;
1304 }
1305
1306 int swap_process_new_device(Manager *m, struct udev_device *dev) {
1307         struct udev_list_entry *item = NULL, *first = NULL;
1308         _cleanup_free_ char *e = NULL;
1309         const char *dn;
1310         Swap *s;
1311         int r = 0;
1312
1313         assert(m);
1314         assert(dev);
1315
1316         dn = udev_device_get_devnode(dev);
1317         if (!dn)
1318                 return 0;
1319
1320         e = unit_name_from_path(dn, ".swap");
1321         if (!e)
1322                 return -ENOMEM;
1323
1324         s = hashmap_get(m->units, e);
1325         if (s)
1326                 r = swap_set_devnode(s, dn);
1327
1328         first = udev_device_get_devlinks_list_entry(dev);
1329         udev_list_entry_foreach(item, first) {
1330                 _cleanup_free_ char *n = NULL;
1331
1332                 n = unit_name_from_path(udev_list_entry_get_name(item), ".swap");
1333                 if (!n)
1334                         return -ENOMEM;
1335
1336                 s = hashmap_get(m->units, n);
1337                 if (s) {
1338                         int q;
1339
1340                         q = swap_set_devnode(s, dn);
1341                         if (q < 0)
1342                                 r = q;
1343                 }
1344         }
1345
1346         return r;
1347 }
1348
1349 int swap_process_removed_device(Manager *m, struct udev_device *dev) {
1350         _cleanup_free_ char *e = NULL;
1351         const char *dn;
1352         int r = 0;
1353         Swap *s;
1354
1355         dn = udev_device_get_devnode(dev);
1356         if (!dn)
1357                 return 0;
1358
1359         while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
1360                 int q;
1361
1362                 q = swap_set_devnode(s, NULL);
1363                 if (q < 0)
1364                         r = q;
1365         }
1366
1367         return r;
1368 }
1369
1370 static void swap_reset_failed(Unit *u) {
1371         Swap *s = SWAP(u);
1372
1373         assert(s);
1374
1375         if (s->state == SWAP_FAILED)
1376                 swap_set_state(s, SWAP_DEAD);
1377
1378         s->result = SWAP_SUCCESS;
1379 }
1380
1381 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1382         return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1383 }
1384
1385 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1386         [SWAP_DEAD] = "dead",
1387         [SWAP_ACTIVATING] = "activating",
1388         [SWAP_ACTIVATING_DONE] = "activating-done",
1389         [SWAP_ACTIVE] = "active",
1390         [SWAP_DEACTIVATING] = "deactivating",
1391         [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1392         [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1393         [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1394         [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1395         [SWAP_FAILED] = "failed"
1396 };
1397
1398 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1399
1400 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1401         [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1402         [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1403 };
1404
1405 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1406
1407 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1408         [SWAP_SUCCESS] = "success",
1409         [SWAP_FAILURE_RESOURCES] = "resources",
1410         [SWAP_FAILURE_TIMEOUT] = "timeout",
1411         [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1412         [SWAP_FAILURE_SIGNAL] = "signal",
1413         [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1414 };
1415
1416 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1417
1418 const UnitVTable swap_vtable = {
1419         .object_size = sizeof(Swap),
1420         .exec_context_offset = offsetof(Swap, exec_context),
1421         .cgroup_context_offset = offsetof(Swap, cgroup_context),
1422         .kill_context_offset = offsetof(Swap, kill_context),
1423
1424         .sections =
1425                 "Unit\0"
1426                 "Swap\0"
1427                 "Install\0",
1428         .private_section = "Swap",
1429
1430         .no_alias = true,
1431         .no_instances = true,
1432
1433         .init = swap_init,
1434         .load = swap_load,
1435         .done = swap_done,
1436
1437         .coldplug = swap_coldplug,
1438
1439         .dump = swap_dump,
1440
1441         .start = swap_start,
1442         .stop = swap_stop,
1443
1444         .kill = swap_kill,
1445
1446         .serialize = swap_serialize,
1447         .deserialize_item = swap_deserialize_item,
1448
1449         .active_state = swap_active_state,
1450         .sub_state_to_string = swap_sub_state_to_string,
1451
1452         .check_gc = swap_check_gc,
1453
1454         .sigchld_event = swap_sigchld_event,
1455
1456         .reset_failed = swap_reset_failed,
1457
1458         .bus_interface = "org.freedesktop.systemd1.Swap",
1459         .bus_vtable = bus_swap_vtable,
1460         .bus_changing_properties = bus_swap_changing_properties,
1461         .bus_set_property = bus_swap_set_property,
1462         .bus_commit_properties = bus_swap_commit_properties,
1463
1464         .following = swap_following,
1465         .following_set = swap_following_set,
1466
1467         .enumerate = swap_enumerate,
1468         .shutdown = swap_shutdown,
1469
1470         .status_message_formats = {
1471                 .starting_stopping = {
1472                         [0] = "Activating swap %s...",
1473                         [1] = "Deactivating swap %s...",
1474                 },
1475                 .finished_start_job = {
1476                         [JOB_DONE]       = "Activated swap %s.",
1477                         [JOB_FAILED]     = "Failed to activate swap %s.",
1478                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1479                         [JOB_TIMEOUT]    = "Timed out activating swap %s.",
1480                 },
1481                 .finished_stop_job = {
1482                         [JOB_DONE]       = "Deactivated swap %s.",
1483                         [JOB_FAILED]     = "Failed deactivating swap %s.",
1484                         [JOB_TIMEOUT]    = "Timed out deactivating swap %s.",
1485                 },
1486         },
1487 };