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


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