]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
c95f9a23 | 2 | |
3c9fbb99 ZJS |
3 | #include <unistd.h> |
4 | ||
bf3598be DDM |
5 | #include "dirent-util.h" |
6 | #include "fd-util.h" | |
e59678b2 | 7 | #include "fileio.h" |
aa6aa81c | 8 | #include "fs-util.h" |
c95f9a23 LP |
9 | #include "id128-util.h" |
10 | #include "mkfs-util.h" | |
eb43379c | 11 | #include "mountpoint-util.h" |
c95f9a23 LP |
12 | #include "path-util.h" |
13 | #include "process-util.h" | |
aa6aa81c | 14 | #include "recurse-dir.h" |
bf3598be | 15 | #include "stat-util.h" |
0f2b2c48 | 16 | #include "stdio-util.h" |
c95f9a23 | 17 | #include "string-util.h" |
aa6aa81c | 18 | #include "tmpfile-util.h" |
dc91c971 | 19 | #include "utf8.h" |
c95f9a23 LP |
20 | |
21 | int mkfs_exists(const char *fstype) { | |
22 | const char *mkfs; | |
23 | int r; | |
24 | ||
25 | assert(fstype); | |
26 | ||
27 | if (STR_IN_SET(fstype, "auto", "swap")) /* these aren't real file system types, refuse early */ | |
28 | return -EINVAL; | |
29 | ||
30 | mkfs = strjoina("mkfs.", fstype); | |
31 | if (!filename_is_valid(mkfs)) /* refuse file system types with slashes and similar */ | |
32 | return -EINVAL; | |
33 | ||
f7bc0c32 | 34 | r = find_executable(mkfs, NULL); |
c95f9a23 LP |
35 | if (r == -ENOENT) |
36 | return false; | |
37 | if (r < 0) | |
38 | return r; | |
39 | ||
40 | return true; | |
41 | } | |
42 | ||
59e2be46 | 43 | int mkfs_supports_root_option(const char *fstype) { |
aa6aa81c | 44 | return fstype_is_ro(fstype) || STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "vfat", "xfs"); |
59e2be46 DDM |
45 | } |
46 | ||
7ffe593b ZJS |
47 | static int mangle_linux_fs_label(const char *s, size_t max_len, char **ret) { |
48 | /* Not more than max_len bytes (12 or 16) */ | |
49 | ||
50 | assert(s); | |
51 | assert(max_len > 0); | |
52 | assert(ret); | |
53 | ||
54 | const char *q; | |
55 | char *ans; | |
56 | ||
57 | for (q = s; *q;) { | |
58 | int l; | |
59 | ||
60 | l = utf8_encoded_valid_unichar(q, SIZE_MAX); | |
61 | if (l < 0) | |
62 | return l; | |
63 | ||
64 | if ((size_t) (q - s + l) > max_len) | |
65 | break; | |
66 | q += l; | |
67 | } | |
68 | ||
69 | ans = memdup_suffix0(s, q - s); | |
70 | if (!ans) | |
71 | return -ENOMEM; | |
72 | ||
73 | *ret = ans; | |
74 | return 0; | |
75 | } | |
76 | ||
dc91c971 ZJS |
77 | static int mangle_fat_label(const char *s, char **ret) { |
78 | assert(s); | |
79 | ||
80 | _cleanup_free_ char *q = NULL; | |
81 | int r; | |
82 | ||
83 | r = utf8_to_ascii(s, '_', &q); | |
84 | if (r < 0) | |
85 | return r; | |
86 | ||
87 | /* Classic FAT only allows 11 character uppercase labels */ | |
88 | strshorten(q, 11); | |
89 | ascii_strupper(q); | |
90 | ||
91 | /* mkfs.vfat: Labels with characters *?.,;:/\|+=<>[]" are not allowed. | |
92 | * Let's also replace any control chars. */ | |
93 | for (char *p = q; *p; p++) | |
94 | if (strchr("*?.,;:/\\|+=<>[]\"", *p) || char_is_cc(*p)) | |
95 | *p = '_'; | |
96 | ||
97 | *ret = TAKE_PTR(q); | |
98 | return 0; | |
99 | } | |
100 | ||
e59678b2 DDM |
101 | static int setup_userns(uid_t uid, gid_t gid) { |
102 | int r; | |
103 | ||
104 | /* mkfs programs tend to keep ownership intact when bootstrapping themselves from a root directory. | |
105 | * However, we'd like for the files to be owned by root instead, so we fork off a user namespace and | |
106 | * inside of it, map the uid/gid of the root directory to root in the user namespace. mkfs programs | |
107 | * will pick up on this and the files will be owned by root in the generated filesystem. */ | |
108 | ||
109 | r = write_string_filef("/proc/self/uid_map", WRITE_STRING_FILE_DISABLE_BUFFER, | |
110 | UID_FMT " " UID_FMT " " UID_FMT, 0u, uid, 1u); | |
111 | if (r < 0) | |
112 | return log_error_errno(r, | |
113 | "Failed to write mapping for "UID_FMT" to /proc/self/uid_map: %m", | |
114 | uid); | |
115 | ||
116 | r = write_string_file("/proc/self/setgroups", "deny", WRITE_STRING_FILE_DISABLE_BUFFER); | |
117 | if (r < 0) | |
118 | return log_error_errno(r, "Failed to write 'deny' to /proc/self/setgroups: %m"); | |
119 | ||
120 | r = write_string_filef("/proc/self/gid_map", WRITE_STRING_FILE_DISABLE_BUFFER, | |
29ec4bce | 121 | GID_FMT " " GID_FMT " " GID_FMT, 0u, gid, 1u); |
e59678b2 DDM |
122 | if (r < 0) |
123 | return log_error_errno(r, | |
29ec4bce | 124 | "Failed to write mapping for "GID_FMT" to /proc/self/gid_map: %m", |
e59678b2 DDM |
125 | gid); |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
bf3598be | 130 | static int do_mcopy(const char *node, const char *root) { |
fe5779cf | 131 | _cleanup_free_ char *mcopy = NULL; |
bf3598be | 132 | _cleanup_strv_free_ char **argv = NULL; |
c75cf016 DDM |
133 | _cleanup_close_ int rfd = -1; |
134 | _cleanup_free_ DirectoryEntries *de = NULL; | |
e59678b2 | 135 | struct stat st; |
bf3598be DDM |
136 | int r; |
137 | ||
138 | assert(node); | |
139 | assert(root); | |
140 | ||
141 | /* Return early if there's nothing to copy. */ | |
142 | if (dir_is_empty(root, /*ignore_hidden_or_backup=*/ false)) | |
143 | return 0; | |
144 | ||
fe5779cf DDM |
145 | r = find_executable("mcopy", &mcopy); |
146 | if (r == -ENOENT) | |
147 | return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "Could not find mcopy binary."); | |
148 | if (r < 0) | |
149 | return log_error_errno(r, "Failed to determine whether mcopy binary exists: %m"); | |
150 | ||
151 | argv = strv_new(mcopy, "-b", "-s", "-p", "-Q", "-n", "-m", "-i", node); | |
bf3598be DDM |
152 | if (!argv) |
153 | return log_oom(); | |
154 | ||
155 | /* mcopy copies the top level directory instead of everything in it so we have to pass all | |
156 | * the subdirectories to mcopy instead to end up with the correct directory structure. */ | |
157 | ||
c75cf016 DDM |
158 | rfd = open(root, O_RDONLY|O_DIRECTORY|O_CLOEXEC); |
159 | if (rfd < 0) | |
160 | return log_error_errno(errno, "Failed to open directory '%s': %m", root); | |
bf3598be | 161 | |
c75cf016 DDM |
162 | r = readdir_all(rfd, RECURSE_DIR_SORT|RECURSE_DIR_ENSURE_TYPE, &de); |
163 | if (r < 0) | |
164 | return log_error_errno(r, "Failed to read '%s' contents: %m", root); | |
165 | ||
166 | for (size_t i = 0; i < de->n_entries; i++) { | |
167 | char *p = path_join(root, de->entries[i]->d_name); | |
bf3598be DDM |
168 | if (!p) |
169 | return log_oom(); | |
170 | ||
c75cf016 DDM |
171 | if (!IN_SET(de->entries[i]->d_type, DT_REG, DT_DIR)) { |
172 | log_debug("%s is not a file/directory which are the only file types supported by vfat, ignoring", p); | |
173 | continue; | |
174 | } | |
175 | ||
bf3598be DDM |
176 | r = strv_consume(&argv, TAKE_PTR(p)); |
177 | if (r < 0) | |
178 | return log_oom(); | |
179 | } | |
180 | ||
181 | r = strv_extend(&argv, "::"); | |
182 | if (r < 0) | |
183 | return log_oom(); | |
184 | ||
c75cf016 | 185 | if (fstat(rfd, &st) < 0) |
e59678b2 DDM |
186 | return log_error_errno(errno, "Failed to stat '%s': %m", root); |
187 | ||
a9abef7f | 188 | r = safe_fork("(mcopy)", FORK_RESET_SIGNALS|FORK_RLIMIT_NOFILE_SAFE|FORK_DEATHSIG|FORK_LOG|FORK_WAIT|FORK_STDOUT_TO_STDERR|FORK_NEW_USERNS|FORK_CLOSE_ALL_FDS, NULL); |
bf3598be DDM |
189 | if (r < 0) |
190 | return r; | |
191 | if (r == 0) { | |
e59678b2 DDM |
192 | r = setup_userns(st.st_uid, st.st_gid); |
193 | if (r < 0) | |
194 | _exit(EXIT_FAILURE); | |
195 | ||
bf3598be DDM |
196 | /* Avoid failures caused by mismatch in expectations between mkfs.vfat and mcopy by disabling |
197 | * the stricter mcopy checks using MTOOLS_SKIP_CHECK. */ | |
fe5779cf | 198 | execve(mcopy, argv, STRV_MAKE("MTOOLS_SKIP_CHECK=1")); |
bf3598be DDM |
199 | |
200 | log_error_errno(errno, "Failed to execute mcopy: %m"); | |
201 | ||
202 | _exit(EXIT_FAILURE); | |
203 | } | |
204 | ||
205 | return 0; | |
206 | } | |
207 | ||
aa6aa81c DDM |
208 | static int protofile_print_item( |
209 | RecurseDirEvent event, | |
210 | const char *path, | |
211 | int dir_fd, | |
212 | int inode_fd, | |
213 | const struct dirent *de, | |
214 | const struct statx *sx, | |
215 | void *userdata) { | |
216 | ||
217 | FILE *f = ASSERT_PTR(userdata); | |
aa6aa81c DDM |
218 | int r; |
219 | ||
220 | if (event == RECURSE_DIR_LEAVE) { | |
48ac1fd1 | 221 | fputs("$\n", f); |
aa6aa81c DDM |
222 | return 0; |
223 | } | |
224 | ||
225 | if (!IN_SET(event, RECURSE_DIR_ENTER, RECURSE_DIR_ENTRY)) | |
226 | return RECURSE_DIR_CONTINUE; | |
227 | ||
aa6aa81c DDM |
228 | char type = S_ISDIR(sx->stx_mode) ? 'd' : |
229 | S_ISREG(sx->stx_mode) ? '-' : | |
230 | S_ISLNK(sx->stx_mode) ? 'l' : | |
231 | S_ISFIFO(sx->stx_mode) ? 'p' : | |
232 | S_ISBLK(sx->stx_mode) ? 'b' : | |
233 | S_ISCHR(sx->stx_mode) ? 'c' : 0; | |
234 | if (type == 0) | |
235 | return RECURSE_DIR_CONTINUE; | |
236 | ||
237 | fprintf(f, "%s %c%c%c%03o 0 0 ", | |
48ac1fd1 | 238 | de->d_name, |
aa6aa81c DDM |
239 | type, |
240 | sx->stx_mode & S_ISUID ? 'u' : '-', | |
241 | sx->stx_mode & S_ISGID ? 'g' : '-', | |
242 | (unsigned) (sx->stx_mode & 0777)); | |
243 | ||
244 | if (S_ISREG(sx->stx_mode)) | |
48ac1fd1 | 245 | fputs(path, f); |
aa6aa81c DDM |
246 | else if (S_ISLNK(sx->stx_mode)) { |
247 | _cleanup_free_ char *p = NULL; | |
248 | ||
48ac1fd1 | 249 | r = readlinkat_malloc(dir_fd, de->d_name, &p); |
aa6aa81c DDM |
250 | if (r < 0) |
251 | return log_error_errno(r, "Failed to read symlink %s: %m", path); | |
252 | ||
48ac1fd1 | 253 | fputs(p, f); |
aa6aa81c | 254 | } else if (S_ISBLK(sx->stx_mode) || S_ISCHR(sx->stx_mode)) |
48ac1fd1 | 255 | fprintf(f, "%" PRIu32 " %" PRIu32, sx->stx_rdev_major, sx->stx_rdev_minor); |
aa6aa81c | 256 | |
48ac1fd1 | 257 | fputc('\n', f); |
aa6aa81c DDM |
258 | |
259 | return RECURSE_DIR_CONTINUE; | |
260 | } | |
261 | ||
262 | static int make_protofile(const char *root, char **ret) { | |
263 | _cleanup_fclose_ FILE *f = NULL; | |
48ac1fd1 DDM |
264 | _cleanup_(unlink_and_freep) char *p = NULL; |
265 | const char *vt; | |
aa6aa81c DDM |
266 | int r; |
267 | ||
268 | assert(ret); | |
269 | ||
48ac1fd1 DDM |
270 | r = var_tmp_dir(&vt); |
271 | if (r < 0) | |
272 | return log_error_errno(r, "Failed to get persistent temporary directory: %m"); | |
273 | ||
274 | r = fopen_temporary_child(vt, &f, &p); | |
aa6aa81c DDM |
275 | if (r < 0) |
276 | return log_error_errno(r, "Failed to open temporary file: %m"); | |
277 | ||
48ac1fd1 DDM |
278 | fputs("/\n" |
279 | "0 0\n" | |
280 | "d--755 0 0\n", f); | |
aa6aa81c | 281 | |
c75cf016 | 282 | r = recurse_dir_at(AT_FDCWD, root, STATX_TYPE|STATX_MODE, UINT_MAX, RECURSE_DIR_SORT, protofile_print_item, f); |
aa6aa81c DDM |
283 | if (r < 0) |
284 | return log_error_errno(r, "Failed to recurse through %s: %m", root); | |
285 | ||
48ac1fd1 | 286 | fputs("$\n", f); |
aa6aa81c DDM |
287 | |
288 | r = fflush_and_check(f); | |
289 | if (r < 0) | |
290 | return log_error_errno(r, "Failed to flush %s: %m", p); | |
291 | ||
292 | *ret = TAKE_PTR(p); | |
293 | ||
294 | return 0; | |
295 | } | |
296 | ||
c95f9a23 LP |
297 | int make_filesystem( |
298 | const char *node, | |
299 | const char *fstype, | |
300 | const char *label, | |
7f55ad77 | 301 | const char *root, |
c95f9a23 LP |
302 | sd_id128_t uuid, |
303 | bool discard) { | |
304 | ||
dc91c971 | 305 | _cleanup_free_ char *mkfs = NULL, *mangled_label = NULL; |
ddf615a1 | 306 | _cleanup_strv_free_ char **argv = NULL; |
aa6aa81c | 307 | _cleanup_(unlink_and_freep) char *protofile = NULL; |
b7416360 | 308 | char vol_id[CONST_MAX(SD_ID128_UUID_STRING_MAX, 8U + 1U)] = {}; |
e59678b2 | 309 | struct stat st; |
c95f9a23 LP |
310 | int r; |
311 | ||
312 | assert(node); | |
313 | assert(fstype); | |
314 | assert(label); | |
315 | ||
eb43379c DDM |
316 | if (fstype_is_ro(fstype) && !root) |
317 | return log_error_errno(SYNTHETIC_ERRNO(EINVAL), | |
318 | "Cannot generate read-only filesystem %s without a source tree.", | |
319 | fstype); | |
320 | ||
c95f9a23 | 321 | if (streq(fstype, "swap")) { |
7f55ad77 DDM |
322 | if (root) |
323 | return log_error_errno(SYNTHETIC_ERRNO(EINVAL), | |
324 | "A swap filesystem can't be populated, refusing"); | |
f7bc0c32 | 325 | r = find_executable("mkswap", &mkfs); |
c95f9a23 LP |
326 | if (r == -ENOENT) |
327 | return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkswap binary not available."); | |
328 | if (r < 0) | |
329 | return log_error_errno(r, "Failed to determine whether mkswap binary exists: %m"); | |
7f55ad77 | 330 | } else if (streq(fstype, "squashfs")) { |
7f55ad77 DDM |
331 | r = find_executable("mksquashfs", &mkfs); |
332 | if (r == -ENOENT) | |
333 | return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mksquashfs binary not available."); | |
334 | if (r < 0) | |
335 | return log_error_errno(r, "Failed to determine whether mksquashfs binary exists: %m"); | |
eaec6994 DDM |
336 | } else if (fstype_is_ro(fstype)) { |
337 | return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), | |
338 | "Don't know how to create read-only file system '%s', refusing.", | |
339 | fstype); | |
c95f9a23 | 340 | } else { |
59e2be46 | 341 | if (root && !mkfs_supports_root_option(fstype)) |
7f55ad77 | 342 | return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), |
59e2be46 | 343 | "Populating with source tree is not supported for %s", fstype); |
c95f9a23 LP |
344 | r = mkfs_exists(fstype); |
345 | if (r < 0) | |
346 | return log_error_errno(r, "Failed to determine whether mkfs binary for %s exists: %m", fstype); | |
347 | if (r == 0) | |
348 | return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkfs binary for %s is not available.", fstype); | |
349 | ||
350 | mkfs = strjoin("mkfs.", fstype); | |
351 | if (!mkfs) | |
352 | return log_oom(); | |
353 | } | |
354 | ||
8d433a99 ZJS |
355 | if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "xfs", "swap")) { |
356 | size_t max_len = | |
357 | streq(fstype, "xfs") ? 12 : | |
358 | streq(fstype, "swap") ? 15 : | |
359 | 16; | |
360 | ||
361 | r = mangle_linux_fs_label(label, max_len, &mangled_label); | |
7ffe593b | 362 | if (r < 0) |
8d433a99 | 363 | return log_error_errno(r, "Failed to determine volume label from string \"%s\": %m", label); |
7ffe593b ZJS |
364 | label = mangled_label; |
365 | ||
366 | } else if (streq(fstype, "vfat")) { | |
dc91c971 ZJS |
367 | r = mangle_fat_label(label, &mangled_label); |
368 | if (r < 0) | |
369 | return log_error_errno(r, "Failed to determine FAT label from string \"%s\": %m", label); | |
4f05a11c ZJS |
370 | label = mangled_label; |
371 | ||
372 | xsprintf(vol_id, "%08" PRIx32, | |
373 | ((uint32_t) uuid.bytes[0] << 24) | | |
374 | ((uint32_t) uuid.bytes[1] << 16) | | |
375 | ((uint32_t) uuid.bytes[2] << 8) | | |
376 | ((uint32_t) uuid.bytes[3])); /* Take first 32 bytes of UUID */ | |
377 | } | |
378 | ||
379 | if (isempty(vol_id)) | |
b7416360 | 380 | assert_se(sd_id128_to_uuid_string(uuid, vol_id)); |
4f05a11c | 381 | |
ddf615a1 | 382 | /* When changing this conditional, also adjust the log statement below. */ |
59e2be46 | 383 | if (streq(fstype, "ext2")) { |
ddf615a1 DDM |
384 | argv = strv_new(mkfs, |
385 | "-q", | |
386 | "-L", label, | |
387 | "-U", vol_id, | |
388 | "-I", "256", | |
389 | "-m", "0", | |
390 | "-E", discard ? "discard,lazy_itable_init=1" : "nodiscard,lazy_itable_init=1", | |
391 | node); | |
59e2be46 DDM |
392 | if (!argv) |
393 | return log_oom(); | |
394 | ||
395 | if (root) { | |
396 | r = strv_extend_strv(&argv, STRV_MAKE("-d", root), false); | |
397 | if (r < 0) | |
398 | return log_oom(); | |
399 | } | |
ddf615a1 | 400 | |
59e2be46 | 401 | } else if (STR_IN_SET(fstype, "ext3", "ext4")) { |
ddf615a1 DDM |
402 | argv = strv_new(mkfs, |
403 | "-q", | |
404 | "-L", label, | |
405 | "-U", vol_id, | |
406 | "-I", "256", | |
407 | "-O", "has_journal", | |
408 | "-m", "0", | |
409 | "-E", discard ? "discard,lazy_itable_init=1" : "nodiscard,lazy_itable_init=1", | |
410 | node); | |
411 | ||
59e2be46 DDM |
412 | if (root) { |
413 | r = strv_extend_strv(&argv, STRV_MAKE("-d", root), false); | |
414 | if (r < 0) | |
415 | return log_oom(); | |
416 | } | |
417 | ||
418 | } else if (streq(fstype, "btrfs")) { | |
ddf615a1 DDM |
419 | argv = strv_new(mkfs, |
420 | "-q", | |
421 | "-L", label, | |
422 | "-U", vol_id, | |
423 | node); | |
424 | if (!argv) | |
425 | return log_oom(); | |
426 | ||
427 | if (!discard) { | |
428 | r = strv_extend(&argv, "--nodiscard"); | |
429 | if (r < 0) | |
430 | return log_oom(); | |
431 | } | |
432 | ||
59e2be46 DDM |
433 | if (root) { |
434 | r = strv_extend_strv(&argv, STRV_MAKE("-r", root), false); | |
435 | if (r < 0) | |
436 | return log_oom(); | |
437 | } | |
438 | ||
ddf615a1 DDM |
439 | } else if (streq(fstype, "f2fs")) { |
440 | argv = strv_new(mkfs, | |
441 | "-q", | |
442 | "-g", /* "default options" */ | |
443 | "-f", /* force override, without this it doesn't seem to want to write to an empty partition */ | |
444 | "-l", label, | |
445 | "-U", vol_id, | |
446 | "-t", one_zero(discard), | |
447 | node); | |
448 | ||
449 | } else if (streq(fstype, "xfs")) { | |
450 | const char *j; | |
451 | ||
452 | j = strjoina("uuid=", vol_id); | |
453 | ||
454 | argv = strv_new(mkfs, | |
455 | "-q", | |
456 | "-L", label, | |
457 | "-m", j, | |
458 | "-m", "reflink=1", | |
459 | node); | |
460 | if (!argv) | |
461 | return log_oom(); | |
462 | ||
463 | if (!discard) { | |
464 | r = strv_extend(&argv, "-K"); | |
465 | if (r < 0) | |
466 | return log_oom(); | |
467 | } | |
468 | ||
aa6aa81c DDM |
469 | if (root) { |
470 | r = make_protofile(root, &protofile); | |
471 | if (r < 0) | |
472 | return r; | |
473 | ||
474 | r = strv_extend_strv(&argv, STRV_MAKE("-p", protofile), false); | |
475 | if (r < 0) | |
476 | return log_oom(); | |
477 | } | |
478 | ||
ddf615a1 DDM |
479 | } else if (streq(fstype, "vfat")) |
480 | ||
481 | argv = strv_new(mkfs, | |
482 | "-i", vol_id, | |
483 | "-n", label, | |
484 | "-F", "32", /* yes, we force FAT32 here */ | |
485 | node); | |
486 | ||
487 | else if (streq(fstype, "swap")) | |
488 | /* TODO: add --quiet here if | |
489 | * https://github.com/util-linux/util-linux/issues/1499 resolved. */ | |
490 | ||
491 | argv = strv_new(mkfs, | |
492 | "-L", label, | |
493 | "-U", vol_id, | |
494 | node); | |
495 | ||
496 | else if (streq(fstype, "squashfs")) | |
497 | ||
498 | argv = strv_new(mkfs, | |
499 | root, node, | |
500 | "-quiet", | |
501 | "-noappend"); | |
502 | else | |
503 | /* Generic fallback for all other file systems */ | |
504 | argv = strv_new(mkfs, node); | |
505 | ||
506 | if (!argv) | |
507 | return log_oom(); | |
508 | ||
e59678b2 DDM |
509 | if (root && stat(root, &st) < 0) |
510 | return log_error_errno(errno, "Failed to stat %s: %m", root); | |
511 | ||
a9abef7f | 512 | r = safe_fork("(mkfs)", FORK_RESET_SIGNALS|FORK_RLIMIT_NOFILE_SAFE|FORK_DEATHSIG|FORK_LOG|FORK_WAIT|FORK_STDOUT_TO_STDERR|FORK_CLOSE_ALL_FDS|(root ? FORK_NEW_USERNS : 0), NULL); |
c95f9a23 LP |
513 | if (r < 0) |
514 | return r; | |
515 | if (r == 0) { | |
c95f9a23 | 516 | /* Child */ |
4f05a11c | 517 | |
e59678b2 DDM |
518 | if (root) { |
519 | r = setup_userns(st.st_uid, st.st_gid); | |
520 | if (r < 0) | |
521 | _exit(EXIT_FAILURE); | |
522 | } | |
523 | ||
ddf615a1 | 524 | execvp(mkfs, argv); |
c95f9a23 LP |
525 | |
526 | log_error_errno(errno, "Failed to execute %s: %m", mkfs); | |
527 | ||
528 | _exit(EXIT_FAILURE); | |
529 | } | |
530 | ||
bf3598be DDM |
531 | if (root && streq(fstype, "vfat")) { |
532 | r = do_mcopy(node, root); | |
533 | if (r < 0) | |
534 | return r; | |
535 | } | |
536 | ||
2d96440f | 537 | if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "f2fs", "xfs", "vfat", "swap")) |
4f05a11c ZJS |
538 | log_info("%s successfully formatted as %s (label \"%s\", uuid %s)", |
539 | node, fstype, label, vol_id); | |
540 | else | |
541 | log_info("%s successfully formatted as %s (no label or uuid specified)", | |
542 | node, fstype); | |
543 | ||
c95f9a23 LP |
544 | return 0; |
545 | } |