]> 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
Merge pull request #1107 from msekletar/selinux-get-raw-context
[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 <unistd.h>
24 #include <sys/epoll.h>
25 #include <sys/stat.h>
26 #include <libudev.h>
27
28 #include "unit.h"
29 #include "swap.h"
30 #include "unit-name.h"
31 #include "dbus-swap.h"
32 #include "special.h"
33 #include "exit-status.h"
34 #include "path-util.h"
35 #include "virt.h"
36 #include "udev-util.h"
37 #include "fstab-util.h"
38 #include "formats-util.h"
39
40 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
41 [SWAP_DEAD] = UNIT_INACTIVE,
42 [SWAP_ACTIVATING] = UNIT_ACTIVATING,
43 [SWAP_ACTIVATING_DONE] = UNIT_ACTIVE,
44 [SWAP_ACTIVE] = UNIT_ACTIVE,
45 [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
46 [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
47 [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
48 [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
49 [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
50 [SWAP_FAILED] = UNIT_FAILED
51 };
52
53 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
54 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
55
56 static void swap_unset_proc_swaps(Swap *s) {
57 assert(s);
58
59 if (!s->from_proc_swaps)
60 return;
61
62 free(s->parameters_proc_swaps.what);
63 s->parameters_proc_swaps.what = NULL;
64
65 s->from_proc_swaps = false;
66 }
67
68 static int swap_set_devnode(Swap *s, const char *devnode) {
69 Hashmap *swaps;
70 Swap *first;
71 int r;
72
73 assert(s);
74
75 r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &string_hash_ops);
76 if (r < 0)
77 return r;
78
79 swaps = UNIT(s)->manager->swaps_by_devnode;
80
81 if (s->devnode) {
82 first = hashmap_get(swaps, s->devnode);
83
84 LIST_REMOVE(same_devnode, first, s);
85 if (first)
86 hashmap_replace(swaps, first->devnode, first);
87 else
88 hashmap_remove(swaps, s->devnode);
89
90 free(s->devnode);
91 s->devnode = NULL;
92 }
93
94 if (devnode) {
95 s->devnode = strdup(devnode);
96 if (!s->devnode)
97 return -ENOMEM;
98
99 first = hashmap_get(swaps, s->devnode);
100 LIST_PREPEND(same_devnode, first, s);
101
102 return hashmap_replace(swaps, first->devnode, first);
103 }
104
105 return 0;
106 }
107
108 static void swap_init(Unit *u) {
109 Swap *s = SWAP(u);
110
111 assert(s);
112 assert(UNIT(s)->load_state == UNIT_STUB);
113
114 s->timeout_usec = u->manager->default_timeout_start_usec;
115
116 s->exec_context.std_output = u->manager->default_std_output;
117 s->exec_context.std_error = u->manager->default_std_error;
118
119 s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
120
121 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
122
123 u->ignore_on_isolate = true;
124 }
125
126 static void swap_unwatch_control_pid(Swap *s) {
127 assert(s);
128
129 if (s->control_pid <= 0)
130 return;
131
132 unit_unwatch_pid(UNIT(s), s->control_pid);
133 s->control_pid = 0;
134 }
135
136 static void swap_done(Unit *u) {
137 Swap *s = SWAP(u);
138
139 assert(s);
140
141 swap_unset_proc_swaps(s);
142 swap_set_devnode(s, NULL);
143
144 free(s->what);
145 s->what = NULL;
146
147 free(s->parameters_fragment.what);
148 s->parameters_fragment.what = NULL;
149
150 free(s->parameters_fragment.options);
151 s->parameters_fragment.options = NULL;
152
153 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
154 exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
155 s->control_command = NULL;
156
157 swap_unwatch_control_pid(s);
158
159 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
160 }
161
162 static int swap_arm_timer(Swap *s) {
163 int r;
164
165 assert(s);
166
167 if (s->timeout_usec <= 0) {
168 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
169 return 0;
170 }
171
172 if (s->timer_event_source) {
173 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
174 if (r < 0)
175 return r;
176
177 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
178 }
179
180 r = sd_event_add_time(
181 UNIT(s)->manager->event,
182 &s->timer_event_source,
183 CLOCK_MONOTONIC,
184 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
185 swap_dispatch_timer, s);
186 if (r < 0)
187 return r;
188
189 (void) sd_event_source_set_description(s->timer_event_source, "swap-timer");
190
191 return 0;
192 }
193
194 static int swap_add_device_links(Swap *s) {
195 assert(s);
196
197 if (!s->what)
198 return 0;
199
200 if (!s->from_fragment)
201 return 0;
202
203 if (is_device_path(s->what))
204 return unit_add_node_link(UNIT(s), s->what, UNIT(s)->manager->running_as == MANAGER_SYSTEM);
205 else
206 /* File based swap devices need to be ordered after
207 * systemd-remount-fs.service, since they might need a
208 * writable file system. */
209 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
210 }
211
212 static int swap_add_default_dependencies(Swap *s) {
213 assert(s);
214
215 if (UNIT(s)->manager->running_as != MANAGER_SYSTEM)
216 return 0;
217
218 if (detect_container(NULL) > 0)
219 return 0;
220
221 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
222 }
223
224 static int swap_verify(Swap *s) {
225 _cleanup_free_ char *e = NULL;
226 int r;
227
228 if (UNIT(s)->load_state != UNIT_LOADED)
229 return 0;
230
231 r = unit_name_from_path(s->what, ".swap", &e);
232 if (r < 0)
233 return log_unit_error_errno(UNIT(s), r, "Failed to generate unit name from path: %m");
234
235 if (!unit_has_name(UNIT(s), e)) {
236 log_unit_error(UNIT(s), "Value of What= and unit name do not match, not loading.");
237 return -EINVAL;
238 }
239
240 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
241 log_unit_error(UNIT(s), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.");
242 return -EINVAL;
243 }
244
245 return 0;
246 }
247
248 static int swap_load_devnode(Swap *s) {
249 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
250 struct stat st;
251 const char *p;
252
253 assert(s);
254
255 if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
256 return 0;
257
258 d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev);
259 if (!d)
260 return 0;
261
262 p = udev_device_get_devnode(d);
263 if (!p)
264 return 0;
265
266 return swap_set_devnode(s, p);
267 }
268
269 static int swap_load(Unit *u) {
270 int r;
271 Swap *s = SWAP(u);
272
273 assert(s);
274 assert(u->load_state == UNIT_STUB);
275
276 /* Load a .swap file */
277 r = unit_load_fragment_and_dropin_optional(u);
278 if (r < 0)
279 return r;
280
281 if (u->load_state == UNIT_LOADED) {
282
283 if (UNIT(s)->fragment_path)
284 s->from_fragment = true;
285
286 if (!s->what) {
287 if (s->parameters_fragment.what)
288 s->what = strdup(s->parameters_fragment.what);
289 else if (s->parameters_proc_swaps.what)
290 s->what = strdup(s->parameters_proc_swaps.what);
291 else {
292 r = unit_name_to_path(u->id, &s->what);
293 if (r < 0)
294 return r;
295 }
296
297 if (!s->what)
298 return -ENOMEM;
299 }
300
301 path_kill_slashes(s->what);
302
303 if (!UNIT(s)->description) {
304 r = unit_set_description(u, s->what);
305 if (r < 0)
306 return r;
307 }
308
309 r = unit_require_mounts_for(UNIT(s), s->what);
310 if (r < 0)
311 return r;
312
313 r = swap_add_device_links(s);
314 if (r < 0)
315 return r;
316
317 r = swap_load_devnode(s);
318 if (r < 0)
319 return r;
320
321 r = unit_patch_contexts(u);
322 if (r < 0)
323 return r;
324
325 r = unit_add_exec_dependencies(u, &s->exec_context);
326 if (r < 0)
327 return r;
328
329 r = unit_set_default_slice(u);
330 if (r < 0)
331 return r;
332
333 if (UNIT(s)->default_dependencies) {
334 r = swap_add_default_dependencies(s);
335 if (r < 0)
336 return r;
337 }
338 }
339
340 return swap_verify(s);
341 }
342
343 static int swap_setup_unit(
344 Manager *m,
345 const char *what,
346 const char *what_proc_swaps,
347 int priority,
348 bool set_flags) {
349
350 _cleanup_free_ char *e = NULL;
351 bool delete = false;
352 Unit *u = NULL;
353 int r;
354 SwapParameters *p;
355
356 assert(m);
357 assert(what);
358 assert(what_proc_swaps);
359
360 r = unit_name_from_path(what, ".swap", &e);
361 if (r < 0)
362 return log_unit_error_errno(u, r, "Failed to generate unit name from path: %m");
363
364 u = manager_get_unit(m, e);
365
366 if (u &&
367 SWAP(u)->from_proc_swaps &&
368 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps)) {
369 log_error("Swap %s appeared twice with different device paths %s and %s", e, SWAP(u)->parameters_proc_swaps.what, what_proc_swaps);
370 return -EEXIST;
371 }
372
373 if (!u) {
374 delete = true;
375
376 u = unit_new(m, sizeof(Swap));
377 if (!u)
378 return log_oom();
379
380 r = unit_add_name(u, e);
381 if (r < 0)
382 goto fail;
383
384 SWAP(u)->what = strdup(what);
385 if (!SWAP(u)->what) {
386 r = -ENOMEM;
387 goto fail;
388 }
389
390 unit_add_to_load_queue(u);
391 } else
392 delete = false;
393
394 p = &SWAP(u)->parameters_proc_swaps;
395
396 if (!p->what) {
397 p->what = strdup(what_proc_swaps);
398 if (!p->what) {
399 r = -ENOMEM;
400 goto fail;
401 }
402 }
403
404 if (set_flags) {
405 SWAP(u)->is_active = true;
406 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
407 }
408
409 SWAP(u)->from_proc_swaps = true;
410
411 p->priority = priority;
412
413 unit_add_to_dbus_queue(u);
414 return 0;
415
416 fail:
417 log_unit_warning_errno(u, r, "Failed to load swap unit: %m");
418
419 if (delete && u)
420 unit_free(u);
421
422 return r;
423 }
424
425 static int swap_process_new(Manager *m, const char *device, int prio, bool set_flags) {
426 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
427 struct udev_list_entry *item = NULL, *first = NULL;
428 const char *dn;
429 struct stat st;
430 int r;
431
432 assert(m);
433
434 r = swap_setup_unit(m, device, device, prio, set_flags);
435 if (r < 0)
436 return r;
437
438 /* If this is a block device, then let's add duplicates for
439 * all other names of this block device */
440 if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
441 return 0;
442
443 d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
444 if (!d)
445 return 0;
446
447 /* Add the main device node */
448 dn = udev_device_get_devnode(d);
449 if (dn && !streq(dn, device))
450 swap_setup_unit(m, dn, device, prio, set_flags);
451
452 /* Add additional units for all symlinks */
453 first = udev_device_get_devlinks_list_entry(d);
454 udev_list_entry_foreach(item, first) {
455 const char *p;
456
457 /* Don't bother with the /dev/block links */
458 p = udev_list_entry_get_name(item);
459
460 if (streq(p, device))
461 continue;
462
463 if (path_startswith(p, "/dev/block/"))
464 continue;
465
466 if (stat(p, &st) >= 0)
467 if (!S_ISBLK(st.st_mode) ||
468 st.st_rdev != udev_device_get_devnum(d))
469 continue;
470
471 swap_setup_unit(m, p, device, prio, set_flags);
472 }
473
474 return r;
475 }
476
477 static void swap_set_state(Swap *s, SwapState state) {
478 SwapState old_state;
479 Swap *other;
480
481 assert(s);
482
483 old_state = s->state;
484 s->state = state;
485
486 if (state != SWAP_ACTIVATING &&
487 state != SWAP_ACTIVATING_SIGTERM &&
488 state != SWAP_ACTIVATING_SIGKILL &&
489 state != SWAP_ACTIVATING_DONE &&
490 state != SWAP_DEACTIVATING &&
491 state != SWAP_DEACTIVATING_SIGTERM &&
492 state != SWAP_DEACTIVATING_SIGKILL) {
493 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
494 swap_unwatch_control_pid(s);
495 s->control_command = NULL;
496 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
497 }
498
499 if (state != old_state)
500 log_unit_debug(UNIT(s), "Changed %s -> %s", swap_state_to_string(old_state), swap_state_to_string(state));
501
502 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
503
504 /* If there other units for the same device node have a job
505 queued it might be worth checking again if it is runnable
506 now. This is necessary, since swap_start() refuses
507 operation with EAGAIN if there's already another job for
508 the same device node queued. */
509 LIST_FOREACH_OTHERS(same_devnode, other, s)
510 if (UNIT(other)->job)
511 job_add_to_run_queue(UNIT(other)->job);
512 }
513
514 static int swap_coldplug(Unit *u) {
515 Swap *s = SWAP(u);
516 SwapState new_state = SWAP_DEAD;
517 int r;
518
519 assert(s);
520 assert(s->state == SWAP_DEAD);
521
522 if (s->deserialized_state != s->state)
523 new_state = s->deserialized_state;
524 else if (s->from_proc_swaps)
525 new_state = SWAP_ACTIVE;
526
527 if (new_state == s->state)
528 return 0;
529
530 if (new_state == SWAP_ACTIVATING ||
531 new_state == SWAP_ACTIVATING_SIGTERM ||
532 new_state == SWAP_ACTIVATING_SIGKILL ||
533 new_state == SWAP_ACTIVATING_DONE ||
534 new_state == SWAP_DEACTIVATING ||
535 new_state == SWAP_DEACTIVATING_SIGTERM ||
536 new_state == SWAP_DEACTIVATING_SIGKILL) {
537
538 if (s->control_pid <= 0)
539 return -EBADMSG;
540
541 r = unit_watch_pid(UNIT(s), s->control_pid);
542 if (r < 0)
543 return r;
544
545 r = swap_arm_timer(s);
546 if (r < 0)
547 return r;
548 }
549
550 swap_set_state(s, new_state);
551 return 0;
552 }
553
554 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
555 Swap *s = SWAP(u);
556 SwapParameters *p;
557
558 assert(s);
559 assert(f);
560
561 if (s->from_proc_swaps)
562 p = &s->parameters_proc_swaps;
563 else if (s->from_fragment)
564 p = &s->parameters_fragment;
565 else
566 p = NULL;
567
568 fprintf(f,
569 "%sSwap State: %s\n"
570 "%sResult: %s\n"
571 "%sWhat: %s\n"
572 "%sFrom /proc/swaps: %s\n"
573 "%sFrom fragment: %s\n",
574 prefix, swap_state_to_string(s->state),
575 prefix, swap_result_to_string(s->result),
576 prefix, s->what,
577 prefix, yes_no(s->from_proc_swaps),
578 prefix, yes_no(s->from_fragment));
579
580 if (s->devnode)
581 fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
582
583 if (p)
584 fprintf(f,
585 "%sPriority: %i\n"
586 "%sOptions: %s\n",
587 prefix, p->priority,
588 prefix, strempty(p->options));
589
590 if (s->control_pid > 0)
591 fprintf(f,
592 "%sControl PID: "PID_FMT"\n",
593 prefix, s->control_pid);
594
595 exec_context_dump(&s->exec_context, f, prefix);
596 kill_context_dump(&s->kill_context, f, prefix);
597 }
598
599 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
600 pid_t pid;
601 int r;
602 ExecParameters exec_params = {
603 .apply_permissions = true,
604 .apply_chroot = true,
605 .apply_tty_stdin = true,
606 .bus_endpoint_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(NULL) > 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(NULL) > 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 if (m->proc_swaps) {
1263 fclose(m->proc_swaps);
1264 m->proc_swaps = NULL;
1265 }
1266
1267 hashmap_free(m->swaps_by_devnode);
1268 m->swaps_by_devnode = NULL;
1269 }
1270
1271 static int swap_enumerate(Manager *m) {
1272 int r;
1273
1274 assert(m);
1275
1276 if (!m->proc_swaps) {
1277 m->proc_swaps = fopen("/proc/swaps", "re");
1278 if (!m->proc_swaps)
1279 return errno == ENOENT ? 0 : -errno;
1280
1281 r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
1282 if (r < 0)
1283 goto fail;
1284
1285 /* Dispatch this before we dispatch SIGCHLD, so that
1286 * we always get the events from /proc/swaps before
1287 * the SIGCHLD of /sbin/swapon. */
1288 r = sd_event_source_set_priority(m->swap_event_source, -10);
1289 if (r < 0)
1290 goto fail;
1291
1292 (void) sd_event_source_set_description(m->swap_event_source, "swap-proc");
1293 }
1294
1295 r = swap_load_proc_swaps(m, false);
1296 if (r < 0)
1297 goto fail;
1298
1299 return 0;
1300
1301 fail:
1302 swap_shutdown(m);
1303 return r;
1304 }
1305
1306 int swap_process_device_new(Manager *m, struct udev_device *dev) {
1307 struct udev_list_entry *item = NULL, *first = NULL;
1308 _cleanup_free_ char *e = NULL;
1309 const char *dn;
1310 Swap *s;
1311 int r = 0;
1312
1313 assert(m);
1314 assert(dev);
1315
1316 dn = udev_device_get_devnode(dev);
1317 if (!dn)
1318 return 0;
1319
1320 r = unit_name_from_path(dn, ".swap", &e);
1321 if (r < 0)
1322 return r;
1323
1324 s = hashmap_get(m->units, e);
1325 if (s)
1326 r = swap_set_devnode(s, dn);
1327
1328 first = udev_device_get_devlinks_list_entry(dev);
1329 udev_list_entry_foreach(item, first) {
1330 _cleanup_free_ char *n = NULL;
1331 int q;
1332
1333 q = unit_name_from_path(udev_list_entry_get_name(item), ".swap", &n);
1334 if (q < 0)
1335 return q;
1336
1337 s = hashmap_get(m->units, n);
1338 if (s) {
1339 q = swap_set_devnode(s, dn);
1340 if (q < 0)
1341 r = q;
1342 }
1343 }
1344
1345 return r;
1346 }
1347
1348 int swap_process_device_remove(Manager *m, struct udev_device *dev) {
1349 const char *dn;
1350 int r = 0;
1351 Swap *s;
1352
1353 dn = udev_device_get_devnode(dev);
1354 if (!dn)
1355 return 0;
1356
1357 while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
1358 int q;
1359
1360 q = swap_set_devnode(s, NULL);
1361 if (q < 0)
1362 r = q;
1363 }
1364
1365 return r;
1366 }
1367
1368 static void swap_reset_failed(Unit *u) {
1369 Swap *s = SWAP(u);
1370
1371 assert(s);
1372
1373 if (s->state == SWAP_FAILED)
1374 swap_set_state(s, SWAP_DEAD);
1375
1376 s->result = SWAP_SUCCESS;
1377 }
1378
1379 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1380 return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1381 }
1382
1383 static int swap_get_timeout(Unit *u, uint64_t *timeout) {
1384 Swap *s = SWAP(u);
1385 int r;
1386
1387 if (!s->timer_event_source)
1388 return 0;
1389
1390 r = sd_event_source_get_time(s->timer_event_source, timeout);
1391 if (r < 0)
1392 return r;
1393
1394 return 1;
1395 }
1396
1397 static bool swap_supported(void) {
1398 static int supported = -1;
1399
1400 /* If swap support is not available in the kernel, or we are
1401 * running in a container we don't support swap units, and any
1402 * attempts to starting one should fail immediately. */
1403
1404 if (supported < 0)
1405 supported =
1406 access("/proc/swaps", F_OK) >= 0 &&
1407 detect_container(NULL) <= 0;
1408
1409 return supported;
1410 }
1411
1412 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1413 [SWAP_DEAD] = "dead",
1414 [SWAP_ACTIVATING] = "activating",
1415 [SWAP_ACTIVATING_DONE] = "activating-done",
1416 [SWAP_ACTIVE] = "active",
1417 [SWAP_DEACTIVATING] = "deactivating",
1418 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1419 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1420 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1421 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1422 [SWAP_FAILED] = "failed"
1423 };
1424
1425 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1426
1427 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1428 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1429 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1430 };
1431
1432 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1433
1434 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1435 [SWAP_SUCCESS] = "success",
1436 [SWAP_FAILURE_RESOURCES] = "resources",
1437 [SWAP_FAILURE_TIMEOUT] = "timeout",
1438 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1439 [SWAP_FAILURE_SIGNAL] = "signal",
1440 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1441 };
1442
1443 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1444
1445 const UnitVTable swap_vtable = {
1446 .object_size = sizeof(Swap),
1447 .exec_context_offset = offsetof(Swap, exec_context),
1448 .cgroup_context_offset = offsetof(Swap, cgroup_context),
1449 .kill_context_offset = offsetof(Swap, kill_context),
1450 .exec_runtime_offset = offsetof(Swap, exec_runtime),
1451
1452 .sections =
1453 "Unit\0"
1454 "Swap\0"
1455 "Install\0",
1456 .private_section = "Swap",
1457
1458 .no_alias = true,
1459 .no_instances = true,
1460
1461 .init = swap_init,
1462 .load = swap_load,
1463 .done = swap_done,
1464
1465 .coldplug = swap_coldplug,
1466
1467 .dump = swap_dump,
1468
1469 .start = swap_start,
1470 .stop = swap_stop,
1471
1472 .kill = swap_kill,
1473
1474 .get_timeout = swap_get_timeout,
1475
1476 .serialize = swap_serialize,
1477 .deserialize_item = swap_deserialize_item,
1478
1479 .active_state = swap_active_state,
1480 .sub_state_to_string = swap_sub_state_to_string,
1481
1482 .check_gc = swap_check_gc,
1483
1484 .sigchld_event = swap_sigchld_event,
1485
1486 .reset_failed = swap_reset_failed,
1487
1488 .bus_vtable = bus_swap_vtable,
1489 .bus_set_property = bus_swap_set_property,
1490 .bus_commit_properties = bus_swap_commit_properties,
1491
1492 .following = swap_following,
1493 .following_set = swap_following_set,
1494
1495 .enumerate = swap_enumerate,
1496 .shutdown = swap_shutdown,
1497 .supported = swap_supported,
1498
1499 .status_message_formats = {
1500 .starting_stopping = {
1501 [0] = "Activating swap %s...",
1502 [1] = "Deactivating swap %s...",
1503 },
1504 .finished_start_job = {
1505 [JOB_DONE] = "Activated swap %s.",
1506 [JOB_FAILED] = "Failed to activate swap %s.",
1507 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1508 },
1509 .finished_stop_job = {
1510 [JOB_DONE] = "Deactivated swap %s.",
1511 [JOB_FAILED] = "Failed deactivating swap %s.",
1512 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",
1513 },
1514 },
1515 };
Unnamed repository; edit this file 'description' to name the repository.