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