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


fffd8d4627b1bb372c18bf184c0f1f6fc1f96d08
[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, false);
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 (void) unit_setup_exec_runtime(u);
555 }
556
557 swap_set_state(s, new_state);
558 return 0;
559 }
560
561 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
562 char buf[FORMAT_TIMESPAN_MAX];
563 Swap *s = SWAP(u);
564 SwapParameters *p;
565
566 assert(s);
567 assert(f);
568
569 if (s->from_proc_swaps)
570 p = &s->parameters_proc_swaps;
571 else if (s->from_fragment)
572 p = &s->parameters_fragment;
573 else
574 p = NULL;
575
576 fprintf(f,
577 "%sSwap State: %s\n"
578 "%sResult: %s\n"
579 "%sWhat: %s\n"
580 "%sFrom /proc/swaps: %s\n"
581 "%sFrom fragment: %s\n",
582 prefix, swap_state_to_string(s->state),
583 prefix, swap_result_to_string(s->result),
584 prefix, s->what,
585 prefix, yes_no(s->from_proc_swaps),
586 prefix, yes_no(s->from_fragment));
587
588 if (s->devnode)
589 fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
590
591 if (p)
592 fprintf(f,
593 "%sPriority: %i\n"
594 "%sOptions: %s\n",
595 prefix, p->priority,
596 prefix, strempty(p->options));
597
598 fprintf(f,
599 "%sTimeoutSec: %s\n",
600 prefix, format_timespan(buf, sizeof(buf), s->timeout_usec, USEC_PER_SEC));
601
602 if (s->control_pid > 0)
603 fprintf(f,
604 "%sControl PID: "PID_FMT"\n",
605 prefix, s->control_pid);
606
607 exec_context_dump(&s->exec_context, f, prefix);
608 kill_context_dump(&s->kill_context, f, prefix);
609 cgroup_context_dump(&s->cgroup_context, f, prefix);
610 }
611
612 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
613
614 ExecParameters exec_params = {
615 .flags = EXEC_APPLY_SANDBOXING|EXEC_APPLY_CHROOT|EXEC_APPLY_TTY_STDIN,
616 .stdin_fd = -1,
617 .stdout_fd = -1,
618 .stderr_fd = -1,
619 };
620 pid_t pid;
621 int r;
622
623 assert(s);
624 assert(c);
625 assert(_pid);
626
627 r = unit_prepare_exec(UNIT(s));
628 if (r < 0)
629 return r;
630
631 r = swap_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
632 if (r < 0)
633 goto fail;
634
635 manager_set_exec_params(UNIT(s)->manager, &exec_params);
636 unit_set_exec_params(UNIT(s), &exec_params);
637
638 r = exec_spawn(UNIT(s),
639 c,
640 &s->exec_context,
641 &exec_params,
642 s->exec_runtime,
643 &s->dynamic_creds,
644 &pid);
645 if (r < 0)
646 goto fail;
647
648 r = unit_watch_pid(UNIT(s), pid);
649 if (r < 0)
650 /* FIXME: we need to do something here */
651 goto fail;
652
653 *_pid = pid;
654
655 return 0;
656
657 fail:
658 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
659
660 return r;
661 }
662
663 static void swap_enter_dead(Swap *s, SwapResult f) {
664 assert(s);
665
666 if (s->result == SWAP_SUCCESS)
667 s->result = f;
668
669 if (s->result != SWAP_SUCCESS)
670 log_unit_warning(UNIT(s), "Failed with result '%s'.", swap_result_to_string(s->result));
671
672 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
673
674 s->exec_runtime = exec_runtime_unref(s->exec_runtime, true);
675
676 exec_context_destroy_runtime_directory(&s->exec_context, UNIT(s)->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
677
678 unit_unref_uid_gid(UNIT(s), true);
679
680 dynamic_creds_destroy(&s->dynamic_creds);
681 }
682
683 static void swap_enter_active(Swap *s, SwapResult f) {
684 assert(s);
685
686 if (s->result == SWAP_SUCCESS)
687 s->result = f;
688
689 swap_set_state(s, SWAP_ACTIVE);
690 }
691
692 static void swap_enter_dead_or_active(Swap *s, SwapResult f) {
693 assert(s);
694
695 if (s->from_proc_swaps)
696 swap_enter_active(s, f);
697 else
698 swap_enter_dead(s, f);
699 }
700
701 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
702 int r;
703 KillOperation kop;
704
705 assert(s);
706
707 if (s->result == SWAP_SUCCESS)
708 s->result = f;
709
710 if (state == SWAP_DEACTIVATING_SIGTERM)
711 kop = KILL_TERMINATE;
712 else
713 kop = KILL_KILL;
714
715 r = unit_kill_context(UNIT(s), &s->kill_context, kop, -1, s->control_pid, false);
716 if (r < 0)
717 goto fail;
718
719 if (r > 0) {
720 r = swap_arm_timer(s, usec_add(now(CLOCK_MONOTONIC), s->timeout_usec));
721 if (r < 0)
722 goto fail;
723
724 swap_set_state(s, state);
725 } else if (state == SWAP_DEACTIVATING_SIGTERM && s->kill_context.send_sigkill)
726 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS);
727 else
728 swap_enter_dead_or_active(s, SWAP_SUCCESS);
729
730 return;
731
732 fail:
733 log_unit_warning_errno(UNIT(s), r, "Failed to kill processes: %m");
734 swap_enter_dead_or_active(s, SWAP_FAILURE_RESOURCES);
735 }
736
737 static void swap_enter_activating(Swap *s) {
738 _cleanup_free_ char *opts = NULL;
739 int r;
740
741 assert(s);
742
743 unit_warn_leftover_processes(UNIT(s));
744
745 s->control_command_id = SWAP_EXEC_ACTIVATE;
746 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
747
748 if (s->from_fragment) {
749 int priority = -1;
750
751 r = fstab_find_pri(s->parameters_fragment.options, &priority);
752 if (r < 0)
753 log_warning_errno(r, "Failed to parse swap priority \"%s\", ignoring: %m", s->parameters_fragment.options);
754 else if (r == 1 && s->parameters_fragment.priority >= 0)
755 log_warning("Duplicate swap priority configuration by Priority and Options fields.");
756
757 if (r <= 0 && s->parameters_fragment.priority >= 0) {
758 if (s->parameters_fragment.options)
759 r = asprintf(&opts, "%s,pri=%i", s->parameters_fragment.options, s->parameters_fragment.priority);
760 else
761 r = asprintf(&opts, "pri=%i", s->parameters_fragment.priority);
762 if (r < 0)
763 goto fail;
764 }
765 }
766
767 r = exec_command_set(s->control_command, "/sbin/swapon", NULL);
768 if (r < 0)
769 goto fail;
770
771 if (s->parameters_fragment.options || opts) {
772 r = exec_command_append(s->control_command, "-o",
773 opts ? : s->parameters_fragment.options, NULL);
774 if (r < 0)
775 goto fail;
776 }
777
778 r = exec_command_append(s->control_command, s->what, NULL);
779 if (r < 0)
780 goto fail;
781
782 swap_unwatch_control_pid(s);
783
784 r = swap_spawn(s, s->control_command, &s->control_pid);
785 if (r < 0)
786 goto fail;
787
788 swap_set_state(s, SWAP_ACTIVATING);
789
790 return;
791
792 fail:
793 log_unit_warning_errno(UNIT(s), r, "Failed to run 'swapon' task: %m");
794 swap_enter_dead_or_active(s, SWAP_FAILURE_RESOURCES);
795 }
796
797 static void swap_enter_deactivating(Swap *s) {
798 int r;
799
800 assert(s);
801
802 s->control_command_id = SWAP_EXEC_DEACTIVATE;
803 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
804
805 r = exec_command_set(s->control_command,
806 "/sbin/swapoff",
807 s->what,
808 NULL);
809 if (r < 0)
810 goto fail;
811
812 swap_unwatch_control_pid(s);
813
814 r = swap_spawn(s, s->control_command, &s->control_pid);
815 if (r < 0)
816 goto fail;
817
818 swap_set_state(s, SWAP_DEACTIVATING);
819
820 return;
821
822 fail:
823 log_unit_warning_errno(UNIT(s), r, "Failed to run 'swapoff' task: %m");
824 swap_enter_dead_or_active(s, SWAP_FAILURE_RESOURCES);
825 }
826
827 static int swap_start(Unit *u) {
828 Swap *s = SWAP(u), *other;
829 int r;
830
831 assert(s);
832
833 /* We cannot fulfill this request right now, try again later please! */
834 if (IN_SET(s->state,
835 SWAP_DEACTIVATING,
836 SWAP_DEACTIVATING_SIGTERM,
837 SWAP_DEACTIVATING_SIGKILL))
838 return -EAGAIN;
839
840 /* Already on it! */
841 if (s->state == SWAP_ACTIVATING)
842 return 0;
843
844 assert(IN_SET(s->state, SWAP_DEAD, SWAP_FAILED));
845
846 if (detect_container() > 0)
847 return -EPERM;
848
849 /* If there's a job for another swap unit for the same node
850 * running, then let's not dispatch this one for now, and wait
851 * until that other job has finished. */
852 LIST_FOREACH_OTHERS(same_devnode, other, s)
853 if (UNIT(other)->job && UNIT(other)->job->state == JOB_RUNNING)
854 return -EAGAIN;
855
856 r = unit_start_limit_test(u);
857 if (r < 0) {
858 swap_enter_dead(s, SWAP_FAILURE_START_LIMIT_HIT);
859 return r;
860 }
861
862 r = unit_acquire_invocation_id(u);
863 if (r < 0)
864 return r;
865
866 s->result = SWAP_SUCCESS;
867
868 u->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, SD_EVENT_PRIORITY_NORMAL-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.