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