util-linux/mkfs_ext2.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * mkfs_ext2: utility to create EXT2 filesystem
   4  * inspired by genext2fs
   5  *
   6  * Busybox'ed (2009) by Vladimir Dronnikov <dronnikov@gmail.com>
   7  *
   8  * Licensed under GPLv2, see file LICENSE in this source tree.
   9  */
  10 //config:config MKE2FS
  11 //config:       bool "mke2fs (10 kb)"
  12 //config:       default y
  13 //config:       select PLATFORM_LINUX
  14 //config:       help
  15 //config:       Utility to create EXT2 filesystems.
  16 //config:
  17 //config:config MKFS_EXT2
  18 //config:       bool "mkfs.ext2 (10 kb)"
  19 //config:       default y
  20 //config:       select PLATFORM_LINUX
  21 //config:       help
  22 //config:       Alias to "mke2fs".
  23
  24 //                    APPLET_ODDNAME:name       main       location     suid_type     help
  25 //applet:IF_MKE2FS(   APPLET_ODDNAME(mke2fs,    mkfs_ext2, BB_DIR_SBIN, BB_SUID_DROP, mkfs_ext2))
  26 //applet:IF_MKFS_EXT2(APPLET_ODDNAME(mkfs.ext2, mkfs_ext2, BB_DIR_SBIN, BB_SUID_DROP, mkfs_ext2))
  27 ////////:IF_MKFS_EXT3(APPLET_ODDNAME(mkfs.ext3, mkfs_ext2, BB_DIR_SBIN, BB_SUID_DROP, mkfs_ext2))
  28
  29 //kbuild:lib-$(CONFIG_MKE2FS) += mkfs_ext2.o
  30 //kbuild:lib-$(CONFIG_MKFS_EXT2) += mkfs_ext2.o
  31
  32 //usage:#define mkfs_ext2_trivial_usage
  33 //usage:       "[-Fn] "
  34 /* //usage:    "[-c|-l filename] " */
  35 //usage:       "[-b BLK_SIZE] "
  36 /* //usage:    "[-f fragment-size] [-g blocks-per-group] " */
  37 //usage:       "[-i INODE_RATIO] [-I INODE_SIZE] "
  38 /* //usage:    "[-j] [-J journal-options] [-N number-of-inodes] " */
  39 //usage:       "[-m RESERVED_PERCENT] "
  40 /* //usage:    "[-o creator-os] [-O feature[,...]] [-q] " */
  41 /* //usage:    "[r fs-revision-level] [-E extended-options] [-v] [-F] " */
  42 //usage:       "[-L LABEL] "
  43 /* //usage:    "[-M last-mounted-directory] [-S] [-T filesystem-type] " */
  44 //usage:       "BLOCKDEV [KBYTES]"
  45 //usage:#define mkfs_ext2_full_usage "\n\n"
  46 //usage:       "        -b BLK_SIZE     Block size, bytes"
  47 /* //usage:  "\n        -c              Check device for bad blocks" */
  48 /* //usage:  "\n        -E opts         Set extended options" */
  49 /* //usage:  "\n        -f size         Fragment size in bytes" */
  50 //usage:     "\n        -F              Force"
  51 /* //usage:  "\n        -g N            Number of blocks in a block group" */
  52 //usage:     "\n        -i RATIO        Max number of files is filesystem_size / RATIO"
  53 //usage:     "\n        -I BYTES        Inode size (min 128)"
  54 /* //usage:  "\n        -j              Create a journal (ext3)" */
  55 /* //usage:  "\n        -J opts         Set journal options (size/device)" */
  56 /* //usage:  "\n        -l file         Read bad blocks list from file" */
  57 //usage:     "\n        -L LBL          Volume label"
  58 //usage:     "\n        -m PERCENT      Percent of blocks to reserve for admin"
  59 /* //usage:  "\n        -M dir          Set last mounted directory" */
  60 //usage:     "\n        -n              Dry run"
  61 /* //usage:  "\n        -N N            Number of inodes to create" */
  62 /* //usage:  "\n        -o os           Set the 'creator os' field" */
  63 /* //usage:  "\n        -O features     Dir_index/filetype/has_journal/journal_dev/sparse_super" */
  64 /* //usage:  "\n        -q              Quiet" */
  65 /* //usage:  "\n        -r rev          Set filesystem revision" */
  66 /* //usage:  "\n        -S              Write superblock and group descriptors only" */
  67 /* //usage:  "\n        -T fs-type      Set usage type (news/largefile/largefile4)" */
  68 /* //usage:  "\n        -v              Verbose" */
  69
  70 #include "libbb.h"
  71 #include <linux/fs.h>
  72 #include "bb_e2fs_defs.h"
  73
  74 #define ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT 0
  75 #define ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX    1
  76
  77 #define EXT2_HASH_HALF_MD4       1
  78 #define EXT2_FLAGS_SIGNED_HASH   0x0001
  79 #define EXT2_FLAGS_UNSIGNED_HASH 0x0002
  80
  81 // All fields are little-endian
  82 struct ext2_dir {
  83         uint32_t inode1;
  84         uint16_t rec_len1;
  85         uint8_t  name_len1;
  86         uint8_t  file_type1;
  87         char     name1[4];
  88         uint32_t inode2;
  89         uint16_t rec_len2;
  90         uint8_t  name_len2;
  91         uint8_t  file_type2;
  92         char     name2[4];
  93         uint32_t inode3;
  94         uint16_t rec_len3;
  95         uint8_t  name_len3;
  96         uint8_t  file_type3;
  97         char     name3[12];
  98 };
  99
 100 static unsigned int_log2(unsigned arg)
 101 {
 102         unsigned r = 0;
 103         while ((arg >>= 1) != 0)
 104                 r++;
 105         return r;
 106 }
 107
 108 // taken from mkfs_minix.c. libbb candidate?
 109 // "uint32_t size", since we never use it for anything >32 bits
 110 static uint32_t div_roundup(uint32_t size, uint32_t n)
 111 {
 112         // Overflow-resistant
 113         uint32_t res = size / n;
 114         if (res * n != size)
 115                 res++;
 116         return res;
 117 }
 118
 119 static void allocate(uint8_t *bitmap, uint32_t blocksize, uint32_t start, uint32_t end)
 120 {
 121         uint32_t i;
 122
 123 //bb_error_msg("ALLOC: [%u][%u][%u]: [%u-%u]:=[%x],[%x]", blocksize, start, end, start/8, blocksize - end/8 - 1, (1 << (start & 7)) - 1, (uint8_t)(0xFF00 >> (end & 7)));
 124         memset(bitmap, 0, blocksize);
 125         i = start / 8;
 126         memset(bitmap, 0xFF, i);
 127         bitmap[i] = (1 << (start & 7)) - 1; //0..7 => 00000000..01111111
 128         i = end / 8;
 129         bitmap[blocksize - i - 1] |= 0x7F00 >> (end & 7); //0..7 => 00000000..11111110
 130         memset(bitmap + blocksize - i, 0xFF, i); // N.B. no overflow here!
 131 }
 132
 133 static uint32_t has_super(uint32_t x)
 134 {
 135         // 0, 1 and powers of 3, 5, 7 up to 2^32 limit
 136         static const uint32_t supers[] = {
 137                 0, 1, 3, 5, 7, 9, 25, 27, 49, 81, 125, 243, 343, 625, 729,
 138                 2187, 2401, 3125, 6561, 15625, 16807, 19683, 59049, 78125,
 139                 117649, 177147, 390625, 531441, 823543, 1594323, 1953125,
 140                 4782969, 5764801, 9765625, 14348907, 40353607, 43046721,
 141                 48828125, 129140163, 244140625, 282475249, 387420489,
 142                 1162261467, 1220703125, 1977326743, 3486784401/* >2^31 */,
 143         };
 144         const uint32_t *sp = supers + ARRAY_SIZE(supers);
 145         while (1) {
 146                 sp--;
 147                 if (x == *sp)
 148                         return 1;
 149                 if (x > *sp)
 150                         return 0;
 151         }
 152 }
 153
 154 #define fd 3    /* predefined output descriptor */
 155
 156 static void PUT(uint64_t off, void *buf, uint32_t size)
 157 {
 158         //bb_error_msg("PUT[%llu]:[%u]", off, size);
 159         xlseek(fd, off, SEEK_SET);
 160         xwrite(fd, buf, size);
 161 }
 162
 163 // 128 and 256-byte inodes:
 164 // 128-byte inode is described by struct ext2_inode.
 165 // 256-byte one just has these fields appended:
 166 //      __u16   i_extra_isize;
 167 //      __u16   i_pad1;
 168 //      __u32   i_ctime_extra;  /* extra Change time (nsec << 2 | epoch) */
 169 //      __u32   i_mtime_extra;  /* extra Modification time (nsec << 2 | epoch) */
 170 //      __u32   i_atime_extra;  /* extra Access time (nsec << 2 | epoch) */
 171 //      __u32   i_crtime;       /* File creation time */
 172 //      __u32   i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/
 173 //      __u32   i_version_hi;   /* high 32 bits for 64-bit version */
 174 // the rest is padding.
 175 //
 176 // linux/ext2_fs.h has "#define i_size_high i_dir_acl" which suggests that even
 177 // 128-byte inode is capable of describing large files (i_dir_acl is meaningful
 178 // only for directories, which never need i_size_high).
 179 //
 180 // Standard mke2fs creates a filesystem with 256-byte inodes if it is
 181 // bigger than 0.5GB.
 182
 183 // Standard mke2fs 1.41.9:
 184 // Usage: mke2fs [-c|-l filename] [-b block-size] [-f fragment-size]
 185 //      [-i bytes-per-inode] [-I inode-size] [-J journal-options]
 186 //      [-G meta group size] [-N number-of-inodes]
 187 //      [-m reserved-blocks-percentage] [-o creator-os]
 188 //      [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
 189 //      [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
 190 //      [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
 191 //
 192 // Options not commented below are taken but silently ignored:
 193 enum {
 194         OPT_c = 1 << 0,
 195         OPT_l = 1 << 1,
 196         OPT_b = 1 << 2,         // block size, in bytes
 197         OPT_f = 1 << 3,
 198         OPT_i = 1 << 4,         // bytes per inode
 199         OPT_I = 1 << 5,         // custom inode size, in bytes
 200         OPT_J = 1 << 6,
 201         OPT_G = 1 << 7,
 202         OPT_N = 1 << 8,
 203         OPT_m = 1 << 9,         // percentage of blocks reserved for superuser
 204         OPT_o = 1 << 10,
 205         OPT_g = 1 << 11,
 206         OPT_L = 1 << 12,        // label
 207         OPT_M = 1 << 13,
 208         OPT_O = 1 << 14,
 209         OPT_r = 1 << 15,
 210         OPT_E = 1 << 16,
 211         OPT_T = 1 << 17,
 212         OPT_U = 1 << 18,
 213         OPT_j = 1 << 19,
 214         OPT_n = 1 << 20,        // dry run: do not write anything
 215         OPT_q = 1 << 21,
 216         OPT_v = 1 << 22,
 217         OPT_F = 1 << 23,
 218         OPT_S = 1 << 24,
 219         //OPT_V = 1 << 25,      // -V version. bbox applets don't support that
 220 };
 221
 222 int mkfs_ext2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 223 int mkfs_ext2_main(int argc UNUSED_PARAM, char **argv)
 224 {
 225         unsigned i, pos, n;
 226         unsigned bs, bpi;
 227         unsigned blocksize, blocksize_log2;
 228         unsigned inodesize, user_inodesize;
 229         unsigned reserved_percent = 5;
 230         unsigned long long kilobytes;
 231         uint32_t nblocks, nblocks_full;
 232         uint32_t nreserved;
 233         uint32_t ngroups;
 234         uint32_t bytes_per_inode;
 235         uint32_t first_block;
 236         uint32_t inodes_per_group;
 237         uint32_t group_desc_blocks;
 238         uint32_t inode_table_blocks;
 239         uint32_t lost_and_found_blocks;
 240         time_t timestamp;
 241         const char *label = "";
 242         struct stat st;
 243         struct ext2_super_block *sb; // superblock
 244         struct ext2_group_desc *gd; // group descriptors
 245         struct ext2_inode *inode;
 246         struct ext2_dir *dir;
 247         uint8_t *buf;
 248
 249         // using global "option_mask32" instead of local "opts":
 250         // we are register starved here
 251         /*opts =*/ getopt32(argv, "cl:b:+f:i:+I:+J:G:N:m:+o:g:L:M:O:r:E:T:U:jnqvFS",
 252                 /*lbfi:*/ NULL, &bs, NULL, &bpi,
 253                 /*IJGN:*/ &user_inodesize, NULL, NULL, NULL,
 254                 /*mogL:*/ &reserved_percent, NULL, NULL, &label,
 255                 /*MOrE:*/ NULL, NULL, NULL, NULL,
 256                 /*TU:*/ NULL, NULL);
 257         argv += optind; // argv[0] -- device
 258
 259         // open the device, check the device is a block device
 260         xmove_fd(xopen(argv[0], O_WRONLY), fd);
 261         xfstat(fd, &st, argv[0]);
 262         if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_F))
 263                 bb_error_msg_and_die("%s: not a block device", argv[0]);
 264
 265         // check if it is mounted
 266         // N.B. what if we format a file? find_mount_point will return false negative since
 267         // it is loop block device which is mounted!
 268         if (find_mount_point(argv[0], 0))
 269                 bb_error_msg_and_die("can't format mounted filesystem");
 270
 271         // get size in kbytes
 272         kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
 273
 274         bytes_per_inode = 16384;
 275         if (kilobytes < 512*1024)
 276                 bytes_per_inode = 4096;
 277         if (kilobytes < 3*1024)
 278                 bytes_per_inode = 8192;
 279         if (option_mask32 & OPT_i)
 280                 bytes_per_inode = bpi;
 281
 282         // Determine block size and inode size
 283         // block size is a multiple of 1024
 284         // inode size is a multiple of 128
 285         blocksize = 1024;
 286         inodesize = sizeof(struct ext2_inode); // 128
 287         if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
 288                 blocksize = 4096;
 289                 inodesize = 256;
 290         }
 291         if (EXT2_MAX_BLOCK_SIZE > 4096) {
 292                 // kilobytes >> 22 == size in 4gigabyte chunks.
 293                 // if size >= 16k gigs, blocksize must be increased.
 294                 // Try "mke2fs -F image $((16 * 1024*1024*1024))"
 295                 while ((kilobytes >> 22) >= blocksize)
 296                         blocksize *= 2;
 297         }
 298         if (option_mask32 & OPT_b)
 299                 blocksize = bs;
 300         if (blocksize < EXT2_MIN_BLOCK_SIZE
 301          || blocksize > EXT2_MAX_BLOCK_SIZE
 302          || (blocksize & (blocksize - 1)) // not power of 2
 303         ) {
 304                 bb_error_msg_and_die("blocksize %u is bad", blocksize);
 305         }
 306         // Do we have custom inode size?
 307         if (option_mask32 & OPT_I) {
 308                 if (user_inodesize < sizeof(*inode)
 309                  || user_inodesize > blocksize
 310                  || (user_inodesize & (user_inodesize - 1)) // not power of 2
 311                 ) {
 312                         bb_error_msg("-%c is bad", 'I');
 313                 } else {
 314                         inodesize = user_inodesize;
 315                 }
 316         }
 317
 318         if ((int32_t)bytes_per_inode < blocksize)
 319                 bb_error_msg_and_die("-%c is bad", 'i');
 320         // number of bits in one block, i.e. 8*blocksize
 321 #define blocks_per_group (8 * blocksize)
 322         first_block = (EXT2_MIN_BLOCK_SIZE == blocksize);
 323         blocksize_log2 = int_log2(blocksize);
 324
 325         // Determine number of blocks
 326         kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
 327         nblocks = kilobytes;
 328         if (nblocks != kilobytes)
 329                 bb_error_msg_and_die("block count doesn't fit in 32 bits");
 330 #define kilobytes kilobytes_unused_after_this
 331         // Experimentally, standard mke2fs won't work on images smaller than 60k
 332         if (nblocks < 60)
 333                 bb_error_msg_and_die("need >= 60 blocks");
 334
 335         // How many reserved blocks?
 336         if (reserved_percent > 50)
 337                 bb_error_msg_and_die("-%c is bad", 'm');
 338         nreserved = (uint64_t)nblocks * reserved_percent / 100;
 339
 340         // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
 341         nblocks_full = nblocks;
 342
 343         // If last block group is too small, nblocks may be decreased in order
 344         // to discard it, and control returns here to recalculate some
 345         // parameters.
 346         // Note: blocksize and bytes_per_inode are never recalculated.
 347  retry:
 348         // N.B. a block group can have no more than blocks_per_group blocks
 349         ngroups = div_roundup(nblocks - first_block, blocks_per_group);
 350
 351         group_desc_blocks = div_roundup(ngroups, blocksize / sizeof(*gd));
 352         // TODO: reserved blocks must be marked as such in the bitmaps,
 353         // or resulting filesystem is corrupt
 354         if (ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT) {
 355                 /*
 356                  * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
 357                  * filesystem growth.
 358                  * The absolute maximum number of GDT blocks we can reserve is determined by
 359                  * the number of block pointers that can fit into a single block.
 360                  * We set it at 1024x the current filesystem size, or
 361                  * the upper block count limit (2^32), whichever is lower.
 362                  */
 363                 uint32_t reserved_group_desc_blocks = 0xFFFFFFFF; // maximum block number
 364                 if (nblocks < reserved_group_desc_blocks / 1024)
 365                         reserved_group_desc_blocks = nblocks * 1024;
 366                 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks - first_block, blocks_per_group);
 367                 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks, blocksize / sizeof(*gd)) - group_desc_blocks;
 368                 if (reserved_group_desc_blocks > blocksize / sizeof(uint32_t))
 369                         reserved_group_desc_blocks = blocksize / sizeof(uint32_t);
 370                 //TODO: STORE_LE(sb->s_reserved_gdt_blocks, reserved_group_desc_blocks);
 371                 group_desc_blocks += reserved_group_desc_blocks;
 372         }
 373
 374         {
 375                 // N.B. e2fsprogs does as follows!
 376                 uint32_t overhead, remainder;
 377                 // ninodes is the max number of inodes in this filesystem
 378                 uint32_t ninodes = ((uint64_t) nblocks_full * blocksize) / bytes_per_inode;
 379                 if (ninodes < EXT2_GOOD_OLD_FIRST_INO+1)
 380                         ninodes = EXT2_GOOD_OLD_FIRST_INO+1;
 381                 inodes_per_group = div_roundup(ninodes, ngroups);
 382                 // minimum number because the first EXT2_GOOD_OLD_FIRST_INO-1 are reserved
 383                 if (inodes_per_group < 16)
 384                         inodes_per_group = 16;
 385                 // a block group can't have more inodes than blocks
 386                 if (inodes_per_group > blocks_per_group)
 387                         inodes_per_group = blocks_per_group;
 388                 // adjust inodes per group so they completely fill the inode table blocks in the descriptor
 389                 inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
 390                 // make sure the number of inodes per group is a multiple of 8
 391                 inodes_per_group &= ~7;
 392                 inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
 393
 394                 // to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
 395                 // and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
 396                 /* Or e2fsprogs comment verbatim (what does it mean?):
 397                  * Ensure that lost+found is at least 2 blocks, so we always
 398                  * test large empty blocks for big-block filesystems. */
 399                 lost_and_found_blocks = MIN(EXT2_NDIR_BLOCKS, 16 >> (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE));
 400
 401                 // the last group needs more attention: isn't it too small for possible overhead?
 402                 overhead = (has_super(ngroups - 1) ? (1/*sb*/ + group_desc_blocks) : 0) + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
 403                 remainder = (nblocks - first_block) % blocks_per_group;
 404                 ////can't happen, nblocks >= 60 guarantees this
 405                 ////if ((1 == ngroups)
 406                 //// && remainder
 407                 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
 408                 ////) {
 409                 ////    bb_error_msg_and_die("way small device");
 410                 ////}
 411
 412                 // Standard mke2fs uses 50. Looks like a bug in our calculation
 413                 // of "remainder" or "overhead" - we don't match standard mke2fs
 414                 // when we transition from one group to two groups
 415                 // (a bit after 8M image size), but it works for two->three groups
 416                 // transition (at 16M).
 417                 if (remainder && (remainder < overhead + 50)) {
 418 //bb_error_msg("CHOP[%u]", remainder);
 419                         nblocks -= remainder;
 420                         goto retry;
 421                 }
 422         }
 423
 424         if (nblocks_full - nblocks)
 425                 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
 426         printf(
 427                 "Filesystem label=%s\n"
 428                 "OS type: Linux\n"
 429                 "Block size=%u (log=%u)\n"
 430                 "Fragment size=%u (log=%u)\n"
 431                 "%u inodes, %u blocks\n"
 432                 "%u blocks (%u%%) reserved for the super user\n"
 433                 "First data block=%u\n"
 434                 "Maximum filesystem blocks=%u\n"
 435                 "%u block groups\n"
 436                 "%u blocks per group, %u fragments per group\n"
 437                 "%u inodes per group"
 438                 , label
 439                 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
 440                 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
 441                 , inodes_per_group * ngroups, nblocks
 442                 , nreserved, reserved_percent
 443                 , first_block
 444                 , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
 445                 , ngroups
 446                 , blocks_per_group, blocks_per_group
 447                 , inodes_per_group
 448         );
 449         {
 450                 const char *fmt = "\nSuperblock backups stored on blocks:\n"
 451                         "\t%u";
 452                 pos = first_block;
 453                 for (i = 1; i < ngroups; i++) {
 454                         pos += blocks_per_group;
 455                         if (has_super(i)) {
 456                                 printf(fmt, (unsigned)pos);
 457                                 fmt = ", %u";
 458                         }
 459                 }
 460         }
 461         bb_putchar('\n');
 462
 463         if (option_mask32 & OPT_n) {
 464                 if (ENABLE_FEATURE_CLEAN_UP)
 465                         close(fd);
 466                 return EXIT_SUCCESS;
 467         }
 468
 469         // TODO: 3/5 refuse if mounted
 470         // TODO: 4/5 compat options
 471         // TODO: 1/5 sanity checks
 472         // TODO: 0/5 more verbose error messages
 473         // TODO: 4/5 bigendianness: recheck, wait for ARM reporters
 474         // TODO: 2/5 reserved GDT: how to mark but not allocate?
 475         // TODO: 3/5 dir_index?
 476
 477         // fill the superblock
 478         sb = xzalloc(1024);
 479         STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
 480         STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
 481         STORE_LE(sb->s_inode_size, inodesize);
 482         // set "Required extra isize" and "Desired extra isize" fields to 28
 483         if (inodesize != sizeof(*inode)) {
 484                 STORE_LE(sb->s_min_extra_isize, 0x001c);
 485                 STORE_LE(sb->s_want_extra_isize, 0x001c);
 486         }
 487         STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
 488         STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
 489         STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
 490         // first 1024 bytes of the device are for boot record. If block size is 1024 bytes, then
 491         // the first block is 1, otherwise 0
 492         STORE_LE(sb->s_first_data_block, first_block);
 493         // block and inode bitmaps occupy no more than one block, so maximum number of blocks is
 494         STORE_LE(sb->s_blocks_per_group, blocks_per_group);
 495         STORE_LE(sb->s_frags_per_group, blocks_per_group);
 496         // blocks
 497         STORE_LE(sb->s_blocks_count, nblocks);
 498         // reserve blocks for superuser
 499         STORE_LE(sb->s_r_blocks_count, nreserved);
 500         // ninodes
 501         STORE_LE(sb->s_inodes_per_group, inodes_per_group);
 502         STORE_LE(sb->s_inodes_count, inodes_per_group * ngroups);
 503         STORE_LE(sb->s_free_inodes_count, inodes_per_group * ngroups - EXT2_GOOD_OLD_FIRST_INO);
 504         // timestamps
 505         timestamp = time(NULL);
 506         STORE_LE(sb->s_mkfs_time, timestamp);
 507         STORE_LE(sb->s_wtime, timestamp);
 508         STORE_LE(sb->s_lastcheck, timestamp);
 509         // misc. Values are chosen to match mke2fs 1.41.9
 510         STORE_LE(sb->s_state, 1); // TODO: what's 1?
 511         STORE_LE(sb->s_creator_os, EXT2_OS_LINUX);
 512         STORE_LE(sb->s_checkinterval, 24*60*60 * 180); // 180 days
 513         STORE_LE(sb->s_errors, EXT2_ERRORS_DEFAULT);
 514         // mke2fs 1.41.9 also sets EXT3_FEATURE_COMPAT_RESIZE_INODE
 515         // and if >= 0.5GB, EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
 516         // we use values which match "mke2fs -O ^resize_inode":
 517         // in this case 1.41.9 never sets EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
 518         STORE_LE(sb->s_feature_compat, EXT2_FEATURE_COMPAT_SUPP
 519                 | (EXT2_FEATURE_COMPAT_RESIZE_INO * ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT)
 520                 | (EXT2_FEATURE_COMPAT_DIR_INDEX * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX)
 521         );
 522         STORE_LE(sb->s_feature_incompat, EXT2_FEATURE_INCOMPAT_FILETYPE);
 523         STORE_LE(sb->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
 524         STORE_LE(sb->s_flags, EXT2_FLAGS_UNSIGNED_HASH * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX);
 525         generate_uuid(sb->s_uuid);
 526         if (ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX) {
 527                 STORE_LE(sb->s_def_hash_version, EXT2_HASH_HALF_MD4);
 528                 generate_uuid((uint8_t *)sb->s_hash_seed);
 529         }
 530         /*
 531          * From e2fsprogs: add "jitter" to the superblock's check interval so that we
 532          * don't check all the filesystems at the same time.  We use a
 533          * kludgy hack of using the UUID to derive a random jitter value.
 534          */
 535         STORE_LE(sb->s_max_mnt_count,
 536                 EXT2_DFL_MAX_MNT_COUNT
 537                 + (sb->s_uuid[ARRAY_SIZE(sb->s_uuid)-1] % EXT2_DFL_MAX_MNT_COUNT));
 538
 539         // write the label
 540         safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
 541
 542         // calculate filesystem skeleton structures
 543         gd = xzalloc(group_desc_blocks * blocksize);
 544         buf = xmalloc(blocksize);
 545         sb->s_free_blocks_count = 0;
 546         for (i = 0, pos = first_block, n = nblocks - first_block;
 547                 i < ngroups;
 548                 i++, pos += blocks_per_group, n -= blocks_per_group
 549         ) {
 550                 uint32_t overhead = pos + (has_super(i) ? (1/*sb*/ + group_desc_blocks) : 0);
 551                 uint32_t free_blocks;
 552                 // fill group descriptors
 553                 STORE_LE(gd[i].bg_block_bitmap, overhead + 0);
 554                 STORE_LE(gd[i].bg_inode_bitmap, overhead + 1);
 555                 STORE_LE(gd[i].bg_inode_table, overhead + 2);
 556                 overhead = overhead - pos + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
 557                 gd[i].bg_free_inodes_count = inodes_per_group;
 558                 //STORE_LE(gd[i].bg_used_dirs_count, 0);
 559                 // N.B. both "/" and "/lost+found" are within the first block group
 560                 // "/" occupies 1 block, "/lost+found" occupies lost_and_found_blocks...
 561                 if (0 == i) {
 562                         // ... thus increased overhead for the first block group ...
 563                         overhead += 1 + lost_and_found_blocks;
 564                         // ... and 2 used directories
 565                         STORE_LE(gd[i].bg_used_dirs_count, 2);
 566                         // well known reserved inodes belong to the first block too
 567                         gd[i].bg_free_inodes_count -= EXT2_GOOD_OLD_FIRST_INO;
 568                 }
 569
 570                 // cache free block count of the group
 571                 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
 572
 573                 // mark preallocated blocks as allocated
 574 //bb_error_msg("ALLOC: [%u][%u][%u]", blocksize, overhead, blocks_per_group - (free_blocks + overhead));
 575                 allocate(buf, blocksize,
 576                         // reserve "overhead" blocks
 577                         overhead,
 578                         // mark unused trailing blocks
 579                         blocks_per_group - (free_blocks + overhead)
 580                 );
 581                 // dump block bitmap
 582                 PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
 583                 STORE_LE(gd[i].bg_free_blocks_count, free_blocks);
 584
 585                 // mark preallocated inodes as allocated
 586                 allocate(buf, blocksize,
 587                         // mark reserved inodes
 588                         inodes_per_group - gd[i].bg_free_inodes_count,
 589                         // mark unused trailing inodes
 590                         blocks_per_group - inodes_per_group
 591                 );
 592                 // dump inode bitmap
 593                 //PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
 594                 //but it's right after block bitmap, so we can just:
 595                 xwrite(fd, buf, blocksize);
 596                 STORE_LE(gd[i].bg_free_inodes_count, gd[i].bg_free_inodes_count);
 597
 598                 // count overall free blocks
 599                 sb->s_free_blocks_count += free_blocks;
 600         }
 601         STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
 602
 603         // dump filesystem skeleton structures
 604 //      printf("Writing superblocks and filesystem accounting information: ");
 605         for (i = 0, pos = first_block; i < ngroups; i++, pos += blocks_per_group) {
 606                 // dump superblock and group descriptors and their backups
 607                 if (has_super(i)) {
 608                         // N.B. 1024 byte blocks are special
 609                         PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
 610                                         sb, 1024);
 611                         PUT(((uint64_t)pos * blocksize) + blocksize,
 612                                         gd, group_desc_blocks * blocksize);
 613                 }
 614         }
 615
 616         // zero boot sectors
 617         memset(buf, 0, blocksize);
 618         // Disabled: standard mke2fs doesn't do this, and
 619         // on SPARC this destroys Sun disklabel.
 620         // Users who need/want zeroing can easily do it with dd.
 621         //PUT(0, buf, 1024); // N.B. 1024 <= blocksize, so buf[0..1023] contains zeros
 622
 623         // zero inode tables
 624         for (i = 0; i < ngroups; ++i)
 625                 for (n = 0; n < inode_table_blocks; ++n)
 626                         PUT((uint64_t)(FETCH_LE32(gd[i].bg_inode_table) + n) * blocksize,
 627                                 buf, blocksize);
 628
 629         // prepare directory inode
 630         inode = (struct ext2_inode *)buf;
 631         STORE_LE(inode->i_mode, S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
 632         STORE_LE(inode->i_mtime, timestamp);
 633         STORE_LE(inode->i_atime, timestamp);
 634         STORE_LE(inode->i_ctime, timestamp);
 635         STORE_LE(inode->i_size, blocksize);
 636         // inode->i_blocks stores the number of 512 byte data blocks
 637         // (512, because it goes directly to struct stat without scaling)
 638         STORE_LE(inode->i_blocks, blocksize / 512);
 639
 640         // dump root dir inode
 641         STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
 642         STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
 643         PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
 644                                 buf, inodesize);
 645
 646         // dump lost+found dir inode
 647         STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
 648         STORE_LE(inode->i_size, lost_and_found_blocks * blocksize);
 649         STORE_LE(inode->i_blocks, (lost_and_found_blocks * blocksize) / 512);
 650         n = FETCH_LE32(inode->i_block[0]) + 1;
 651         for (i = 0; i < lost_and_found_blocks; ++i)
 652                 STORE_LE(inode->i_block[i], i + n); // use next block
 653 //bb_error_msg("LAST BLOCK USED[%u]", i + n);
 654         PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
 655                                 buf, inodesize);
 656
 657         // dump directories
 658         memset(buf, 0, blocksize);
 659         dir = (struct ext2_dir *)buf;
 660
 661         // dump 2nd+ blocks of "/lost+found"
 662         STORE_LE(dir->rec_len1, blocksize); // e2fsck 1.41.4 compat (1.41.9 does not need this)
 663         for (i = 1; i < lost_and_found_blocks; ++i)
 664                 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1+i) * blocksize,
 665                                 buf, blocksize);
 666
 667         // dump 1st block of "/lost+found"
 668         STORE_LE(dir->inode1, EXT2_GOOD_OLD_FIRST_INO);
 669         STORE_LE(dir->rec_len1, 12);
 670         STORE_LE(dir->name_len1, 1);
 671         STORE_LE(dir->file_type1, EXT2_FT_DIR);
 672         dir->name1[0] = '.';
 673         STORE_LE(dir->inode2, EXT2_ROOT_INO);
 674         STORE_LE(dir->rec_len2, blocksize - 12);
 675         STORE_LE(dir->name_len2, 2);
 676         STORE_LE(dir->file_type2, EXT2_FT_DIR);
 677         dir->name2[0] = '.'; dir->name2[1] = '.';
 678         PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1) * blocksize, buf, blocksize);
 679
 680         // dump root dir block
 681         STORE_LE(dir->inode1, EXT2_ROOT_INO);
 682         STORE_LE(dir->rec_len2, 12);
 683         STORE_LE(dir->inode3, EXT2_GOOD_OLD_FIRST_INO);
 684         STORE_LE(dir->rec_len3, blocksize - 12 - 12);
 685         STORE_LE(dir->name_len3, 10);
 686         STORE_LE(dir->file_type3, EXT2_FT_DIR);
 687         strcpy(dir->name3, "lost+found");
 688         PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 0) * blocksize, buf, blocksize);
 689
 690         // cleanup
 691         if (ENABLE_FEATURE_CLEAN_UP) {
 692                 free(buf);
 693                 free(gd);
 694                 free(sb);
 695         }
 696
 697         xclose(fd);
 698         return EXIT_SUCCESS;
 699 }