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