]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/nspawn/nspawn-mount.c
projects / thirdparty / systemd.git / blob
? search:


4687ac4c18d88cde8268f2879666b0d8826da9db
[thirdparty/systemd.git] / src / nspawn / nspawn-mount.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <sys/mount.h>
4 #include <linux/magic.h>
5
6 #include "alloc-util.h"
7 #include "escape.h"
8 #include "fd-util.h"
9 #include "format-util.h"
10 #include "fs-util.h"
11 #include "label.h"
12 #include "mkdir.h"
13 #include "mount-util.h"
14 #include "mountpoint-util.h"
15 #include "nspawn-mount.h"
16 #include "parse-util.h"
17 #include "path-util.h"
18 #include "rm-rf.h"
19 #include "set.h"
20 #include "sort-util.h"
21 #include "stat-util.h"
22 #include "string-util.h"
23 #include "strv.h"
24 #include "tmpfile-util.h"
25 #include "user-util.h"
26
27 CustomMount* custom_mount_add(CustomMount **l, size_t *n, CustomMountType t) {
28 CustomMount *c, *ret;
29
30 assert(l);
31 assert(n);
32 assert(t >= 0);
33 assert(t < _CUSTOM_MOUNT_TYPE_MAX);
34
35 c = reallocarray(*l, *n + 1, sizeof(CustomMount));
36 if (!c)
37 return NULL;
38
39 *l = c;
40 ret = *l + *n;
41 (*n)++;
42
43 *ret = (CustomMount) { .type = t };
44
45 return ret;
46 }
47
48 void custom_mount_free_all(CustomMount *l, size_t n) {
49 size_t i;
50
51 for (i = 0; i < n; i++) {
52 CustomMount *m = l + i;
53
54 free(m->source);
55 free(m->destination);
56 free(m->options);
57
58 if (m->work_dir) {
59 (void) rm_rf(m->work_dir, REMOVE_ROOT|REMOVE_PHYSICAL);
60 free(m->work_dir);
61 }
62
63 if (m->rm_rf_tmpdir) {
64 (void) rm_rf(m->rm_rf_tmpdir, REMOVE_ROOT|REMOVE_PHYSICAL);
65 free(m->rm_rf_tmpdir);
66 }
67
68 strv_free(m->lower);
69 free(m->type_argument);
70 }
71
72 free(l);
73 }
74
75 static int custom_mount_compare(const CustomMount *a, const CustomMount *b) {
76 int r;
77
78 r = path_compare(a->destination, b->destination);
79 if (r != 0)
80 return r;
81
82 return CMP(a->type, b->type);
83 }
84
85 static bool source_path_is_valid(const char *p) {
86 assert(p);
87
88 if (*p == '+')
89 p++;
90
91 return path_is_absolute(p);
92 }
93
94 static char *resolve_source_path(const char *dest, const char *source) {
95
96 if (!source)
97 return NULL;
98
99 if (source[0] == '+')
100 return path_join(dest, source + 1);
101
102 return strdup(source);
103 }
104
105 static int allocate_temporary_source(CustomMount *m) {
106 assert(m);
107 assert(!m->source);
108 assert(!m->rm_rf_tmpdir);
109
110 m->rm_rf_tmpdir = strdup("/var/tmp/nspawn-temp-XXXXXX");
111 if (!m->rm_rf_tmpdir)
112 return log_oom();
113
114 if (!mkdtemp(m->rm_rf_tmpdir)) {
115 m->rm_rf_tmpdir = mfree(m->rm_rf_tmpdir);
116 return log_error_errno(errno, "Failed to acquire temporary directory: %m");
117 }
118
119 m->source = path_join(m->rm_rf_tmpdir, "src");
120 if (!m->source)
121 return log_oom();
122
123 if (mkdir(m->source, 0755) < 0)
124 return log_error_errno(errno, "Failed to create %s: %m", m->source);
125
126 return 0;
127 }
128
129 int custom_mount_prepare_all(const char *dest, CustomMount *l, size_t n) {
130 size_t i;
131 int r;
132
133 /* Prepare all custom mounts. This will make source we know all temporary directories. This is called in the
134 * parent process, so that we know the temporary directories to remove on exit before we fork off the
135 * children. */
136
137 assert(l || n == 0);
138
139 /* Order the custom mounts, and make sure we have a working directory */
140 typesafe_qsort(l, n, custom_mount_compare);
141
142 for (i = 0; i < n; i++) {
143 CustomMount *m = l + i;
144
145 /* /proc we mount in the inner child, i.e. when we acquired CLONE_NEWPID. All other mounts we mount
146 * already in the outer child, so that the mounts are already established before CLONE_NEWPID and in
147 * particular CLONE_NEWUSER. This also means any custom mounts below /proc also need to be mounted in
148 * the inner child, not the outer one. Determine this here. */
149 m->in_userns = path_startswith(m->destination, "/proc");
150
151 if (m->type == CUSTOM_MOUNT_BIND) {
152 if (m->source) {
153 char *s;
154
155 s = resolve_source_path(dest, m->source);
156 if (!s)
157 return log_oom();
158
159 free_and_replace(m->source, s);
160 } else {
161 /* No source specified? In that case, use a throw-away temporary directory in /var/tmp */
162
163 r = allocate_temporary_source(m);
164 if (r < 0)
165 return r;
166 }
167 }
168
169 if (m->type == CUSTOM_MOUNT_OVERLAY) {
170 char **j;
171
172 STRV_FOREACH(j, m->lower) {
173 char *s;
174
175 s = resolve_source_path(dest, *j);
176 if (!s)
177 return log_oom();
178
179 free_and_replace(*j, s);
180 }
181
182 if (m->source) {
183 char *s;
184
185 s = resolve_source_path(dest, m->source);
186 if (!s)
187 return log_oom();
188
189 free_and_replace(m->source, s);
190 } else {
191 r = allocate_temporary_source(m);
192 if (r < 0)
193 return r;
194 }
195
196 if (m->work_dir) {
197 char *s;
198
199 s = resolve_source_path(dest, m->work_dir);
200 if (!s)
201 return log_oom();
202
203 free_and_replace(m->work_dir, s);
204 } else {
205 r = tempfn_random(m->source, NULL, &m->work_dir);
206 if (r < 0)
207 return log_error_errno(r, "Failed to acquire working directory: %m");
208 }
209
210 (void) mkdir_label(m->work_dir, 0700);
211 }
212 }
213
214 return 0;
215 }
216
217 int bind_mount_parse(CustomMount **l, size_t *n, const char *s, bool read_only) {
218 _cleanup_free_ char *source = NULL, *destination = NULL, *opts = NULL;
219 const char *p = s;
220 CustomMount *m;
221 int r;
222
223 assert(l);
224 assert(n);
225
226 r = extract_many_words(&p, ":", EXTRACT_DONT_COALESCE_SEPARATORS, &source, &destination, NULL);
227 if (r < 0)
228 return r;
229 if (r == 0)
230 return -EINVAL;
231 if (r == 1) {
232 destination = strdup(source[0] == '+' ? source+1 : source);
233 if (!destination)
234 return -ENOMEM;
235 }
236 if (r == 2 && !isempty(p)) {
237 opts = strdup(p);
238 if (!opts)
239 return -ENOMEM;
240 }
241
242 if (isempty(source))
243 source = mfree(source);
244 else if (!source_path_is_valid(source))
245 return -EINVAL;
246
247 if (!path_is_absolute(destination))
248 return -EINVAL;
249
250 m = custom_mount_add(l, n, CUSTOM_MOUNT_BIND);
251 if (!m)
252 return -ENOMEM;
253
254 m->source = TAKE_PTR(source);
255 m->destination = TAKE_PTR(destination);
256 m->read_only = read_only;
257 m->options = TAKE_PTR(opts);
258
259 return 0;
260 }
261
262 int tmpfs_mount_parse(CustomMount **l, size_t *n, const char *s) {
263 _cleanup_free_ char *path = NULL, *opts = NULL;
264 const char *p = s;
265 CustomMount *m;
266 int r;
267
268 assert(l);
269 assert(n);
270 assert(s);
271
272 r = extract_first_word(&p, &path, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
273 if (r < 0)
274 return r;
275 if (r == 0)
276 return -EINVAL;
277
278 if (isempty(p))
279 opts = strdup("mode=0755");
280 else
281 opts = strdup(p);
282 if (!opts)
283 return -ENOMEM;
284
285 if (!path_is_absolute(path))
286 return -EINVAL;
287
288 m = custom_mount_add(l, n, CUSTOM_MOUNT_TMPFS);
289 if (!m)
290 return -ENOMEM;
291
292 m->destination = TAKE_PTR(path);
293 m->options = TAKE_PTR(opts);
294
295 return 0;
296 }
297
298 int overlay_mount_parse(CustomMount **l, size_t *n, const char *s, bool read_only) {
299 _cleanup_free_ char *upper = NULL, *destination = NULL;
300 _cleanup_strv_free_ char **lower = NULL;
301 CustomMount *m;
302 int k;
303
304 k = strv_split_extract(&lower, s, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
305 if (k < 0)
306 return k;
307 if (k < 2)
308 return -EADDRNOTAVAIL;
309 if (k == 2) {
310 /* If two parameters are specified, the first one is the lower, the second one the upper directory. And
311 * we'll also define the destination mount point the same as the upper. */
312
313 if (!source_path_is_valid(lower[0]) ||
314 !source_path_is_valid(lower[1]))
315 return -EINVAL;
316
317 upper = TAKE_PTR(lower[1]);
318
319 destination = strdup(upper[0] == '+' ? upper+1 : upper); /* take the destination without "+" prefix */
320 if (!destination)
321 return -ENOMEM;
322 } else {
323 char **i;
324
325 /* If more than two parameters are specified, the last one is the destination, the second to last one
326 * the "upper", and all before that the "lower" directories. */
327
328 destination = lower[k - 1];
329 upper = TAKE_PTR(lower[k - 2]);
330
331 STRV_FOREACH(i, lower)
332 if (!source_path_is_valid(*i))
333 return -EINVAL;
334
335 /* If the upper directory is unspecified, then let's create it automatically as a throw-away directory
336 * in /var/tmp */
337 if (isempty(upper))
338 upper = mfree(upper);
339 else if (!source_path_is_valid(upper))
340 return -EINVAL;
341
342 if (!path_is_absolute(destination))
343 return -EINVAL;
344 }
345
346 m = custom_mount_add(l, n, CUSTOM_MOUNT_OVERLAY);
347 if (!m)
348 return -ENOMEM;
349
350 m->destination = TAKE_PTR(destination);
351 m->source = TAKE_PTR(upper);
352 m->lower = TAKE_PTR(lower);
353 m->read_only = read_only;
354
355 return 0;
356 }
357
358 int inaccessible_mount_parse(CustomMount **l, size_t *n, const char *s) {
359 _cleanup_free_ char *path = NULL;
360 CustomMount *m;
361
362 assert(l);
363 assert(n);
364 assert(s);
365
366 if (!path_is_absolute(s))
367 return -EINVAL;
368
369 path = strdup(s);
370 if (!path)
371 return -ENOMEM;
372
373 m = custom_mount_add(l, n, CUSTOM_MOUNT_INACCESSIBLE);
374 if (!m)
375 return -ENOMEM;
376
377 m->destination = TAKE_PTR(path);
378 return 0;
379 }
380
381 int tmpfs_patch_options(
382 const char *options,
383 uid_t uid_shift,
384 const char *selinux_apifs_context,
385 char **ret) {
386
387 char *buf = NULL;
388
389 if (uid_shift != UID_INVALID) {
390 if (asprintf(&buf, "%s%suid=" UID_FMT ",gid=" UID_FMT,
391 strempty(options), options ? "," : "",
392 uid_shift, uid_shift) < 0)
393 return -ENOMEM;
394
395 options = buf;
396 }
397
398 #if HAVE_SELINUX
399 if (selinux_apifs_context) {
400 char *t;
401
402 t = strjoin(strempty(options), options ? "," : "",
403 "context=\"", selinux_apifs_context, "\"");
404 free(buf);
405 if (!t)
406 return -ENOMEM;
407
408 buf = t;
409 }
410 #endif
411
412 if (!buf && options) {
413 buf = strdup(options);
414 if (!buf)
415 return -ENOMEM;
416 }
417 *ret = buf;
418
419 return !!buf;
420 }
421
422 int mount_sysfs(const char *dest, MountSettingsMask mount_settings) {
423 const char *full, *top, *x;
424 int r;
425 unsigned long extra_flags = 0;
426
427 top = prefix_roota(dest, "/sys");
428 r = path_is_fs_type(top, SYSFS_MAGIC);
429 if (r < 0)
430 return log_error_errno(r, "Failed to determine filesystem type of %s: %m", top);
431 /* /sys might already be mounted as sysfs by the outer child in the
432 * !netns case. In this case, it's all good. Don't touch it because we
433 * don't have the right to do so, see https://github.com/systemd/systemd/issues/1555.
434 */
435 if (r > 0)
436 return 0;
437
438 full = prefix_roota(top, "/full");
439
440 (void) mkdir(full, 0755);
441
442 if (FLAGS_SET(mount_settings, MOUNT_APPLY_APIVFS_RO))
443 extra_flags |= MS_RDONLY;
444
445 r = mount_verbose(LOG_ERR, "sysfs", full, "sysfs",
446 MS_NOSUID|MS_NOEXEC|MS_NODEV|extra_flags, NULL);
447 if (r < 0)
448 return r;
449
450 FOREACH_STRING(x, "block", "bus", "class", "dev", "devices", "kernel") {
451 _cleanup_free_ char *from = NULL, *to = NULL;
452
453 from = path_join(full, x);
454 if (!from)
455 return log_oom();
456
457 to = path_join(top, x);
458 if (!to)
459 return log_oom();
460
461 (void) mkdir(to, 0755);
462
463 r = mount_verbose(LOG_ERR, from, to, NULL, MS_BIND, NULL);
464 if (r < 0)
465 return r;
466
467 r = mount_verbose(LOG_ERR, NULL, to, NULL,
468 MS_BIND|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT|extra_flags, NULL);
469 if (r < 0)
470 return r;
471 }
472
473 r = umount_verbose(full);
474 if (r < 0)
475 return r;
476
477 if (rmdir(full) < 0)
478 return log_error_errno(errno, "Failed to remove %s: %m", full);
479
480 /* Create mountpoint for cgroups. Otherwise we are not allowed since we
481 * remount /sys read-only.
482 */
483 x = prefix_roota(top, "/fs/cgroup");
484 (void) mkdir_p(x, 0755);
485
486 return mount_verbose(LOG_ERR, NULL, top, NULL,
487 MS_BIND|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT|extra_flags, NULL);
488 }
489
490 int mount_all(const char *dest,
491 MountSettingsMask mount_settings,
492 uid_t uid_shift,
493 const char *selinux_apifs_context) {
494
495 #define PROC_INACCESSIBLE_REG(path) \
496 { "/run/systemd/inaccessible/reg", (path), NULL, NULL, MS_BIND, \
497 MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO }, /* Bind mount first ... */ \
498 { NULL, (path), NULL, NULL, MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, \
499 MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO } /* Then, make it r/o */
500
501 #define PROC_READ_ONLY(path) \
502 { (path), (path), NULL, NULL, MS_BIND, \
503 MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO }, /* Bind mount first ... */ \
504 { NULL, (path), NULL, NULL, MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT, \
505 MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO } /* Then, make it r/o */
506
507 typedef struct MountPoint {
508 const char *what;
509 const char *where;
510 const char *type;
511 const char *options;
512 unsigned long flags;
513 MountSettingsMask mount_settings;
514 } MountPoint;
515
516 static const MountPoint mount_table[] = {
517 /* First we list inner child mounts (i.e. mounts applied *after* entering user namespacing) */
518 { "proc", "/proc", "proc", NULL, MS_NOSUID|MS_NOEXEC|MS_NODEV,
519 MOUNT_FATAL|MOUNT_IN_USERNS|MOUNT_MKDIR },
520
521 { "/proc/sys", "/proc/sys", NULL, NULL, MS_BIND,
522 MOUNT_FATAL|MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO }, /* Bind mount first ... */
523
524 { "/proc/sys/net", "/proc/sys/net", NULL, NULL, MS_BIND,
525 MOUNT_FATAL|MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO|MOUNT_APPLY_APIVFS_NETNS }, /* (except for this) */
526
527 { NULL, "/proc/sys", NULL, NULL, MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT,
528 MOUNT_FATAL|MOUNT_IN_USERNS|MOUNT_APPLY_APIVFS_RO }, /* ... then, make it r/o */
529
530 /* Make these files inaccessible to container payloads: they potentially leak information about kernel
531 * internals or the host's execution environment to the container */
532 PROC_INACCESSIBLE_REG("/proc/kallsyms"),
533 PROC_INACCESSIBLE_REG("/proc/kcore"),
534 PROC_INACCESSIBLE_REG("/proc/keys"),
535 PROC_INACCESSIBLE_REG("/proc/sysrq-trigger"),
536 PROC_INACCESSIBLE_REG("/proc/timer_list"),
537
538 /* Make these directories read-only to container payloads: they show hardware information, and in some
539 * cases contain tunables the container really shouldn't have access to. */
540 PROC_READ_ONLY("/proc/acpi"),
541 PROC_READ_ONLY("/proc/apm"),
542 PROC_READ_ONLY("/proc/asound"),
543 PROC_READ_ONLY("/proc/bus"),
544 PROC_READ_ONLY("/proc/fs"),
545 PROC_READ_ONLY("/proc/irq"),
546 PROC_READ_ONLY("/proc/scsi"),
547
548 { "mqueue", "/dev/mqueue", "mqueue", NULL, MS_NOSUID|MS_NOEXEC|MS_NODEV,
549 MOUNT_IN_USERNS|MOUNT_MKDIR },
550
551 /* Then we list outer child mounts (i.e. mounts applied *before* entering user namespacing) */
552 { "tmpfs", "/tmp", "tmpfs", "mode=1777" TMPFS_LIMITS_TMP, MS_NOSUID|MS_NODEV|MS_STRICTATIME,
553 MOUNT_FATAL|MOUNT_APPLY_TMPFS_TMP|MOUNT_MKDIR },
554 { "tmpfs", "/sys", "tmpfs", "mode=555" TMPFS_LIMITS_SYS, MS_NOSUID|MS_NOEXEC|MS_NODEV,
555 MOUNT_FATAL|MOUNT_APPLY_APIVFS_NETNS|MOUNT_MKDIR },
556 { "sysfs", "/sys", "sysfs", NULL, MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV,
557 MOUNT_FATAL|MOUNT_APPLY_APIVFS_RO|MOUNT_MKDIR }, /* skipped if above was mounted */
558 { "sysfs", "/sys", "sysfs", NULL, MS_NOSUID|MS_NOEXEC|MS_NODEV,
559 MOUNT_FATAL|MOUNT_MKDIR }, /* skipped if above was mounted */
560 { "tmpfs", "/dev", "tmpfs", "mode=755" TMPFS_LIMITS_DEV, MS_NOSUID|MS_STRICTATIME,
561 MOUNT_FATAL|MOUNT_MKDIR },
562 { "tmpfs", "/dev/shm", "tmpfs", "mode=1777" TMPFS_LIMITS_DEV_SHM, MS_NOSUID|MS_NODEV|MS_STRICTATIME,
563 MOUNT_FATAL|MOUNT_MKDIR },
564 { "tmpfs", "/run", "tmpfs", "mode=755" TMPFS_LIMITS_RUN, MS_NOSUID|MS_NODEV|MS_STRICTATIME,
565 MOUNT_FATAL|MOUNT_MKDIR },
566 { "/usr/lib/os-release", "/run/host/usr/lib/os-release", NULL, NULL, MS_BIND,
567 MOUNT_FATAL|MOUNT_MKDIR|MOUNT_TOUCH }, /* As per kernel interface requirements, bind mount first (creating mount points) and make read-only later */
568 { NULL, "/run/host/usr/lib/os-release", NULL, NULL, MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT,
569 0 },
570 { "/etc/os-release", "/run/host/etc/os-release", NULL, NULL, MS_BIND,
571 MOUNT_MKDIR|MOUNT_TOUCH },
572 { NULL, "/run/host/etc/os-release", NULL, NULL, MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT,
573 0 },
574
575 #if HAVE_SELINUX
576 { "/sys/fs/selinux", "/sys/fs/selinux", NULL, NULL, MS_BIND,
577 MOUNT_MKDIR }, /* Bind mount first (mkdir/chown the mount point in case /sys/ is mounted as minimal skeleton tmpfs) */
578 { NULL, "/sys/fs/selinux", NULL, NULL, MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV|MS_REMOUNT,
579 0 }, /* Then, make it r/o (don't mkdir/chown the mount point here, the previous entry already did that) */
580 #endif
581 };
582
583 bool use_userns = FLAGS_SET(mount_settings, MOUNT_USE_USERNS);
584 bool netns = FLAGS_SET(mount_settings, MOUNT_APPLY_APIVFS_NETNS);
585 bool ro = FLAGS_SET(mount_settings, MOUNT_APPLY_APIVFS_RO);
586 bool in_userns = FLAGS_SET(mount_settings, MOUNT_IN_USERNS);
587 bool tmpfs_tmp = FLAGS_SET(mount_settings, MOUNT_APPLY_TMPFS_TMP);
588 size_t k;
589 int r;
590
591 for (k = 0; k < ELEMENTSOF(mount_table); k++) {
592 _cleanup_free_ char *where = NULL, *options = NULL;
593 const char *o;
594 bool fatal = FLAGS_SET(mount_table[k].mount_settings, MOUNT_FATAL);
595
596 if (in_userns != FLAGS_SET(mount_table[k].mount_settings, MOUNT_IN_USERNS))
597 continue;
598
599 if (!netns && FLAGS_SET(mount_table[k].mount_settings, MOUNT_APPLY_APIVFS_NETNS))
600 continue;
601
602 if (!ro && FLAGS_SET(mount_table[k].mount_settings, MOUNT_APPLY_APIVFS_RO))
603 continue;
604
605 if (!tmpfs_tmp && FLAGS_SET(mount_table[k].mount_settings, MOUNT_APPLY_TMPFS_TMP))
606 continue;
607
608 r = chase_symlinks(mount_table[k].where, dest, CHASE_NONEXISTENT|CHASE_PREFIX_ROOT, &where, NULL);
609 if (r < 0)
610 return log_error_errno(r, "Failed to resolve %s/%s: %m", dest, mount_table[k].where);
611
612 /* Skip this entry if it is not a remount. */
613 if (mount_table[k].what) {
614 r = path_is_mount_point(where, NULL, 0);
615 if (r < 0 && r != -ENOENT)
616 return log_error_errno(r, "Failed to detect whether %s is a mount point: %m", where);
617 if (r > 0)
618 continue;
619
620 /* Shortcut for optional bind mounts: if the source can't be found skip ahead to avoid creating
621 * empty and unused directories. */
622 if (!fatal && FLAGS_SET(mount_table[k].mount_settings, MOUNT_MKDIR) && FLAGS_SET(mount_table[k].flags, MS_BIND)) {
623 r = access(mount_table[k].what, F_OK);
624 if (r < 0) {
625 if (errno == ENOENT)
626 continue;
627 return log_error_errno(errno, "Failed to stat %s: %m", mount_table[k].what);
628 }
629 }
630 }
631
632 if (FLAGS_SET(mount_table[k].mount_settings, MOUNT_MKDIR)) {
633 uid_t u = (use_userns && !in_userns) ? uid_shift : UID_INVALID;
634
635 if (FLAGS_SET(mount_table[k].mount_settings, MOUNT_TOUCH))
636 r = mkdir_parents_safe(dest, where, 0755, u, u, 0);
637 else
638 r = mkdir_p_safe(dest, where, 0755, u, u, 0);
639 if (r < 0 && r != -EEXIST) {
640 if (fatal && r != -EROFS)
641 return log_error_errno(r, "Failed to create directory %s: %m", where);
642
643 log_debug_errno(r, "Failed to create directory %s: %m", where);
644
645 /* If we failed mkdir() or chown() due to the root directory being read only,
646 * attempt to mount this fs anyway and let mount_verbose log any errors */
647 if (r != -EROFS)
648 continue;
649 }
650 if (FLAGS_SET(mount_table[k].mount_settings, MOUNT_TOUCH)) {
651 r = touch(where);
652 if (r < 0 && r != -EEXIST) {
653 if (fatal)
654 return log_error_errno(r, "Failed to create mount point %s: %m", where);
655 log_debug_errno(r, "Failed to create mount point %s: %m", where);
656 }
657 }
658 }
659
660 o = mount_table[k].options;
661 if (streq_ptr(mount_table[k].type, "tmpfs")) {
662 r = tmpfs_patch_options(o, in_userns ? 0 : uid_shift, selinux_apifs_context, &options);
663 if (r < 0)
664 return log_oom();
665 if (r > 0)
666 o = options;
667 }
668
669 r = mount_verbose(fatal ? LOG_ERR : LOG_DEBUG,
670 mount_table[k].what,
671 where,
672 mount_table[k].type,
673 mount_table[k].flags,
674 o);
675 if (r < 0 && fatal)
676 return r;
677 }
678
679 return 0;
680 }
681
682 static int parse_mount_bind_options(const char *options, unsigned long *mount_flags, char **mount_opts) {
683 const char *p = options;
684 unsigned long flags = *mount_flags;
685 char *opts = NULL;
686 int r;
687
688 assert(options);
689
690 for (;;) {
691 _cleanup_free_ char *word = NULL;
692
693 r = extract_first_word(&p, &word, ",", 0);
694 if (r < 0)
695 return log_error_errno(r, "Failed to extract mount option: %m");
696 if (r == 0)
697 break;
698
699 if (streq(word, "rbind"))
700 flags |= MS_REC;
701 else if (streq(word, "norbind"))
702 flags &= ~MS_REC;
703 else {
704 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
705 "Invalid bind mount option: %s",
706 word);
707 }
708 }
709
710 *mount_flags = flags;
711 /* in the future mount_opts will hold string options for mount(2) */
712 *mount_opts = opts;
713
714 return 0;
715 }
716
717 static int mount_bind(const char *dest, CustomMount *m) {
718 _cleanup_free_ char *mount_opts = NULL, *where = NULL;
719 unsigned long mount_flags = MS_BIND | MS_REC;
720 struct stat source_st, dest_st;
721 int r;
722
723 assert(dest);
724 assert(m);
725
726 if (m->options) {
727 r = parse_mount_bind_options(m->options, &mount_flags, &mount_opts);
728 if (r < 0)
729 return r;
730 }
731
732 if (stat(m->source, &source_st) < 0)
733 return log_error_errno(errno, "Failed to stat %s: %m", m->source);
734
735 r = chase_symlinks(m->destination, dest, CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &where, NULL);
736 if (r < 0)
737 return log_error_errno(r, "Failed to resolve %s/%s: %m", dest, m->destination);
738 if (r > 0) { /* Path exists already? */
739
740 if (stat(where, &dest_st) < 0)
741 return log_error_errno(errno, "Failed to stat %s: %m", where);
742
743 if (S_ISDIR(source_st.st_mode) && !S_ISDIR(dest_st.st_mode))
744 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
745 "Cannot bind mount directory %s on file %s.",
746 m->source, where);
747
748 if (!S_ISDIR(source_st.st_mode) && S_ISDIR(dest_st.st_mode))
749 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
750 "Cannot bind mount file %s on directory %s.",
751 m->source, where);
752
753 } else { /* Path doesn't exist yet? */
754 r = mkdir_parents_label(where, 0755);
755 if (r < 0)
756 return log_error_errno(r, "Failed to make parents of %s: %m", where);
757
758 /* Create the mount point. Any non-directory file can be
759 * mounted on any non-directory file (regular, fifo, socket,
760 * char, block).
761 */
762 if (S_ISDIR(source_st.st_mode))
763 r = mkdir_label(where, 0755);
764 else
765 r = touch(where);
766 if (r < 0)
767 return log_error_errno(r, "Failed to create mount point %s: %m", where);
768 }
769
770 r = mount_verbose(LOG_ERR, m->source, where, NULL, mount_flags, mount_opts);
771 if (r < 0)
772 return r;
773
774 if (m->read_only) {
775 r = bind_remount_recursive(where, MS_RDONLY, MS_RDONLY, NULL);
776 if (r < 0)
777 return log_error_errno(r, "Read-only bind mount failed: %m");
778 }
779
780 return 0;
781 }
782
783 static int mount_tmpfs(const char *dest, CustomMount *m, uid_t uid_shift, const char *selinux_apifs_context) {
784
785 const char *options;
786 _cleanup_free_ char *buf = NULL, *where = NULL;
787 int r;
788
789 assert(dest);
790 assert(m);
791
792 r = chase_symlinks(m->destination, dest, CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &where, NULL);
793 if (r < 0)
794 return log_error_errno(r, "Failed to resolve %s/%s: %m", dest, m->destination);
795 if (r == 0) { /* Doesn't exist yet? */
796 r = mkdir_p_label(where, 0755);
797 if (r < 0)
798 return log_error_errno(r, "Creating mount point for tmpfs %s failed: %m", where);
799 }
800
801 r = tmpfs_patch_options(m->options, uid_shift == 0 ? UID_INVALID : uid_shift, selinux_apifs_context, &buf);
802 if (r < 0)
803 return log_oom();
804 options = r > 0 ? buf : m->options;
805
806 return mount_verbose(LOG_ERR, "tmpfs", where, "tmpfs", MS_NODEV|MS_STRICTATIME, options);
807 }
808
809 static char *joined_and_escaped_lower_dirs(char **lower) {
810 _cleanup_strv_free_ char **sv = NULL;
811
812 sv = strv_copy(lower);
813 if (!sv)
814 return NULL;
815
816 strv_reverse(sv);
817
818 if (!strv_shell_escape(sv, ",:"))
819 return NULL;
820
821 return strv_join(sv, ":");
822 }
823
824 static int mount_overlay(const char *dest, CustomMount *m) {
825 _cleanup_free_ char *lower = NULL, *where = NULL, *escaped_source = NULL;
826 const char *options;
827 int r;
828
829 assert(dest);
830 assert(m);
831
832 r = chase_symlinks(m->destination, dest, CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &where, NULL);
833 if (r < 0)
834 return log_error_errno(r, "Failed to resolve %s/%s: %m", dest, m->destination);
835 if (r == 0) { /* Doesn't exist yet? */
836 r = mkdir_label(where, 0755);
837 if (r < 0)
838 return log_error_errno(r, "Creating mount point for overlay %s failed: %m", where);
839 }
840
841 (void) mkdir_p_label(m->source, 0755);
842
843 lower = joined_and_escaped_lower_dirs(m->lower);
844 if (!lower)
845 return log_oom();
846
847 escaped_source = shell_escape(m->source, ",:");
848 if (!escaped_source)
849 return log_oom();
850
851 if (m->read_only)
852 options = strjoina("lowerdir=", escaped_source, ":", lower);
853 else {
854 _cleanup_free_ char *escaped_work_dir = NULL;
855
856 escaped_work_dir = shell_escape(m->work_dir, ",:");
857 if (!escaped_work_dir)
858 return log_oom();
859
860 options = strjoina("lowerdir=", lower, ",upperdir=", escaped_source, ",workdir=", escaped_work_dir);
861 }
862
863 return mount_verbose(LOG_ERR, "overlay", where, "overlay", m->read_only ? MS_RDONLY : 0, options);
864 }
865
866 static int mount_inaccessible(const char *dest, CustomMount *m) {
867 _cleanup_free_ char *where = NULL, *source = NULL;
868 struct stat st;
869 int r;
870
871 assert(dest);
872 assert(m);
873
874 r = chase_symlinks_and_stat(m->destination, dest, CHASE_PREFIX_ROOT, &where, &st, NULL);
875 if (r < 0) {
876 log_full_errno(m->graceful ? LOG_DEBUG : LOG_ERR, r, "Failed to resolve %s/%s: %m", dest, m->destination);
877 return m->graceful ? 0 : r;
878 }
879
880 r = mode_to_inaccessible_node(NULL, st.st_mode, &source);
881 if (r < 0)
882 return m->graceful ? 0 : r;
883
884 r = mount_verbose(m->graceful ? LOG_DEBUG : LOG_ERR, source, where, NULL, MS_BIND, NULL);
885 if (r < 0)
886 return m->graceful ? 0 : r;
887
888 r = mount_verbose(m->graceful ? LOG_DEBUG : LOG_ERR, NULL, where, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, NULL);
889 if (r < 0) {
890 (void) umount_verbose(where);
891 return m->graceful ? 0 : r;
892 }
893
894 return 0;
895 }
896
897 static int mount_arbitrary(const char *dest, CustomMount *m) {
898 _cleanup_free_ char *where = NULL;
899 int r;
900
901 assert(dest);
902 assert(m);
903
904 r = chase_symlinks(m->destination, dest, CHASE_PREFIX_ROOT|CHASE_NONEXISTENT, &where, NULL);
905 if (r < 0)
906 return log_error_errno(r, "Failed to resolve %s/%s: %m", dest, m->destination);
907 if (r == 0) { /* Doesn't exist yet? */
908 r = mkdir_p_label(where, 0755);
909 if (r < 0)
910 return log_error_errno(r, "Creating mount point for mount %s failed: %m", where);
911 }
912
913 return mount_verbose(LOG_ERR, m->source, where, m->type_argument, 0, m->options);
914 }
915
916 int mount_custom(
917 const char *dest,
918 CustomMount *mounts, size_t n,
919 uid_t uid_shift,
920 const char *selinux_apifs_context,
921 MountSettingsMask mount_settings) {
922
923 size_t i;
924 int r;
925
926 assert(dest);
927
928 for (i = 0; i < n; i++) {
929 CustomMount *m = mounts + i;
930
931 if (FLAGS_SET(mount_settings, MOUNT_IN_USERNS) != m->in_userns)
932 continue;
933
934 if (FLAGS_SET(mount_settings, MOUNT_ROOT_ONLY) && !path_equal(m->destination, "/"))
935 continue;
936
937 if (FLAGS_SET(mount_settings, MOUNT_NON_ROOT_ONLY) && path_equal(m->destination, "/"))
938 continue;
939
940 switch (m->type) {
941
942 case CUSTOM_MOUNT_BIND:
943 r = mount_bind(dest, m);
944 break;
945
946 case CUSTOM_MOUNT_TMPFS:
947 r = mount_tmpfs(dest, m, uid_shift, selinux_apifs_context);
948 break;
949
950 case CUSTOM_MOUNT_OVERLAY:
951 r = mount_overlay(dest, m);
952 break;
953
954 case CUSTOM_MOUNT_INACCESSIBLE:
955 r = mount_inaccessible(dest, m);
956 break;
957
958 case CUSTOM_MOUNT_ARBITRARY:
959 r = mount_arbitrary(dest, m);
960 break;
961
962 default:
963 assert_not_reached("Unknown custom mount type");
964 }
965
966 if (r < 0)
967 return r;
968 }
969
970 return 0;
971 }
972
973 bool has_custom_root_mount(const CustomMount *mounts, size_t n) {
974 size_t i;
975
976 for (i = 0; i < n; i++) {
977 const CustomMount *m = mounts + i;
978
979 if (path_equal(m->destination, "/"))
980 return true;
981 }
982
983 return false;
984 }
985
986 static int setup_volatile_state(const char *directory, uid_t uid_shift, const char *selinux_apifs_context) {
987
988 _cleanup_free_ char *buf = NULL;
989 const char *p, *options;
990 int r;
991
992 assert(directory);
993
994 /* --volatile=state means we simply overmount /var with a tmpfs, and the rest read-only. */
995
996 r = bind_remount_recursive(directory, MS_RDONLY, MS_RDONLY, NULL);
997 if (r < 0)
998 return log_error_errno(r, "Failed to remount %s read-only: %m", directory);
999
1000 p = prefix_roota(directory, "/var");
1001 r = mkdir(p, 0755);
1002 if (r < 0 && errno != EEXIST)
1003 return log_error_errno(errno, "Failed to create %s: %m", directory);
1004
1005 options = "mode=755" TMPFS_LIMITS_VOLATILE_STATE;
1006 r = tmpfs_patch_options(options, uid_shift == 0 ? UID_INVALID : uid_shift, selinux_apifs_context, &buf);
1007 if (r < 0)
1008 return log_oom();
1009 if (r > 0)
1010 options = buf;
1011
1012 return mount_verbose(LOG_ERR, "tmpfs", p, "tmpfs", MS_STRICTATIME, options);
1013 }
1014
1015 static int setup_volatile_yes(const char *directory, uid_t uid_shift, const char *selinux_apifs_context) {
1016
1017 bool tmpfs_mounted = false, bind_mounted = false;
1018 char template[] = "/tmp/nspawn-volatile-XXXXXX";
1019 _cleanup_free_ char *buf = NULL, *bindir = NULL;
1020 const char *f, *t, *options;
1021 struct stat st;
1022 int r;
1023
1024 assert(directory);
1025
1026 /* --volatile=yes means we mount a tmpfs to the root dir, and the original /usr to use inside it, and
1027 * that read-only. Before we start setting this up let's validate if the image has the /usr merge
1028 * implemented, and let's output a friendly log message if it hasn't. */
1029
1030 bindir = path_join(directory, "/bin");
1031 if (!bindir)
1032 return log_oom();
1033 if (lstat(bindir, &st) < 0) {
1034 if (errno != ENOENT)
1035 return log_error_errno(errno, "Failed to stat /bin directory below image: %m");
1036
1037 /* ENOENT is fine, just means the image is probably just a naked /usr and we can create the
1038 * rest. */
1039 } else if (S_ISDIR(st.st_mode))
1040 return log_error_errno(SYNTHETIC_ERRNO(EISDIR),
1041 "Sorry, --volatile=yes mode is not supported with OS images that have not merged /bin/, /sbin/, /lib/, /lib64/ into /usr/. "
1042 "Please work with your distribution and help them adopt the merged /usr scheme.");
1043 else if (!S_ISLNK(st.st_mode))
1044 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1045 "Error starting image: if --volatile=yes is used /bin must be a symlink (for merged /usr support) or non-existent (in which case a symlink is created automatically).");
1046
1047 if (!mkdtemp(template))
1048 return log_error_errno(errno, "Failed to create temporary directory: %m");
1049
1050 options = "mode=755" TMPFS_LIMITS_ROOTFS;
1051 r = tmpfs_patch_options(options, uid_shift == 0 ? UID_INVALID : uid_shift, selinux_apifs_context, &buf);
1052 if (r < 0)
1053 goto fail;
1054 if (r > 0)
1055 options = buf;
1056
1057 r = mount_verbose(LOG_ERR, "tmpfs", template, "tmpfs", MS_STRICTATIME, options);
1058 if (r < 0)
1059 goto fail;
1060
1061 tmpfs_mounted = true;
1062
1063 f = prefix_roota(directory, "/usr");
1064 t = prefix_roota(template, "/usr");
1065
1066 r = mkdir(t, 0755);
1067 if (r < 0 && errno != EEXIST) {
1068 r = log_error_errno(errno, "Failed to create %s: %m", t);
1069 goto fail;
1070 }
1071
1072 r = mount_verbose(LOG_ERR, f, t, NULL, MS_BIND|MS_REC, NULL);
1073 if (r < 0)
1074 goto fail;
1075
1076 bind_mounted = true;
1077
1078 r = bind_remount_recursive(t, MS_RDONLY, MS_RDONLY, NULL);
1079 if (r < 0) {
1080 log_error_errno(r, "Failed to remount %s read-only: %m", t);
1081 goto fail;
1082 }
1083
1084 r = mount_verbose(LOG_ERR, template, directory, NULL, MS_MOVE, NULL);
1085 if (r < 0)
1086 goto fail;
1087
1088 (void) rmdir(template);
1089
1090 return 0;
1091
1092 fail:
1093 if (bind_mounted)
1094 (void) umount_verbose(t);
1095
1096 if (tmpfs_mounted)
1097 (void) umount_verbose(template);
1098 (void) rmdir(template);
1099 return r;
1100 }
1101
1102 static int setup_volatile_overlay(const char *directory, uid_t uid_shift, const char *selinux_apifs_context) {
1103
1104 _cleanup_free_ char *buf = NULL, *escaped_directory = NULL, *escaped_upper = NULL, *escaped_work = NULL;
1105 char template[] = "/tmp/nspawn-volatile-XXXXXX";
1106 const char *upper, *work, *options;
1107 bool tmpfs_mounted = false;
1108 int r;
1109
1110 assert(directory);
1111
1112 /* --volatile=overlay means we mount an overlayfs to the root dir. */
1113
1114 if (!mkdtemp(template))
1115 return log_error_errno(errno, "Failed to create temporary directory: %m");
1116
1117 options = "mode=755" TMPFS_LIMITS_ROOTFS;
1118 r = tmpfs_patch_options(options, uid_shift == 0 ? UID_INVALID : uid_shift, selinux_apifs_context, &buf);
1119 if (r < 0)
1120 goto finish;
1121 if (r > 0)
1122 options = buf;
1123
1124 r = mount_verbose(LOG_ERR, "tmpfs", template, "tmpfs", MS_STRICTATIME, options);
1125 if (r < 0)
1126 goto finish;
1127
1128 tmpfs_mounted = true;
1129
1130 upper = strjoina(template, "/upper");
1131 work = strjoina(template, "/work");
1132
1133 if (mkdir(upper, 0755) < 0) {
1134 r = log_error_errno(errno, "Failed to create %s: %m", upper);
1135 goto finish;
1136 }
1137 if (mkdir(work, 0755) < 0) {
1138 r = log_error_errno(errno, "Failed to create %s: %m", work);
1139 goto finish;
1140 }
1141
1142 /* And now, let's overmount the root dir with an overlayfs that uses the root dir as lower dir. It's kinda nice
1143 * that the kernel allows us to do that without going through some mount point rearrangements. */
1144
1145 escaped_directory = shell_escape(directory, ",:");
1146 escaped_upper = shell_escape(upper, ",:");
1147 escaped_work = shell_escape(work, ",:");
1148 if (!escaped_directory || !escaped_upper || !escaped_work) {
1149 r = -ENOMEM;
1150 goto finish;
1151 }
1152
1153 options = strjoina("lowerdir=", escaped_directory, ",upperdir=", escaped_upper, ",workdir=", escaped_work);
1154 r = mount_verbose(LOG_ERR, "overlay", directory, "overlay", 0, options);
1155
1156 finish:
1157 if (tmpfs_mounted)
1158 (void) umount_verbose(template);
1159
1160 (void) rmdir(template);
1161 return r;
1162 }
1163
1164 int setup_volatile_mode(
1165 const char *directory,
1166 VolatileMode mode,
1167 uid_t uid_shift,
1168 const char *selinux_apifs_context) {
1169
1170 switch (mode) {
1171
1172 case VOLATILE_YES:
1173 return setup_volatile_yes(directory, uid_shift, selinux_apifs_context);
1174
1175 case VOLATILE_STATE:
1176 return setup_volatile_state(directory, uid_shift, selinux_apifs_context);
1177
1178 case VOLATILE_OVERLAY:
1179 return setup_volatile_overlay(directory, uid_shift, selinux_apifs_context);
1180
1181 default:
1182 return 0;
1183 }
1184 }
1185
1186 /* Expects *pivot_root_new and *pivot_root_old to be initialised to allocated memory or NULL. */
1187 int pivot_root_parse(char **pivot_root_new, char **pivot_root_old, const char *s) {
1188 _cleanup_free_ char *root_new = NULL, *root_old = NULL;
1189 const char *p = s;
1190 int r;
1191
1192 assert(pivot_root_new);
1193 assert(pivot_root_old);
1194
1195 r = extract_first_word(&p, &root_new, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
1196 if (r < 0)
1197 return r;
1198 if (r == 0)
1199 return -EINVAL;
1200
1201 if (isempty(p))
1202 root_old = NULL;
1203 else {
1204 root_old = strdup(p);
1205 if (!root_old)
1206 return -ENOMEM;
1207 }
1208
1209 if (!path_is_absolute(root_new))
1210 return -EINVAL;
1211 if (root_old && !path_is_absolute(root_old))
1212 return -EINVAL;
1213
1214 free_and_replace(*pivot_root_new, root_new);
1215 free_and_replace(*pivot_root_old, root_old);
1216
1217 return 0;
1218 }
1219
1220 int setup_pivot_root(const char *directory, const char *pivot_root_new, const char *pivot_root_old) {
1221 _cleanup_free_ char *directory_pivot_root_new = NULL;
1222 _cleanup_free_ char *pivot_tmp_pivot_root_old = NULL;
1223 char pivot_tmp[] = "/tmp/nspawn-pivot-XXXXXX";
1224 bool remove_pivot_tmp = false;
1225 int r;
1226
1227 assert(directory);
1228
1229 if (!pivot_root_new)
1230 return 0;
1231
1232 /* Pivot pivot_root_new to / and the existing / to pivot_root_old.
1233 * If pivot_root_old is NULL, the existing / disappears.
1234 * This requires a temporary directory, pivot_tmp, which is
1235 * not a child of either.
1236 *
1237 * This is typically used for OSTree-style containers, where
1238 * the root partition contains several sysroots which could be
1239 * run. Normally, one would be chosen by the bootloader and
1240 * pivoted to / by initramfs.
1241 *
1242 * For example, for an OSTree deployment, pivot_root_new
1243 * would be: /ostree/deploy/$os/deploy/$checksum. Note that this
1244 * code doesn’t do the /var mount which OSTree expects: use
1245 * --bind +/sysroot/ostree/deploy/$os/var:/var for that.
1246 *
1247 * So in the OSTree case, we’ll end up with something like:
1248 * - directory = /tmp/nspawn-root-123456
1249 * - pivot_root_new = /ostree/deploy/os/deploy/123abc
1250 * - pivot_root_old = /sysroot
1251 * - directory_pivot_root_new =
1252 * /tmp/nspawn-root-123456/ostree/deploy/os/deploy/123abc
1253 * - pivot_tmp = /tmp/nspawn-pivot-123456
1254 * - pivot_tmp_pivot_root_old = /tmp/nspawn-pivot-123456/sysroot
1255 *
1256 * Requires all file systems at directory and below to be mounted
1257 * MS_PRIVATE or MS_SLAVE so they can be moved.
1258 */
1259 directory_pivot_root_new = path_join(directory, pivot_root_new);
1260 if (!directory_pivot_root_new)
1261 return log_oom();
1262
1263 /* Remount directory_pivot_root_new to make it movable. */
1264 r = mount_verbose(LOG_ERR, directory_pivot_root_new, directory_pivot_root_new, NULL, MS_BIND, NULL);
1265 if (r < 0)
1266 goto done;
1267
1268 if (pivot_root_old) {
1269 if (!mkdtemp(pivot_tmp)) {
1270 r = log_error_errno(errno, "Failed to create temporary directory: %m");
1271 goto done;
1272 }
1273
1274 remove_pivot_tmp = true;
1275 pivot_tmp_pivot_root_old = path_join(pivot_tmp, pivot_root_old);
1276 if (!pivot_tmp_pivot_root_old) {
1277 r = log_oom();
1278 goto done;
1279 }
1280
1281 r = mount_verbose(LOG_ERR, directory_pivot_root_new, pivot_tmp, NULL, MS_MOVE, NULL);
1282 if (r < 0)
1283 goto done;
1284
1285 r = mount_verbose(LOG_ERR, directory, pivot_tmp_pivot_root_old, NULL, MS_MOVE, NULL);
1286 if (r < 0)
1287 goto done;
1288
1289 r = mount_verbose(LOG_ERR, pivot_tmp, directory, NULL, MS_MOVE, NULL);
1290 if (r < 0)
1291 goto done;
1292 } else {
1293 r = mount_verbose(LOG_ERR, directory_pivot_root_new, directory, NULL, MS_MOVE, NULL);
1294 if (r < 0)
1295 goto done;
1296 }
1297
1298 done:
1299 if (remove_pivot_tmp)
1300 (void) rmdir(pivot_tmp);
1301
1302 return r;
1303 }
Unnamed repository; edit this file 'description' to name the repository.