[thirdparty/systemd.git] / src / shared / mkfs-util.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <unistd.h>

#include "dirent-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "id128-util.h"
#include "mkfs-util.h"
#include "mountpoint-util.h"
#include "path-util.h"
#include "process-util.h"
#include "recurse-dir.h"
#include "stat-util.h"
#include "stdio-util.h"
#include "string-util.h"
#include "tmpfile-util.h"
#include "utf8.h"

int mkfs_exists(const char *fstype) {
        const char *mkfs;
        int r;

        assert(fstype);

        if (STR_IN_SET(fstype, "auto", "swap")) /* these aren't real file system types, refuse early */
                return -EINVAL;

        mkfs = strjoina("mkfs.", fstype);
        if (!filename_is_valid(mkfs)) /* refuse file system types with slashes and similar */
                return -EINVAL;

        r = find_executable(mkfs, NULL);
        if (r == -ENOENT)
                return false;
        if (r < 0)
                return r;

        return true;
}

int mkfs_supports_root_option(const char *fstype) {
        return fstype_is_ro(fstype) || STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "vfat", "xfs");
}

static int mangle_linux_fs_label(const char *s, size_t max_len, char **ret) {
        /* Not more than max_len bytes (12 or 16) */

        assert(s);
        assert(max_len > 0);
        assert(ret);

        const char *q;
        char *ans;

        for (q = s; *q;) {
                int l;

                l = utf8_encoded_valid_unichar(q, SIZE_MAX);
                if (l < 0)
                        return l;

                if ((size_t) (q - s + l) > max_len)
                        break;
                q += l;
        }

        ans = memdup_suffix0(s, q - s);
        if (!ans)
                return -ENOMEM;

        *ret = ans;
        return 0;
}

static int mangle_fat_label(const char *s, char **ret) {
        assert(s);

        _cleanup_free_ char *q = NULL;
        int r;

        r = utf8_to_ascii(s, '_', &q);
        if (r < 0)
                return r;

        /* Classic FAT only allows 11 character uppercase labels */
        strshorten(q, 11);
        ascii_strupper(q);

        /* mkfs.vfat: Labels with characters *?.,;:/\|+=<>[]" are not allowed.
         * Let's also replace any control chars. */
        for (char *p = q; *p; p++)
                if (strchr("*?.,;:/\\|+=<>[]\"", *p) || char_is_cc(*p))
                        *p = '_';

        *ret = TAKE_PTR(q);
        return 0;
}

static int setup_userns(uid_t uid, gid_t gid) {
        int r;

       /* mkfs programs tend to keep ownership intact when bootstrapping themselves from a root directory.
        * However, we'd like for the files to be owned by root instead, so we fork off a user namespace and
        * inside of it, map the uid/gid of the root directory to root in the user namespace. mkfs programs
        * will pick up on this and the files will be owned by root in the generated filesystem. */

        r = write_string_filef("/proc/self/uid_map", WRITE_STRING_FILE_DISABLE_BUFFER,
                                UID_FMT " " UID_FMT " " UID_FMT, 0u, uid, 1u);
        if (r < 0)
                return log_error_errno(r,
                                       "Failed to write mapping for "UID_FMT" to /proc/self/uid_map: %m",
                                       uid);

        r = write_string_file("/proc/self/setgroups", "deny", WRITE_STRING_FILE_DISABLE_BUFFER);
        if (r < 0)
                return log_error_errno(r, "Failed to write 'deny' to /proc/self/setgroups: %m");

        r = write_string_filef("/proc/self/gid_map", WRITE_STRING_FILE_DISABLE_BUFFER,
                                GID_FMT " " GID_FMT " " GID_FMT, 0u, gid, 1u);
        if (r < 0)
                return log_error_errno(r,
                                       "Failed to write mapping for "GID_FMT" to /proc/self/gid_map: %m",
                                       gid);

        return 0;
}

static int do_mcopy(const char *node, const char *root) {
        _cleanup_free_ char *mcopy = NULL;
        _cleanup_strv_free_ char **argv = NULL;
        _cleanup_close_ int rfd = -1;
        _cleanup_free_ DirectoryEntries *de = NULL;
        struct stat st;
        int r;

        assert(node);
        assert(root);

        /* Return early if there's nothing to copy. */
        if (dir_is_empty(root, /*ignore_hidden_or_backup=*/ false))
                return 0;

        r = find_executable("mcopy", &mcopy);
        if (r == -ENOENT)
                return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "Could not find mcopy binary.");
        if (r < 0)
                return log_error_errno(r, "Failed to determine whether mcopy binary exists: %m");

        argv = strv_new(mcopy, "-s", "-p", "-Q", "-m", "-i", node);
        if (!argv)
                return log_oom();

        /* mcopy copies the top level directory instead of everything in it so we have to pass all
         * the subdirectories to mcopy instead to end up with the correct directory structure. */

        rfd = open(root, O_RDONLY|O_DIRECTORY|O_CLOEXEC);
        if (rfd < 0)
                return log_error_errno(errno, "Failed to open directory '%s': %m", root);

        r = readdir_all(rfd, RECURSE_DIR_SORT|RECURSE_DIR_ENSURE_TYPE, &de);
        if (r < 0)
                return log_error_errno(r, "Failed to read '%s' contents: %m", root);

        for (size_t i = 0; i < de->n_entries; i++) {
                _cleanup_free_ char *p = NULL;

                p = path_join(root, de->entries[i]->d_name);
                if (!p)
                        return log_oom();

                if (!IN_SET(de->entries[i]->d_type, DT_REG, DT_DIR)) {
                        log_debug("%s is not a file/directory which are the only file types supported by vfat, ignoring", p);
                        continue;
                }

                r = strv_consume(&argv, TAKE_PTR(p));
                if (r < 0)
                        return log_oom();
        }

        r = strv_extend(&argv, "::");
        if (r < 0)
                return log_oom();

        if (fstat(rfd, &st) < 0)
                return log_error_errno(errno, "Failed to stat '%s': %m", root);

        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);
        if (r < 0)
                return r;
        if (r == 0) {
                r = setup_userns(st.st_uid, st.st_gid);
                if (r < 0)
                        _exit(EXIT_FAILURE);

                /* Avoid failures caused by mismatch in expectations between mkfs.vfat and mcopy by disabling
                 * the stricter mcopy checks using MTOOLS_SKIP_CHECK. */
                execve(mcopy, argv, STRV_MAKE("MTOOLS_SKIP_CHECK=1"));

                log_error_errno(errno, "Failed to execute mcopy: %m");

                _exit(EXIT_FAILURE);
        }

        return 0;
}

static int protofile_print_item(
                RecurseDirEvent event,
                const char *path,
                int dir_fd,
                int inode_fd,
                const struct dirent *de,
                const struct statx *sx,
                void *userdata) {

        FILE *f = ASSERT_PTR(userdata);
        int r;

        if (event == RECURSE_DIR_LEAVE) {
                fputs("$\n", f);
                return 0;
        }

        if (!IN_SET(event, RECURSE_DIR_ENTER, RECURSE_DIR_ENTRY))
                return RECURSE_DIR_CONTINUE;

        char type = S_ISDIR(sx->stx_mode)  ? 'd' :
                    S_ISREG(sx->stx_mode)  ? '-' :
                    S_ISLNK(sx->stx_mode)  ? 'l' :
                    S_ISFIFO(sx->stx_mode) ? 'p' :
                    S_ISBLK(sx->stx_mode)  ? 'b' :
                    S_ISCHR(sx->stx_mode)  ? 'c' : 0;
        if (type == 0)
                return RECURSE_DIR_CONTINUE;

        fprintf(f, "%s %c%c%c%03o 0 0 ",
                de->d_name,
                type,
                sx->stx_mode & S_ISUID ? 'u' : '-',
                sx->stx_mode & S_ISGID ? 'g' : '-',
                (unsigned) (sx->stx_mode & 0777));

        if (S_ISREG(sx->stx_mode))
                fputs(path, f);
        else if (S_ISLNK(sx->stx_mode)) {
                _cleanup_free_ char *p = NULL;

                r = readlinkat_malloc(dir_fd, de->d_name, &p);
                if (r < 0)
                        return log_error_errno(r, "Failed to read symlink %s: %m", path);

                fputs(p, f);
        } else if (S_ISBLK(sx->stx_mode) || S_ISCHR(sx->stx_mode))
                fprintf(f, "%" PRIu32 " %" PRIu32, sx->stx_rdev_major, sx->stx_rdev_minor);

        fputc('\n', f);

        return RECURSE_DIR_CONTINUE;
}

static int make_protofile(const char *root, char **ret) {
        _cleanup_fclose_ FILE *f = NULL;
        _cleanup_(unlink_and_freep) char *p = NULL;
        const char *vt;
        int r;

        assert(ret);

        r = var_tmp_dir(&vt);
        if (r < 0)
                return log_error_errno(r, "Failed to get persistent temporary directory: %m");

        r = fopen_temporary_child(vt, &f, &p);
        if (r < 0)
                return log_error_errno(r, "Failed to open temporary file: %m");

        fputs("/\n"
              "0 0\n"
              "d--755 0 0\n", f);

        r = recurse_dir_at(AT_FDCWD, root, STATX_TYPE|STATX_MODE, UINT_MAX, RECURSE_DIR_SORT, protofile_print_item, f);
        if (r < 0)
                return log_error_errno(r, "Failed to recurse through %s: %m", root);

        fputs("$\n", f);

        r = fflush_and_check(f);
        if (r < 0)
                return log_error_errno(r, "Failed to flush %s: %m", p);

        *ret = TAKE_PTR(p);

        return 0;
}

int make_filesystem(
                const char *node,
                const char *fstype,
                const char *label,
                const char *root,
                sd_id128_t uuid,
                bool discard) {

        _cleanup_free_ char *mkfs = NULL, *mangled_label = NULL;
        _cleanup_strv_free_ char **argv = NULL;
        _cleanup_(unlink_and_freep) char *protofile = NULL;
        char vol_id[CONST_MAX(SD_ID128_UUID_STRING_MAX, 8U + 1U)] = {};
        struct stat st;
        int r;

        assert(node);
        assert(fstype);
        assert(label);

        if (fstype_is_ro(fstype) && !root)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Cannot generate read-only filesystem %s without a source tree.",
                                       fstype);

        if (streq(fstype, "swap")) {
                if (root)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "A swap filesystem can't be populated, refusing");
                r = find_executable("mkswap", &mkfs);
                if (r == -ENOENT)
                        return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkswap binary not available.");
                if (r < 0)
                        return log_error_errno(r, "Failed to determine whether mkswap binary exists: %m");
        } else if (streq(fstype, "squashfs")) {
                r = find_executable("mksquashfs", &mkfs);
                if (r == -ENOENT)
                        return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mksquashfs binary not available.");
                if (r < 0)
                        return log_error_errno(r, "Failed to determine whether mksquashfs binary exists: %m");

        } else if (streq(fstype, "erofs")) {
                r = find_executable("mkfs.erofs", &mkfs);
                if (r == -ENOENT)
                        return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkfs.erofs binary not available.");
                if (r < 0)
                        return log_error_errno(r, "Failed to determine whether mkfs.erofs binary exists: %m");

        } else if (fstype_is_ro(fstype)) {
                return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                                       "Don't know how to create read-only file system '%s', refusing.",
                                                       fstype);
        } else {
                if (root && !mkfs_supports_root_option(fstype))
                        return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                               "Populating with source tree is not supported for %s", fstype);
                r = mkfs_exists(fstype);
                if (r < 0)
                        return log_error_errno(r, "Failed to determine whether mkfs binary for %s exists: %m", fstype);
                if (r == 0)
                        return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkfs binary for %s is not available.", fstype);

                mkfs = strjoin("mkfs.", fstype);
                if (!mkfs)
                        return log_oom();
        }

        if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "xfs", "swap")) {
                size_t max_len =
                        streq(fstype, "xfs") ? 12 :
                        streq(fstype, "swap") ? 15 :
                        16;

                r = mangle_linux_fs_label(label, max_len, &mangled_label);
                if (r < 0)
                        return log_error_errno(r, "Failed to determine volume label from string \"%s\": %m", label);
                label = mangled_label;

        } else if (streq(fstype, "vfat")) {
                r = mangle_fat_label(label, &mangled_label);
                if (r < 0)
                        return log_error_errno(r, "Failed to determine FAT label from string \"%s\": %m", label);
                label = mangled_label;

                xsprintf(vol_id, "%08" PRIx32,
                         ((uint32_t) uuid.bytes[0] << 24) |
                         ((uint32_t) uuid.bytes[1] << 16) |
                         ((uint32_t) uuid.bytes[2] << 8) |
                         ((uint32_t) uuid.bytes[3])); /* Take first 32 bytes of UUID */
        }

        if (isempty(vol_id))
                assert_se(sd_id128_to_uuid_string(uuid, vol_id));

        /* When changing this conditional, also adjust the log statement below. */
        if (streq(fstype, "ext2")) {
                argv = strv_new(mkfs,
                                "-q",
                                "-L", label,
                                "-U", vol_id,
                                "-I", "256",
                                "-m", "0",
                                "-E", discard ? "discard,lazy_itable_init=1" : "nodiscard,lazy_itable_init=1",
                                node);
                if (!argv)
                        return log_oom();

                if (root) {
                        r = strv_extend_strv(&argv, STRV_MAKE("-d", root), false);
                        if (r < 0)
                                return log_oom();
                }

        } else if (STR_IN_SET(fstype, "ext3", "ext4")) {
                argv = strv_new(mkfs,
                                "-q",
                                "-L", label,
                                "-U", vol_id,
                                "-I", "256",
                                "-O", "has_journal",
                                "-m", "0",
                                "-E", discard ? "discard,lazy_itable_init=1" : "nodiscard,lazy_itable_init=1",
                                node);

                if (root) {
                        r = strv_extend_strv(&argv, STRV_MAKE("-d", root), false);
                        if (r < 0)
                                return log_oom();
                }

        } else if (streq(fstype, "btrfs")) {
                argv = strv_new(mkfs,
                                "-q",
                                "-L", label,
                                "-U", vol_id,
                                node);
                if (!argv)
                        return log_oom();

                if (!discard) {
                        r = strv_extend(&argv, "--nodiscard");
                        if (r < 0)
                                return log_oom();
                }

                if (root) {
                        r = strv_extend_strv(&argv, STRV_MAKE("-r", root), false);
                        if (r < 0)
                                return log_oom();
                }

        } else if (streq(fstype, "f2fs")) {
                argv = strv_new(mkfs,
                                "-q",
                                "-g",  /* "default options" */
                                "-f",  /* force override, without this it doesn't seem to want to write to an empty partition */
                                "-l", label,
                                "-U", vol_id,
                                "-t", one_zero(discard),
                                node);

        } else if (streq(fstype, "xfs")) {
                const char *j;

                j = strjoina("uuid=", vol_id);

                argv = strv_new(mkfs,
                                "-q",
                                "-L", label,
                                "-m", j,
                                "-m", "reflink=1",
                                node);
                if (!argv)
                        return log_oom();

                if (!discard) {
                        r = strv_extend(&argv, "-K");
                        if (r < 0)
                                return log_oom();
                }

                if (root) {
                        r = make_protofile(root, &protofile);
                        if (r < 0)
                                return r;

                        r = strv_extend_strv(&argv, STRV_MAKE("-p", protofile), false);
                        if (r < 0)
                                return log_oom();
                }

        } else if (streq(fstype, "vfat"))

                argv = strv_new(mkfs,
                                "-i", vol_id,
                                "-n", label,
                                "-F", "32",  /* yes, we force FAT32 here */
                                node);

        else if (streq(fstype, "swap"))
                /* TODO: add --quiet here if
                 * https://github.com/util-linux/util-linux/issues/1499 resolved. */

                argv = strv_new(mkfs,
                                "-L", label,
                                "-U", vol_id,
                                node);

        else if (streq(fstype, "squashfs"))

                argv = strv_new(mkfs,
                                root, node,
                                "-quiet",
                                "-noappend");

        else if (streq(fstype, "erofs"))

                argv = strv_new(mkfs,
                                "-U", vol_id,
                                node, root);
        else
                /* Generic fallback for all other file systems */
                argv = strv_new(mkfs, node);

        if (!argv)
                return log_oom();

        if (root && stat(root, &st) < 0)
                return log_error_errno(errno, "Failed to stat %s: %m", root);

        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);
        if (r < 0)
                return r;
        if (r == 0) {
                /* Child */

                if (root) {
                        r = setup_userns(st.st_uid, st.st_gid);
                        if (r < 0)
                                _exit(EXIT_FAILURE);
                }

                execvp(mkfs, argv);

                log_error_errno(errno, "Failed to execute %s: %m", mkfs);

                _exit(EXIT_FAILURE);
        }

        if (root && streq(fstype, "vfat")) {
                r = do_mcopy(node, root);
                if (r < 0)
                        return r;
        }

        if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "f2fs", "xfs", "vfat", "swap"))
                log_info("%s successfully formatted as %s (label \"%s\", uuid %s)",
                         node, fstype, label, vol_id);
        else if (streq(fstype, "erofs"))
                log_info("%s successfully formatted as %s (uuid %s, no label)",
                         node, fstype, vol_id);
        else
                log_info("%s successfully formatted as %s (no label or uuid specified)",
                         node, fstype);

        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
c95f9a23	2
3c9fbb99 ZJS	3	#include <unistd.h>
3c9fbb99 ZJS	4
bf3598be DDM	5	#include "dirent-util.h"
bf3598be DDM	6	#include "fd-util.h"
e59678b2	7	#include "fileio.h"
aa6aa81c	8	#include "fs-util.h"
c95f9a23 LP	9	#include "id128-util.h"
c95f9a23 LP	10	#include "mkfs-util.h"
eb43379c	11	#include "mountpoint-util.h"
c95f9a23 LP	12	#include "path-util.h"
c95f9a23 LP	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	}
59e2be46 DDM	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)
e59678b2 DDM	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;
c75cf016 DDM	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
cf9c27b1	151	argv = strv_new(mcopy, "-s", "-p", "-Q", "-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++) {
f3c8cb27 YW	167	_cleanup_free_ char *p = NULL;
	168
	169	p = path_join(root, de->entries[i]->d_name);
bf3598be DDM	170	if (!p)
	171	return log_oom();
	172
c75cf016 DDM	173	if (!IN_SET(de->entries[i]->d_type, DT_REG, DT_DIR)) {
	174	log_debug("%s is not a file/directory which are the only file types supported by vfat, ignoring", p);
	175	continue;
	176	}
	177
bf3598be DDM	178	r = strv_consume(&argv, TAKE_PTR(p));
	179	if (r < 0)
	180	return log_oom();
	181	}
	182
	183	r = strv_extend(&argv, "::");
	184	if (r < 0)
	185	return log_oom();
	186
c75cf016	187	if (fstat(rfd, &st) < 0)
e59678b2 DDM	188	return log_error_errno(errno, "Failed to stat '%s': %m", root);
e59678b2 DDM	189
a9abef7f	190	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	191	if (r < 0)
	192	return r;
	193	if (r == 0) {
e59678b2 DDM	194	r = setup_userns(st.st_uid, st.st_gid);
	195	if (r < 0)
	196	_exit(EXIT_FAILURE);
	197
bf3598be DDM	198	/* Avoid failures caused by mismatch in expectations between mkfs.vfat and mcopy by disabling
bf3598be DDM	199	* the stricter mcopy checks using MTOOLS_SKIP_CHECK. */
fe5779cf	200	execve(mcopy, argv, STRV_MAKE("MTOOLS_SKIP_CHECK=1"));
bf3598be DDM	201
	202	log_error_errno(errno, "Failed to execute mcopy: %m");
	203
	204	_exit(EXIT_FAILURE);
	205	}
	206
	207	return 0;
	208	}
	209
aa6aa81c DDM	210	static int protofile_print_item(
	211	RecurseDirEvent event,
	212	const char *path,
	213	int dir_fd,
	214	int inode_fd,
	215	const struct dirent *de,
	216	const struct statx *sx,
	217	void *userdata) {
	218
	219	FILE *f = ASSERT_PTR(userdata);
aa6aa81c DDM	220	int r;
	221
	222	if (event == RECURSE_DIR_LEAVE) {
48ac1fd1	223	fputs("$\n", f);
aa6aa81c DDM	224	return 0;
	225	}
	226
	227	if (!IN_SET(event, RECURSE_DIR_ENTER, RECURSE_DIR_ENTRY))
	228	return RECURSE_DIR_CONTINUE;
	229
aa6aa81c DDM	230	char type = S_ISDIR(sx->stx_mode) ? 'd' :
	231	S_ISREG(sx->stx_mode) ? '-' :
	232	S_ISLNK(sx->stx_mode) ? 'l' :
	233	S_ISFIFO(sx->stx_mode) ? 'p' :
	234	S_ISBLK(sx->stx_mode) ? 'b' :
	235	S_ISCHR(sx->stx_mode) ? 'c' : 0;
	236	if (type == 0)
	237	return RECURSE_DIR_CONTINUE;
	238
	239	fprintf(f, "%s %c%c%c%03o 0 0 ",
48ac1fd1	240	de->d_name,
aa6aa81c DDM	241	type,
	242	sx->stx_mode & S_ISUID ? 'u' : '-',
	243	sx->stx_mode & S_ISGID ? 'g' : '-',
	244	(unsigned) (sx->stx_mode & 0777));
	245
	246	if (S_ISREG(sx->stx_mode))
48ac1fd1	247	fputs(path, f);
aa6aa81c DDM	248	else if (S_ISLNK(sx->stx_mode)) {
	249	_cleanup_free_ char *p = NULL;
	250
48ac1fd1	251	r = readlinkat_malloc(dir_fd, de->d_name, &p);
aa6aa81c DDM	252	if (r < 0)
	253	return log_error_errno(r, "Failed to read symlink %s: %m", path);
	254
48ac1fd1	255	fputs(p, f);
aa6aa81c	256	} else if (S_ISBLK(sx->stx_mode) \|\| S_ISCHR(sx->stx_mode))
48ac1fd1	257	fprintf(f, "%" PRIu32 " %" PRIu32, sx->stx_rdev_major, sx->stx_rdev_minor);
aa6aa81c	258
48ac1fd1	259	fputc('\n', f);
aa6aa81c DDM	260
	261	return RECURSE_DIR_CONTINUE;
	262	}
	263
	264	static int make_protofile(const char root, char *ret) {
	265	_cleanup_fclose_ FILE *f = NULL;
48ac1fd1 DDM	266	_cleanup_(unlink_and_freep) char *p = NULL;
48ac1fd1 DDM	267	const char *vt;
aa6aa81c DDM	268	int r;
	269
	270	assert(ret);
	271
48ac1fd1 DDM	272	r = var_tmp_dir(&vt);
	273	if (r < 0)
	274	return log_error_errno(r, "Failed to get persistent temporary directory: %m");
	275
	276	r = fopen_temporary_child(vt, &f, &p);
aa6aa81c DDM	277	if (r < 0)
	278	return log_error_errno(r, "Failed to open temporary file: %m");
	279
48ac1fd1 DDM	280	fputs("/\n"
	281	"0 0\n"
	282	"d--755 0 0\n", f);
aa6aa81c	283
c75cf016	284	r = recurse_dir_at(AT_FDCWD, root, STATX_TYPE\|STATX_MODE, UINT_MAX, RECURSE_DIR_SORT, protofile_print_item, f);
aa6aa81c DDM	285	if (r < 0)
	286	return log_error_errno(r, "Failed to recurse through %s: %m", root);
	287
48ac1fd1	288	fputs("$\n", f);
aa6aa81c DDM	289
	290	r = fflush_and_check(f);
	291	if (r < 0)
	292	return log_error_errno(r, "Failed to flush %s: %m", p);
	293
	294	*ret = TAKE_PTR(p);
	295
	296	return 0;
	297	}
	298
c95f9a23 LP	299	int make_filesystem(
	300	const char *node,
	301	const char *fstype,
	302	const char *label,
7f55ad77	303	const char *root,
c95f9a23 LP	304	sd_id128_t uuid,
	305	bool discard) {
	306
dc91c971	307	_cleanup_free_ char mkfs = NULL, mangled_label = NULL;
ddf615a1	308	_cleanup_strv_free_ char **argv = NULL;
aa6aa81c	309	_cleanup_(unlink_and_freep) char *protofile = NULL;
b7416360	310	char vol_id[CONST_MAX(SD_ID128_UUID_STRING_MAX, 8U + 1U)] = {};
e59678b2	311	struct stat st;
c95f9a23 LP	312	int r;
	313
	314	assert(node);
	315	assert(fstype);
	316	assert(label);
	317
eb43379c DDM	318	if (fstype_is_ro(fstype) && !root)
	319	return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
	320	"Cannot generate read-only filesystem %s without a source tree.",
	321	fstype);
	322
c95f9a23	323	if (streq(fstype, "swap")) {
7f55ad77 DDM	324	if (root)
	325	return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
	326	"A swap filesystem can't be populated, refusing");
f7bc0c32	327	r = find_executable("mkswap", &mkfs);
c95f9a23 LP	328	if (r == -ENOENT)
	329	return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkswap binary not available.");
	330	if (r < 0)
	331	return log_error_errno(r, "Failed to determine whether mkswap binary exists: %m");
7f55ad77	332	} else if (streq(fstype, "squashfs")) {
7f55ad77 DDM	333	r = find_executable("mksquashfs", &mkfs);
	334	if (r == -ENOENT)
	335	return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mksquashfs binary not available.");
	336	if (r < 0)
	337	return log_error_errno(r, "Failed to determine whether mksquashfs binary exists: %m");
09e917ea LP	338
	339	} else if (streq(fstype, "erofs")) {
	340	r = find_executable("mkfs.erofs", &mkfs);
	341	if (r == -ENOENT)
	342	return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkfs.erofs binary not available.");
	343	if (r < 0)
	344	return log_error_errno(r, "Failed to determine whether mkfs.erofs binary exists: %m");
	345
eaec6994 DDM	346	} else if (fstype_is_ro(fstype)) {
	347	return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
	348	"Don't know how to create read-only file system '%s', refusing.",
	349	fstype);
c95f9a23	350	} else {
59e2be46	351	if (root && !mkfs_supports_root_option(fstype))
7f55ad77	352	return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
59e2be46	353	"Populating with source tree is not supported for %s", fstype);
c95f9a23 LP	354	r = mkfs_exists(fstype);
	355	if (r < 0)
	356	return log_error_errno(r, "Failed to determine whether mkfs binary for %s exists: %m", fstype);
	357	if (r == 0)
	358	return log_error_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "mkfs binary for %s is not available.", fstype);
	359
	360	mkfs = strjoin("mkfs.", fstype);
	361	if (!mkfs)
	362	return log_oom();
	363	}
	364
8d433a99 ZJS	365	if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "xfs", "swap")) {
	366	size_t max_len =
	367	streq(fstype, "xfs") ? 12 :
	368	streq(fstype, "swap") ? 15 :
	369	16;
	370
	371	r = mangle_linux_fs_label(label, max_len, &mangled_label);
7ffe593b	372	if (r < 0)
8d433a99	373	return log_error_errno(r, "Failed to determine volume label from string \"%s\": %m", label);
7ffe593b ZJS	374	label = mangled_label;
	375
	376	} else if (streq(fstype, "vfat")) {
dc91c971 ZJS	377	r = mangle_fat_label(label, &mangled_label);
	378	if (r < 0)
	379	return log_error_errno(r, "Failed to determine FAT label from string \"%s\": %m", label);
4f05a11c ZJS	380	label = mangled_label;
	381
	382	xsprintf(vol_id, "%08" PRIx32,
	383	((uint32_t) uuid.bytes[0] << 24) \|
	384	((uint32_t) uuid.bytes[1] << 16) \|
	385	((uint32_t) uuid.bytes[2] << 8) \|
	386	((uint32_t) uuid.bytes[3])); /* Take first 32 bytes of UUID */
	387	}
	388
	389	if (isempty(vol_id))
b7416360	390	assert_se(sd_id128_to_uuid_string(uuid, vol_id));
4f05a11c	391
ddf615a1	392	/* When changing this conditional, also adjust the log statement below. */
59e2be46	393	if (streq(fstype, "ext2")) {
ddf615a1 DDM	394	argv = strv_new(mkfs,
	395	"-q",
	396	"-L", label,
	397	"-U", vol_id,
	398	"-I", "256",
	399	"-m", "0",
	400	"-E", discard ? "discard,lazy_itable_init=1" : "nodiscard,lazy_itable_init=1",
	401	node);
59e2be46 DDM	402	if (!argv)
	403	return log_oom();
	404
	405	if (root) {
	406	r = strv_extend_strv(&argv, STRV_MAKE("-d", root), false);
	407	if (r < 0)
	408	return log_oom();
	409	}
ddf615a1	410
59e2be46	411	} else if (STR_IN_SET(fstype, "ext3", "ext4")) {
ddf615a1 DDM	412	argv = strv_new(mkfs,
	413	"-q",
	414	"-L", label,
	415	"-U", vol_id,
	416	"-I", "256",
	417	"-O", "has_journal",
	418	"-m", "0",
	419	"-E", discard ? "discard,lazy_itable_init=1" : "nodiscard,lazy_itable_init=1",
	420	node);
	421
59e2be46 DDM	422	if (root) {
	423	r = strv_extend_strv(&argv, STRV_MAKE("-d", root), false);
	424	if (r < 0)
	425	return log_oom();
	426	}
	427
	428	} else if (streq(fstype, "btrfs")) {
ddf615a1 DDM	429	argv = strv_new(mkfs,
	430	"-q",
	431	"-L", label,
	432	"-U", vol_id,
	433	node);
	434	if (!argv)
	435	return log_oom();
	436
	437	if (!discard) {
	438	r = strv_extend(&argv, "--nodiscard");
	439	if (r < 0)
	440	return log_oom();
	441	}
	442
59e2be46 DDM	443	if (root) {
	444	r = strv_extend_strv(&argv, STRV_MAKE("-r", root), false);
	445	if (r < 0)
	446	return log_oom();
	447	}
	448
ddf615a1 DDM	449	} else if (streq(fstype, "f2fs")) {
	450	argv = strv_new(mkfs,
	451	"-q",
	452	"-g", /* "default options" */
	453	"-f", /* force override, without this it doesn't seem to want to write to an empty partition */
	454	"-l", label,
	455	"-U", vol_id,
	456	"-t", one_zero(discard),
	457	node);
	458
	459	} else if (streq(fstype, "xfs")) {
	460	const char *j;
	461
	462	j = strjoina("uuid=", vol_id);
	463
	464	argv = strv_new(mkfs,
	465	"-q",
	466	"-L", label,
	467	"-m", j,
	468	"-m", "reflink=1",
	469	node);
	470	if (!argv)
	471	return log_oom();
	472
	473	if (!discard) {
	474	r = strv_extend(&argv, "-K");
	475	if (r < 0)
	476	return log_oom();
	477	}
	478
aa6aa81c DDM	479	if (root) {
	480	r = make_protofile(root, &protofile);
	481	if (r < 0)
	482	return r;
	483
	484	r = strv_extend_strv(&argv, STRV_MAKE("-p", protofile), false);
	485	if (r < 0)
	486	return log_oom();
	487	}
	488
ddf615a1 DDM	489	} else if (streq(fstype, "vfat"))
	490
	491	argv = strv_new(mkfs,
	492	"-i", vol_id,
	493	"-n", label,
	494	"-F", "32", /* yes, we force FAT32 here */
	495	node);
	496
	497	else if (streq(fstype, "swap"))
	498	/* TODO: add --quiet here if
	499	* https://github.com/util-linux/util-linux/issues/1499 resolved. */
	500
	501	argv = strv_new(mkfs,
	502	"-L", label,
	503	"-U", vol_id,
	504	node);
	505
	506	else if (streq(fstype, "squashfs"))
	507
	508	argv = strv_new(mkfs,
	509	root, node,
	510	"-quiet",
	511	"-noappend");
09e917ea LP	512
	513	else if (streq(fstype, "erofs"))
	514
	515	argv = strv_new(mkfs,
	516	"-U", vol_id,
	517	node, root);
ddf615a1 DDM	518	else
	519	/* Generic fallback for all other file systems */
	520	argv = strv_new(mkfs, node);
	521
	522	if (!argv)
	523	return log_oom();
	524
e59678b2 DDM	525	if (root && stat(root, &st) < 0)
	526	return log_error_errno(errno, "Failed to stat %s: %m", root);
	527
a9abef7f	528	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	529	if (r < 0)
	530	return r;
	531	if (r == 0) {
c95f9a23	532	/* Child */
4f05a11c	533
e59678b2 DDM	534	if (root) {
	535	r = setup_userns(st.st_uid, st.st_gid);
	536	if (r < 0)
	537	_exit(EXIT_FAILURE);
	538	}
	539
ddf615a1	540	execvp(mkfs, argv);
c95f9a23 LP	541
	542	log_error_errno(errno, "Failed to execute %s: %m", mkfs);
	543
	544	_exit(EXIT_FAILURE);
	545	}
	546
bf3598be DDM	547	if (root && streq(fstype, "vfat")) {
	548	r = do_mcopy(node, root);
	549	if (r < 0)
	550	return r;
	551	}
	552
2d96440f	553	if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "f2fs", "xfs", "vfat", "swap"))
4f05a11c ZJS	554	log_info("%s successfully formatted as %s (label \"%s\", uuid %s)",
4f05a11c ZJS	555	node, fstype, label, vol_id);
09e917ea LP	556	else if (streq(fstype, "erofs"))
	557	log_info("%s successfully formatted as %s (uuid %s, no label)",
	558	node, fstype, vol_id);
4f05a11c ZJS	559	else
	560	log_info("%s successfully formatted as %s (no label or uuid specified)",
	561	node, fstype);
	562
c95f9a23 LP	563	return 0;
c95f9a23 LP	564	}