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