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