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