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