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,         // custom inode size, in bytes
 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 inodesize, user_inodesize;
 192         unsigned reserved_percent = 5;
 193         unsigned long long kilobytes;
 194         uint32_t nblocks, nblocks_full;
 195         uint32_t nreserved;
 196         uint32_t ngroups;
 197         uint32_t bytes_per_inode;
 198         uint32_t first_block;
 199         uint32_t inodes_per_group;
 200         uint32_t group_desc_blocks;
 201         uint32_t inode_table_blocks;
 202         uint32_t lost_and_found_blocks;
 203         time_t timestamp;
 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         // using global "option_mask32" instead of local "opts":
 213         // we are register starved here
 214         opt_complementary = "-1:b+:m+:i+";
 215         /*opts =*/ getopt32(argv, "cl:b:f:i:I:J:G:N:m:o:g:L:M:O:r:E:T:U:jnqvFS",
 216                 NULL, &bs, NULL, &bpi, &user_inodesize, NULL, NULL, NULL,
 217                 &reserved_percent, NULL, NULL, &label, NULL, NULL, NULL, NULL, NULL, NULL);
 218         argv += optind; // argv[0] -- device
 219
 220         // check the device is a block device
 221         xmove_fd(xopen(argv[0], O_WRONLY), fd);
 222         fstat(fd, &st);
 223         if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_F))
 224                 bb_error_msg_and_die("not a block device");
 225
 226         // check if it is mounted
 227         // N.B. what if we format a file? find_mount_point will return false negative since
 228         // it is loop block device which mounted!
 229         if (find_mount_point(argv[0], 0))
 230                 bb_error_msg_and_die("can't format mounted filesystem");
 231
 232         // open the device, get size in kbytes
 233         if (argv[1]) {
 234                 kilobytes = xatoull(argv[1]);
 235                 // seek past end fails on block devices but works on files
 236                 if (lseek(fd, kilobytes * 1024 - 1, SEEK_SET) != (off_t)-1) {
 237                         if (!(option_mask32 & OPT_n))
 238                                 xwrite(fd, "", 1); // file grows if needed
 239                 }
 240                 //else {
 241                 //      bb_error_msg("warning, block device is smaller");
 242                 //}
 243         } else {
 244                 kilobytes = (uoff_t)xlseek(fd, 0, SEEK_END) / 1024;
 245         }
 246
 247         bytes_per_inode = 16384;
 248         if (kilobytes < 512*1024)
 249                 bytes_per_inode = 4096;
 250         if (kilobytes < 3*1024)
 251                 bytes_per_inode = 8192;
 252         if (option_mask32 & OPT_i)
 253                 bytes_per_inode = bpi;
 254
 255         // Determine block size and inode size
 256         // block size is a multiple of 1024
 257         // inode size is a multiple of 128
 258         blocksize = 1024;
 259         inodesize = sizeof(struct ext2_inode); // 128
 260         if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
 261                 blocksize = 4096;
 262                 inodesize = 256;
 263         }
 264         if (EXT2_MAX_BLOCK_SIZE > 4096) {
 265                 // kilobytes >> 22 == size in 4gigabyte chunks.
 266                 // if size >= 16k gigs, blocksize must be increased.
 267                 // Try "mke2fs -F image $((16 * 1024*1024*1024))"
 268                 while ((kilobytes >> 22) >= blocksize)
 269                         blocksize *= 2;
 270         }
 271         if (option_mask32 & OPT_b)
 272                 blocksize = bs;
 273         if (blocksize < EXT2_MIN_BLOCK_SIZE
 274          || blocksize > EXT2_MAX_BLOCK_SIZE
 275          || (blocksize & (blocksize - 1)) // not power of 2
 276         ) {
 277                 bb_error_msg_and_die("blocksize %u is bad", blocksize);
 278         }
 279         // Do we have custom inode size?
 280         if (option_mask32 & OPT_I) {
 281                 if (user_inodesize < sizeof(*inode)
 282                  || user_inodesize > blocksize
 283                  || (user_inodesize & (user_inodesize - 1)) // not power of 2
 284                 ) {
 285                         bb_error_msg("-%c is bad", 'I');
 286                 } else {
 287                         inodesize = user_inodesize;
 288                 }
 289         }
 290
 291         if ((int32_t)bytes_per_inode < blocksize)
 292                 bb_error_msg_and_die("-%c is bad", 'i');
 293         // number of bits in one block, i.e. 8*blocksize
 294 #define blocks_per_group (8 * blocksize)
 295         first_block = (EXT2_MIN_BLOCK_SIZE == blocksize);
 296         blocksize_log2 = int_log2(blocksize);
 297
 298         // Determine number of blocks
 299         kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
 300         nblocks = kilobytes;
 301         if (nblocks != kilobytes)
 302                 bb_error_msg_and_die("block count doesn't fit in 32 bits");
 303 #define kilobytes kilobytes_unused_after_this
 304         // Experimentally, standard mke2fs won't work on images smaller than 60k
 305         if (nblocks < 60)
 306                 bb_error_msg_and_die("need >= 60 blocks");
 307
 308         // How many reserved blocks?
 309         if (reserved_percent > 50)
 310                 bb_error_msg_and_die("-%c is bad", 'm');
 311         nreserved = (uint64_t)nblocks * reserved_percent / 100;
 312
 313         // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
 314         nblocks_full = nblocks;
 315
 316         // If last block group is too small, nblocks may be decreased in order
 317         // to discard it, and control returns here to recalculate some
 318         // parameters.
 319         // Note: blocksize and bytes_per_inode are never recalculated.
 320  retry:
 321         // N.B. a block group can have no more than blocks_per_group blocks
 322         ngroups = div_roundup(nblocks - first_block, blocks_per_group);
 323
 324         group_desc_blocks = div_roundup(ngroups, blocksize / sizeof(*gd));
 325         // TODO: reserved blocks must be marked as such in the bitmaps,
 326         // or resulting filesystem is corrupt
 327         if (ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT) {
 328                 /*
 329                  * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
 330                  * filesystem growth.
 331                  * The absolute maximum number of GDT blocks we can reserve is determined by
 332                  * the number of block pointers that can fit into a single block.
 333                  * We set it at 1024x the current filesystem size, or
 334                  * the upper block count limit (2^32), whichever is lower.
 335                  */
 336                 uint32_t reserved_group_desc_blocks = 0xFFFFFFFF; // maximum block number
 337                 if (nblocks < reserved_group_desc_blocks / 1024)
 338                         reserved_group_desc_blocks = nblocks * 1024;
 339                 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks - first_block, blocks_per_group);
 340                 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks, blocksize / sizeof(*gd)) - group_desc_blocks;
 341                 if (reserved_group_desc_blocks > blocksize / sizeof(uint32_t))
 342                         reserved_group_desc_blocks = blocksize / sizeof(uint32_t);
 343                 //TODO: STORE_LE(sb->s_reserved_gdt_blocks, reserved_group_desc_blocks);
 344                 group_desc_blocks += reserved_group_desc_blocks;
 345         }
 346
 347         {
 348                 // N.B. e2fsprogs does as follows!
 349                 uint32_t overhead, remainder;
 350                 // ninodes is the max number of inodes in this filesystem
 351                 uint32_t ninodes = ((uint64_t) nblocks_full * blocksize) / bytes_per_inode;
 352                 if (ninodes < EXT2_GOOD_OLD_FIRST_INO+1)
 353                         ninodes = EXT2_GOOD_OLD_FIRST_INO+1;
 354                 inodes_per_group = div_roundup(ninodes, ngroups);
 355                 // minimum number because the first EXT2_GOOD_OLD_FIRST_INO-1 are reserved
 356                 if (inodes_per_group < 16)
 357                         inodes_per_group = 16;
 358                 // a block group can't have more inodes than blocks
 359                 if (inodes_per_group > blocks_per_group)
 360                         inodes_per_group = blocks_per_group;
 361                 // adjust inodes per group so they completely fill the inode table blocks in the descriptor
 362                 inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
 363                 // make sure the number of inodes per group is a multiple of 8
 364                 inodes_per_group &= ~7;
 365                 inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
 366
 367                 // to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
 368                 // and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
 369                 /* Or e2fsprogs comment verbatim (what does it mean?):
 370                  * Ensure that lost+found is at least 2 blocks, so we always
 371                  * test large empty blocks for big-block filesystems. */
 372                 lost_and_found_blocks = MIN(EXT2_NDIR_BLOCKS, 16 >> (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE));
 373
 374                 // the last group needs more attention: isn't it too small for possible overhead?
 375                 overhead = (has_super(ngroups - 1) ? (1/*sb*/ + group_desc_blocks) : 0) + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
 376                 remainder = (nblocks - first_block) % blocks_per_group;
 377                 ////can't happen, nblocks >= 60 guarantees this
 378                 ////if ((1 == ngroups)
 379                 //// && remainder
 380                 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
 381                 ////) {
 382                 ////    bb_error_msg_and_die("way small device");
 383                 ////}
 384
 385                 // Standard mke2fs uses 50. Looks like a bug in our calculation
 386                 // of "remainder" or "overhead" - we don't match standard mke2fs
 387                 // when we transition from one group to two groups
 388                 // (a bit after 8M image size), but it works for two->three groups
 389                 // transition (at 16M).
 390                 if (remainder && (remainder < overhead + 50)) {
 391 //bb_info_msg("CHOP[%u]", remainder);
 392                         nblocks -= remainder;
 393                         goto retry;
 394                 }
 395         }
 396
 397         if (nblocks_full - nblocks)
 398                 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
 399         printf(
 400                 "Filesystem label=%s\n"
 401                 "OS type: Linux\n"
 402                 "Block size=%u (log=%u)\n"
 403                 "Fragment size=%u (log=%u)\n"
 404                 "%u inodes, %u blocks\n"
 405                 "%u blocks (%u%%) reserved for the super user\n"
 406                 "First data block=%u\n"
 407                 "Maximum filesystem blocks=%u\n"
 408                 "%u block groups\n"
 409                 "%u blocks per group, %u fragments per group\n"
 410                 "%u inodes per group"
 411                 , label
 412                 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
 413                 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
 414                 , inodes_per_group * ngroups, nblocks
 415                 , nreserved, reserved_percent
 416                 , first_block
 417                 , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
 418                 , ngroups
 419                 , blocks_per_group, blocks_per_group
 420                 , inodes_per_group
 421         );
 422         {
 423                 const char *fmt = "\nSuperblock backups stored on blocks:\n"
 424                         "\t%u";
 425                 pos = first_block;
 426                 for (i = 1; i < ngroups; i++) {
 427                         pos += blocks_per_group;
 428                         if (has_super(i)) {
 429                                 printf(fmt, (unsigned)pos);
 430                                 fmt = ", %u";
 431                         }
 432                 }
 433         }
 434         bb_putchar('\n');
 435
 436         if (option_mask32 & OPT_n) {
 437                 if (ENABLE_FEATURE_CLEAN_UP)
 438                         close(fd);
 439                 return EXIT_SUCCESS;
 440         }
 441
 442         // TODO: 3/5 refuse if mounted
 443         // TODO: 4/5 compat options
 444         // TODO: 1/5 sanity checks
 445         // TODO: 0/5 more verbose error messages
 446         // TODO: 4/5 bigendianness: recheck, wait for ARM reporters
 447         // TODO: 2/5 reserved GDT: how to mark but not allocate?
 448         // TODO: 3/5 dir_index?
 449
 450         // fill the superblock
 451         sb = xzalloc(1024);
 452         STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
 453         STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
 454         STORE_LE(sb->s_inode_size, inodesize);
 455         // set "Required extra isize" and "Desired extra isize" fields to 28
 456         if (inodesize != sizeof(*inode))
 457                 STORE_LE(sb->s_reserved[21], 0x001C001C);
 458         STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
 459         STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
 460         STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
 461         // first 1024 bytes of the device are for boot record. If block size is 1024 bytes, then
 462         // the first block is 1, otherwise 0
 463         STORE_LE(sb->s_first_data_block, first_block);
 464         // block and inode bitmaps occupy no more than one block, so maximum number of blocks is
 465         STORE_LE(sb->s_blocks_per_group, blocks_per_group);
 466         STORE_LE(sb->s_frags_per_group, blocks_per_group);
 467         // blocks
 468         STORE_LE(sb->s_blocks_count, nblocks);
 469         // reserve blocks for superuser
 470         STORE_LE(sb->s_r_blocks_count, nreserved);
 471         // ninodes
 472         STORE_LE(sb->s_inodes_per_group, inodes_per_group);
 473         STORE_LE(sb->s_inodes_count, inodes_per_group * ngroups);
 474         STORE_LE(sb->s_free_inodes_count, inodes_per_group * ngroups - EXT2_GOOD_OLD_FIRST_INO);
 475         // timestamps
 476         timestamp = time(NULL);
 477         STORE_LE(sb->s_mkfs_time, timestamp);
 478         STORE_LE(sb->s_wtime, timestamp);
 479         STORE_LE(sb->s_lastcheck, timestamp);
 480         // misc. Values are chosen to match mke2fs 1.41.9
 481         STORE_LE(sb->s_state, 1); // TODO: what's 1?
 482         STORE_LE(sb->s_creator_os, EXT2_OS_LINUX);
 483         STORE_LE(sb->s_checkinterval, 24*60*60 * 180); // 180 days
 484         STORE_LE(sb->s_errors, EXT2_ERRORS_DEFAULT);
 485         // mke2fs 1.41.9 also sets EXT3_FEATURE_COMPAT_RESIZE_INODE
 486         // and if >= 0.5GB, EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
 487         // we use values which match "mke2fs -O ^resize_inode":
 488         // in this case 1.41.9 never sets EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
 489         STORE_LE(sb->s_feature_compat, EXT2_FEATURE_COMPAT_SUPP
 490                 | (EXT2_FEATURE_COMPAT_RESIZE_INO * ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT)
 491                 | (EXT2_FEATURE_COMPAT_DIR_INDEX * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX)
 492         );
 493         STORE_LE(sb->s_feature_incompat, EXT2_FEATURE_INCOMPAT_FILETYPE);
 494         STORE_LE(sb->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
 495         STORE_LE(sb->s_flags, EXT2_FLAGS_UNSIGNED_HASH * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX);
 496         generate_uuid(sb->s_uuid);
 497         if (ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX) {
 498                 STORE_LE(sb->s_def_hash_version, EXT2_HASH_HALF_MD4);
 499                 generate_uuid((uint8_t *)sb->s_hash_seed);
 500         }
 501         /*
 502          * From e2fsprogs: add "jitter" to the superblock's check interval so that we
 503          * don't check all the filesystems at the same time.  We use a
 504          * kludgy hack of using the UUID to derive a random jitter value.
 505          */
 506         STORE_LE(sb->s_max_mnt_count,
 507                 EXT2_DFL_MAX_MNT_COUNT
 508                 + (sb->s_uuid[ARRAY_SIZE(sb->s_uuid)-1] % EXT2_DFL_MAX_MNT_COUNT));
 509
 510         // write the label
 511         safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
 512
 513         // calculate filesystem skeleton structures
 514         gd = xzalloc(group_desc_blocks * blocksize);
 515         buf = xmalloc(blocksize);
 516         sb->s_free_blocks_count = 0;
 517         for (i = 0, pos = first_block, n = nblocks - first_block;
 518                 i < ngroups;
 519                 i++, pos += blocks_per_group, n -= blocks_per_group
 520         ) {
 521                 uint32_t overhead = pos + (has_super(i) ? (1/*sb*/ + group_desc_blocks) : 0);
 522                 uint32_t free_blocks;
 523                 // fill group descriptors
 524                 STORE_LE(gd[i].bg_block_bitmap, overhead + 0);
 525                 STORE_LE(gd[i].bg_inode_bitmap, overhead + 1);
 526                 STORE_LE(gd[i].bg_inode_table, overhead + 2);
 527                 overhead = overhead - pos + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
 528                 gd[i].bg_free_inodes_count = inodes_per_group;
 529                 //STORE_LE(gd[i].bg_used_dirs_count, 0);
 530                 // N.B. both "/" and "/lost+found" are within the first block group
 531                 // "/" occupies 1 block, "/lost+found" occupies lost_and_found_blocks...
 532                 if (0 == i) {
 533                         // ... thus increased overhead for the first block group ...
 534                         overhead += 1 + lost_and_found_blocks;
 535                         // ... and 2 used directories
 536                         STORE_LE(gd[i].bg_used_dirs_count, 2);
 537                         // well known reserved inodes belong to the first block too
 538                         gd[i].bg_free_inodes_count -= EXT2_GOOD_OLD_FIRST_INO;
 539                 }
 540
 541                 // cache free block count of the group
 542                 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
 543
 544                 // mark preallocated blocks as allocated
 545 //bb_info_msg("ALLOC: [%u][%u][%u]", blocksize, overhead, blocks_per_group - (free_blocks + overhead));
 546                 allocate(buf, blocksize,
 547                         // reserve "overhead" blocks
 548                         overhead,
 549                         // mark unused trailing blocks
 550                         blocks_per_group - (free_blocks + overhead)
 551                 );
 552                 // dump block bitmap
 553                 PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
 554                 STORE_LE(gd[i].bg_free_blocks_count, free_blocks);
 555
 556                 // mark preallocated inodes as allocated
 557                 allocate(buf, blocksize,
 558                         // mark reserved inodes
 559                         inodes_per_group - gd[i].bg_free_inodes_count,
 560                         // mark unused trailing inodes
 561                         blocks_per_group - inodes_per_group
 562                 );
 563                 // dump inode bitmap
 564                 //PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
 565                 //but it's right after block bitmap, so we can just:
 566                 xwrite(fd, buf, blocksize);
 567                 STORE_LE(gd[i].bg_free_inodes_count, gd[i].bg_free_inodes_count);
 568
 569                 // count overall free blocks
 570                 sb->s_free_blocks_count += free_blocks;
 571         }
 572         STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
 573
 574         // dump filesystem skeleton structures
 575 //      printf("Writing superblocks and filesystem accounting information: ");
 576         for (i = 0, pos = first_block; i < ngroups; i++, pos += blocks_per_group) {
 577                 // dump superblock and group descriptors and their backups
 578                 if (has_super(i)) {
 579                         // N.B. 1024 byte blocks are special
 580                         PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
 581                                         sb, 1024);
 582                         PUT(((uint64_t)pos * blocksize) + blocksize,
 583                                         gd, group_desc_blocks * blocksize);
 584                 }
 585         }
 586
 587         // zero boot sectors
 588         memset(buf, 0, blocksize);
 589         PUT(0, buf, 1024); // N.B. 1024 <= blocksize, so buf[0..1023] contains zeros
 590         // zero inode tables
 591         for (i = 0; i < ngroups; ++i)
 592                 for (n = 0; n < inode_table_blocks; ++n)
 593                         PUT((uint64_t)(FETCH_LE32(gd[i].bg_inode_table) + n) * blocksize,
 594                                 buf, blocksize);
 595
 596         // prepare directory inode
 597         inode = (struct ext2_inode *)buf;
 598         STORE_LE(inode->i_mode, S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
 599         STORE_LE(inode->i_mtime, timestamp);
 600         STORE_LE(inode->i_atime, timestamp);
 601         STORE_LE(inode->i_ctime, timestamp);
 602         STORE_LE(inode->i_size, blocksize);
 603         // inode->i_blocks stores the number of 512 byte data blocks
 604         // (512, because it goes directly to struct stat without scaling)
 605         STORE_LE(inode->i_blocks, blocksize / 512);
 606
 607         // dump root dir inode
 608         STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
 609         STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
 610         PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
 611                                 buf, inodesize);
 612
 613         // dump lost+found dir inode
 614         STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
 615         STORE_LE(inode->i_size, lost_and_found_blocks * blocksize);
 616         STORE_LE(inode->i_blocks, (lost_and_found_blocks * blocksize) / 512);
 617         n = FETCH_LE32(inode->i_block[0]) + 1;
 618         for (i = 0; i < lost_and_found_blocks; ++i)
 619                 STORE_LE(inode->i_block[i], i + n); // use next block
 620 //bb_info_msg("LAST BLOCK USED[%u]", i + n);
 621         PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
 622                                 buf, inodesize);
 623
 624         // dump directories
 625         memset(buf, 0, blocksize);
 626         dir = (struct ext2_dir *)buf;
 627
 628         // dump 2nd+ blocks of "/lost+found"
 629         STORE_LE(dir->rec_len1, blocksize); // e2fsck 1.41.4 compat (1.41.9 does not need this)
 630         for (i = 1; i < lost_and_found_blocks; ++i)
 631                 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1+i) * blocksize,
 632                                 buf, blocksize);
 633
 634         // dump 1st block of "/lost+found"
 635         STORE_LE(dir->inode1, EXT2_GOOD_OLD_FIRST_INO);
 636         STORE_LE(dir->rec_len1, 12);
 637         STORE_LE(dir->name_len1, 1);
 638         STORE_LE(dir->file_type1, EXT2_FT_DIR);
 639         dir->name1[0] = '.';
 640         STORE_LE(dir->inode2, EXT2_ROOT_INO);
 641         STORE_LE(dir->rec_len2, blocksize - 12);
 642         STORE_LE(dir->name_len2, 2);
 643         STORE_LE(dir->file_type2, EXT2_FT_DIR);
 644         dir->name2[0] = '.'; dir->name2[1] = '.';
 645         PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1) * blocksize, buf, blocksize);
 646
 647         // dump root dir block
 648         STORE_LE(dir->inode1, EXT2_ROOT_INO);
 649         STORE_LE(dir->rec_len2, 12);
 650         STORE_LE(dir->inode3, EXT2_GOOD_OLD_FIRST_INO);
 651         STORE_LE(dir->rec_len3, blocksize - 12 - 12);
 652         STORE_LE(dir->name_len3, 10);
 653         STORE_LE(dir->file_type3, EXT2_FT_DIR);
 654         strcpy(dir->name3, "lost+found");
 655         PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 0) * blocksize, buf, blocksize);
 656
 657         // cleanup
 658         if (ENABLE_FEATURE_CLEAN_UP) {
 659                 free(buf);
 660                 free(gd);
 661                 free(sb);
 662         }
 663
 664         xclose(fd);
 665         return EXIT_SUCCESS;
 666 }