]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/swap.c
projects / thirdparty / systemd.git / blob
? search:


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