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