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