1 /* vi: set sw=4 ts=4: */
3 * mkfs_ext2: utility to create EXT2 filesystem
4 * inspired by genext2fs
6 * Busybox'ed (2009) by Vladimir Dronnikov <dronnikov@gmail.com>
8 * Licensed under GPLv2, see file LICENSE in this source tree.
10 //config:config MKE2FS
11 //config: bool "mke2fs"
13 //config: select PLATFORM_LINUX
15 //config: Utility to create EXT2 filesystems.
17 //config:config MKFS_EXT2
18 //config: bool "mkfs.ext2"
20 //config: select PLATFORM_LINUX
22 //config: Alias to "mke2fs".
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))
29 //kbuild:lib-$(CONFIG_MKE2FS) += mkfs_ext2.o
30 //kbuild:lib-$(CONFIG_MKFS_EXT2) += mkfs_ext2.o
32 //usage:#define mkfs_ext2_trivial_usage
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" */
72 #include "bb_e2fs_defs.h"
74 #define ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT 0
75 #define ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX 1
77 #define EXT2_HASH_HALF_MD4 1
78 #define EXT2_FLAGS_SIGNED_HASH 0x0001
79 #define EXT2_FLAGS_UNSIGNED_HASH 0x0002
82 char BUG_wrong_field_size(void);
83 #define STORE_LE(field, value) \
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) \
92 BUG_wrong_field_size(); \
95 #define FETCH_LE32(field) \
96 (sizeof(field) == 4 ? SWAP_LE32(field) : BUG_wrong_field_size())
98 // All fields are little-endian
117 static unsigned int_log2(unsigned arg)
120 while ((arg >>= 1) != 0)
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)
129 // Overflow-resistant
130 uint32_t res = size / n;
136 static void allocate(uint8_t *bitmap, uint32_t blocksize, uint32_t start, uint32_t end)
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);
143 memset(bitmap, 0xFF, i);
144 bitmap[i] = (1 << (start & 7)) - 1; //0..7 => 00000000..01111111
146 bitmap[blocksize - i - 1] |= 0x7F00 >> (end & 7); //0..7 => 00000000..11111110
147 memset(bitmap + blocksize - i, 0xFF, i); // N.B. no overflow here!
150 static uint32_t has_super(uint32_t x)
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 */,
161 const uint32_t *sp = supers + ARRAY_SIZE(supers);
171 #define fd 3 /* predefined output descriptor */
173 static void PUT(uint64_t off, void *buf, uint32_t size)
175 //bb_error_msg("PUT[%llu]:[%u]", off, size);
176 xlseek(fd, off, SEEK_SET);
177 xwrite(fd, buf, size);
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;
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.
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).
197 // Standard mke2fs creates a filesystem with 256-byte inodes if it is
198 // bigger than 0.5GB.
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]
209 // Options not commented below are taken but silently ignored:
213 OPT_b = 1 << 2, // block size, in bytes
215 OPT_i = 1 << 4, // bytes per inode
216 OPT_I = 1 << 5, // custom inode size, in bytes
220 OPT_m = 1 << 9, // percentage of blocks reserved for superuser
223 OPT_L = 1 << 12, // label
231 OPT_n = 1 << 20, // dry run: do not write anything
236 //OPT_V = 1 << 25, // -V version. bbox applets don't support that
239 int mkfs_ext2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
240 int mkfs_ext2_main(int argc UNUSED_PARAM, char **argv)
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;
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;
258 const char *label = "";
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;
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,
274 argv += optind; // argv[0] -- device
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]);
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");
288 // get size in kbytes
289 kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
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;
299 // Determine block size and inode size
300 // block size is a multiple of 1024
301 // inode size is a multiple of 128
303 inodesize = sizeof(struct ext2_inode); // 128
304 if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
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)
315 if (option_mask32 & OPT_b)
317 if (blocksize < EXT2_MIN_BLOCK_SIZE
318 || blocksize > EXT2_MAX_BLOCK_SIZE
319 || (blocksize & (blocksize - 1)) // not power of 2
321 bb_error_msg_and_die("blocksize %u is bad", blocksize);
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
329 bb_error_msg("-%c is bad", 'I');
331 inodesize = user_inodesize;
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);
342 // Determine number of blocks
343 kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
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
350 bb_error_msg_and_die("need >= 60 blocks");
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;
357 // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
358 nblocks_full = nblocks;
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
363 // Note: blocksize and bytes_per_inode are never recalculated.
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);
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) {
373 * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
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.
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;
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);
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));
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)
424 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
426 //// bb_error_msg_and_die("way small device");
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;
441 if (nblocks_full - nblocks)
442 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
444 "Filesystem label=%s\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"
453 "%u blocks per group, %u fragments per group\n"
454 "%u inodes per group"
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
461 , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
463 , blocks_per_group, blocks_per_group
467 const char *fmt = "\nSuperblock backups stored on blocks:\n"
470 for (i = 1; i < ngroups; i++) {
471 pos += blocks_per_group;
473 printf(fmt, (unsigned)pos);
480 if (option_mask32 & OPT_n) {
481 if (ENABLE_FEATURE_CLEAN_UP)
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?
494 // fill the superblock
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);
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);
514 STORE_LE(sb->s_blocks_count, nblocks);
515 // reserve blocks for superuser
516 STORE_LE(sb->s_r_blocks_count, nreserved);
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);
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)
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);
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.
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));
557 safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
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;
565 i++, pos += blocks_per_group, n -= blocks_per_group
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...
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;
587 // cache free block count of the group
588 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
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
595 // mark unused trailing blocks
596 blocks_per_group - (free_blocks + overhead)
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);
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
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);
615 // count overall free blocks
616 sb->s_free_blocks_count += free_blocks;
618 STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
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
625 // N.B. 1024 byte blocks are special
626 PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
628 PUT(((uint64_t)pos * blocksize) + blocksize,
629 gd, group_desc_blocks * blocksize);
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
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,
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);
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,
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,
675 memset(buf, 0, blocksize);
676 dir = (struct ext2_dir *)buf;
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,
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);
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);
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);
708 if (ENABLE_FEATURE_CLEAN_UP) {