src/shared/mkfs-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <unistd.h>
   4
   5 #include "dirent-util.h"
   6 #include "fd-util.h"
   7 #include "fileio.h"
   8 #include "fs-util.h"
   9 #include "id128-util.h"
  10 #include "mkfs-util.h"
  11 #include "mountpoint-util.h"
  12 #include "path-util.h"
  13 #include "process-util.h"
  14 #include "recurse-dir.h"
  15 #include "stat-util.h"
  16 #include "stdio-util.h"
  17 #include "string-util.h"
  18 #include "tmpfile-util.h"
  19 #include "utf8.h"
  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
  34         r = find_executable(mkfs, NULL);
  35         if (r == -ENOENT)
  36                 return false;
  37         if (r < 0)
  38                 return r;
  39
  40         return true;
  41 }
  42
  43 int mkfs_supports_root_option(const char *fstype) {
  44         return fstype_is_ro(fstype) || STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "vfat", "xfs");
  45 }
  46
  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
  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
 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,
 121                                 GID_FMT " " GID_FMT " " GID_FMT, 0u, gid, 1u);
 122         if (r < 0)
 123                 return log_error_errno(r,
 124                                        "Failed to write mapping for "GID_FMT" to /proc/self/gid_map: %m",
 125                                        gid);
 126
 127         return 0;
 128 }
 129
 130 static int do_mcopy(const char *node, const char *root) {
 131         _cleanup_free_ char *mcopy = NULL;
 132         _cleanup_strv_free_ char **argv = NULL;
 133         _cleanup_close_ int rfd = -1;
 134         _cleanup_free_ DirectoryEntries *de = NULL;
 135         struct stat st;
 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
 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);
 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
 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);
 161
 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);
 168                 if (!p)
 169                         return log_oom();
 170
 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
 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
 185         if (fstat(rfd, &st) < 0)
 186                 return log_error_errno(errno, "Failed to stat '%s': %m", root);
 187
 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);
 189         if (r < 0)
 190                 return r;
 191         if (r == 0) {
 192                 r = setup_userns(st.st_uid, st.st_gid);
 193                 if (r < 0)
 194                         _exit(EXIT_FAILURE);
 195
 196                 /* Avoid failures caused by mismatch in expectations between mkfs.vfat and mcopy by disabling
 197                  * the stricter mcopy checks using MTOOLS_SKIP_CHECK. */
 198                 execve(mcopy, argv, STRV_MAKE("MTOOLS_SKIP_CHECK=1"));
 199
 200                 log_error_errno(errno, "Failed to execute mcopy: %m");
 201
 202                 _exit(EXIT_FAILURE);
 203         }
 204
 205         return 0;
 206 }
 207
 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);
 218         int r;
 219
 220         if (event == RECURSE_DIR_LEAVE) {
 221                 fputs("$\n", f);
 222                 return 0;
 223         }
 224
 225         if (!IN_SET(event, RECURSE_DIR_ENTER, RECURSE_DIR_ENTRY))
 226                 return RECURSE_DIR_CONTINUE;
 227
 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 ",
 238                 de->d_name,
 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))
 245                 fputs(path, f);
 246         else if (S_ISLNK(sx->stx_mode)) {
 247                 _cleanup_free_ char *p = NULL;
 248
 249                 r = readlinkat_malloc(dir_fd, de->d_name, &p);
 250                 if (r < 0)
 251                         return log_error_errno(r, "Failed to read symlink %s: %m", path);
 252
 253                 fputs(p, f);
 254         } else if (S_ISBLK(sx->stx_mode) || S_ISCHR(sx->stx_mode))
 255                 fprintf(f, "%" PRIu32 " %" PRIu32, sx->stx_rdev_major, sx->stx_rdev_minor);
 256
 257         fputc('\n', f);
 258
 259         return RECURSE_DIR_CONTINUE;
 260 }
 261
 262 static int make_protofile(const char *root, char **ret) {
 263         _cleanup_fclose_ FILE *f = NULL;
 264         _cleanup_(unlink_and_freep) char *p = NULL;
 265         const char *vt;
 266         int r;
 267
 268         assert(ret);
 269
 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);
 275         if (r < 0)
 276                 return log_error_errno(r, "Failed to open temporary file: %m");
 277
 278         fputs("/\n"
 279               "0 0\n"
 280               "d--755 0 0\n", f);
 281
 282         r = recurse_dir_at(AT_FDCWD, root, STATX_TYPE|STATX_MODE, UINT_MAX, RECURSE_DIR_SORT, protofile_print_item, f);
 283         if (r < 0)
 284                 return log_error_errno(r, "Failed to recurse through %s: %m", root);
 285
 286         fputs("$\n", f);
 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
 297 int make_filesystem(
 298                 const char *node,
 299                 const char *fstype,
 300                 const char *label,
 301                 const char *root,
 302                 sd_id128_t uuid,
 303                 bool discard) {
 304
 305         _cleanup_free_ char *mkfs = NULL, *mangled_label = NULL;
 306         _cleanup_strv_free_ char **argv = NULL;
 307         _cleanup_(unlink_and_freep) char *protofile = NULL;
 308         char vol_id[CONST_MAX(SD_ID128_UUID_STRING_MAX, 8U + 1U)] = {};
 309         struct stat st;
 310         int r;
 311
 312         assert(node);
 313         assert(fstype);
 314         assert(label);
 315
 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
 321         if (streq(fstype, "swap")) {
 322                 if (root)
 323                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 324                                                "A swap filesystem can't be populated, refusing");
 325                 r = find_executable("mkswap", &mkfs);
 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");
 330         } else if (streq(fstype, "squashfs")) {
 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");
 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);
 340         } else {
 341                 if (root && !mkfs_supports_root_option(fstype))
 342                         return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
 343                                                "Populating with source tree is not supported for %s", fstype);
 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
 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);
 362                 if (r < 0)
 363                         return log_error_errno(r, "Failed to determine volume label from string \"%s\": %m", label);
 364                 label = mangled_label;
 365
 366         } else if (streq(fstype, "vfat")) {
 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);
 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))
 380                 assert_se(sd_id128_to_uuid_string(uuid, vol_id));
 381
 382         /* When changing this conditional, also adjust the log statement below. */
 383         if (streq(fstype, "ext2")) {
 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);
 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                 }
 400
 401         } else if (STR_IN_SET(fstype, "ext3", "ext4")) {
 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
 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")) {
 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
 433                 if (root) {
 434                         r = strv_extend_strv(&argv, STRV_MAKE("-r", root), false);
 435                         if (r < 0)
 436                                 return log_oom();
 437                 }
 438
 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
 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
 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
 509         if (root && stat(root, &st) < 0)
 510                 return log_error_errno(errno, "Failed to stat %s: %m", root);
 511
 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);
 513         if (r < 0)
 514                 return r;
 515         if (r == 0) {
 516                 /* Child */
 517
 518                 if (root) {
 519                         r = setup_userns(st.st_uid, st.st_gid);
 520                         if (r < 0)
 521                                 _exit(EXIT_FAILURE);
 522                 }
 523
 524                 execvp(mkfs, argv);
 525
 526                 log_error_errno(errno, "Failed to execute %s: %m", mkfs);
 527
 528                 _exit(EXIT_FAILURE);
 529         }
 530
 531         if (root && streq(fstype, "vfat")) {
 532                 r = do_mcopy(node, root);
 533                 if (r < 0)
 534                         return r;
 535         }
 536
 537         if (STR_IN_SET(fstype, "ext2", "ext3", "ext4", "btrfs", "f2fs", "xfs", "vfat", "swap"))
 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
 544         return 0;
 545 }