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