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 (9.7 kb)"
13 //config: select PLATFORM_LINUX
15 //config: Utility to create EXT2 filesystems.
17 //config:config MKFS_EXT2
18 //config: bool "mkfs.ext2 (9.8 kb)"
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
81 // All fields are little-endian
100 static unsigned int_log2(unsigned arg)
103 while ((arg >>= 1) != 0)
108 // taken from mkfs_minix.c. libbb candidate?
109 // "uint32_t size", since we never use it for anything >32 bits
110 static uint32_t div_roundup(uint32_t size, uint32_t n)
112 // Overflow-resistant
113 uint32_t res = size / n;
119 static void allocate(uint8_t *bitmap, uint32_t blocksize, uint32_t start, uint32_t end)
123 //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)));
124 memset(bitmap, 0, blocksize);
126 memset(bitmap, 0xFF, i);
127 bitmap[i] = (1 << (start & 7)) - 1; //0..7 => 00000000..01111111
129 bitmap[blocksize - i - 1] |= 0x7F00 >> (end & 7); //0..7 => 00000000..11111110
130 memset(bitmap + blocksize - i, 0xFF, i); // N.B. no overflow here!
133 static uint32_t has_super(uint32_t x)
135 // 0, 1 and powers of 3, 5, 7 up to 2^32 limit
136 static const uint32_t supers[] = {
137 0, 1, 3, 5, 7, 9, 25, 27, 49, 81, 125, 243, 343, 625, 729,
138 2187, 2401, 3125, 6561, 15625, 16807, 19683, 59049, 78125,
139 117649, 177147, 390625, 531441, 823543, 1594323, 1953125,
140 4782969, 5764801, 9765625, 14348907, 40353607, 43046721,
141 48828125, 129140163, 244140625, 282475249, 387420489,
142 1162261467, 1220703125, 1977326743, 3486784401/* >2^31 */,
144 const uint32_t *sp = supers + ARRAY_SIZE(supers);
154 #define fd 3 /* predefined output descriptor */
156 static void PUT(uint64_t off, void *buf, uint32_t size)
158 //bb_error_msg("PUT[%llu]:[%u]", off, size);
159 xlseek(fd, off, SEEK_SET);
160 xwrite(fd, buf, size);
163 // 128 and 256-byte inodes:
164 // 128-byte inode is described by struct ext2_inode.
165 // 256-byte one just has these fields appended:
166 // __u16 i_extra_isize;
168 // __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
169 // __u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */
170 // __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
171 // __u32 i_crtime; /* File creation time */
172 // __u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/
173 // __u32 i_version_hi; /* high 32 bits for 64-bit version */
174 // the rest is padding.
176 // linux/ext2_fs.h has "#define i_size_high i_dir_acl" which suggests that even
177 // 128-byte inode is capable of describing large files (i_dir_acl is meaningful
178 // only for directories, which never need i_size_high).
180 // Standard mke2fs creates a filesystem with 256-byte inodes if it is
181 // bigger than 0.5GB.
183 // Standard mke2fs 1.41.9:
184 // Usage: mke2fs [-c|-l filename] [-b block-size] [-f fragment-size]
185 // [-i bytes-per-inode] [-I inode-size] [-J journal-options]
186 // [-G meta group size] [-N number-of-inodes]
187 // [-m reserved-blocks-percentage] [-o creator-os]
188 // [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
189 // [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
190 // [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
192 // Options not commented below are taken but silently ignored:
196 OPT_b = 1 << 2, // block size, in bytes
198 OPT_i = 1 << 4, // bytes per inode
199 OPT_I = 1 << 5, // custom inode size, in bytes
203 OPT_m = 1 << 9, // percentage of blocks reserved for superuser
206 OPT_L = 1 << 12, // label
214 OPT_n = 1 << 20, // dry run: do not write anything
219 //OPT_V = 1 << 25, // -V version. bbox applets don't support that
222 int mkfs_ext2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
223 int mkfs_ext2_main(int argc UNUSED_PARAM, char **argv)
227 unsigned blocksize, blocksize_log2;
228 unsigned inodesize, user_inodesize;
229 unsigned reserved_percent = 5;
230 unsigned long long kilobytes;
231 uint32_t nblocks, nblocks_full;
234 uint32_t bytes_per_inode;
235 uint32_t first_block;
236 uint32_t inodes_per_group;
237 uint32_t group_desc_blocks;
238 uint32_t inode_table_blocks;
239 uint32_t lost_and_found_blocks;
241 const char *label = "";
243 struct ext2_super_block *sb; // superblock
244 struct ext2_group_desc *gd; // group descriptors
245 struct ext2_inode *inode;
246 struct ext2_dir *dir;
249 // using global "option_mask32" instead of local "opts":
250 // we are register starved here
251 /*opts =*/ getopt32(argv, "cl:b:+f:i:+I:+J:G:N:m:+o:g:L:M:O:r:E:T:U:jnqvFS",
252 /*lbfi:*/ NULL, &bs, NULL, &bpi,
253 /*IJGN:*/ &user_inodesize, NULL, NULL, NULL,
254 /*mogL:*/ &reserved_percent, NULL, NULL, &label,
255 /*MOrE:*/ NULL, NULL, NULL, NULL,
257 argv += optind; // argv[0] -- device
259 // open the device, check the device is a block device
260 xmove_fd(xopen(argv[0], O_WRONLY), fd);
261 xfstat(fd, &st, argv[0]);
262 if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_F))
263 bb_error_msg_and_die("%s: not a block device", argv[0]);
265 // check if it is mounted
266 // N.B. what if we format a file? find_mount_point will return false negative since
267 // it is loop block device which is mounted!
268 if (find_mount_point(argv[0], 0))
269 bb_error_msg_and_die("can't format mounted filesystem");
271 // get size in kbytes
272 kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
274 bytes_per_inode = 16384;
275 if (kilobytes < 512*1024)
276 bytes_per_inode = 4096;
277 if (kilobytes < 3*1024)
278 bytes_per_inode = 8192;
279 if (option_mask32 & OPT_i)
280 bytes_per_inode = bpi;
282 // Determine block size and inode size
283 // block size is a multiple of 1024
284 // inode size is a multiple of 128
286 inodesize = sizeof(struct ext2_inode); // 128
287 if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
291 if (EXT2_MAX_BLOCK_SIZE > 4096) {
292 // kilobytes >> 22 == size in 4gigabyte chunks.
293 // if size >= 16k gigs, blocksize must be increased.
294 // Try "mke2fs -F image $((16 * 1024*1024*1024))"
295 while ((kilobytes >> 22) >= blocksize)
298 if (option_mask32 & OPT_b)
300 if (blocksize < EXT2_MIN_BLOCK_SIZE
301 || blocksize > EXT2_MAX_BLOCK_SIZE
302 || (blocksize & (blocksize - 1)) // not power of 2
304 bb_error_msg_and_die("blocksize %u is bad", blocksize);
306 // Do we have custom inode size?
307 if (option_mask32 & OPT_I) {
308 if (user_inodesize < sizeof(*inode)
309 || user_inodesize > blocksize
310 || (user_inodesize & (user_inodesize - 1)) // not power of 2
312 bb_error_msg("-%c is bad", 'I');
314 inodesize = user_inodesize;
318 if ((int32_t)bytes_per_inode < blocksize)
319 bb_error_msg_and_die("-%c is bad", 'i');
320 // number of bits in one block, i.e. 8*blocksize
321 #define blocks_per_group (8 * blocksize)
322 first_block = (EXT2_MIN_BLOCK_SIZE == blocksize);
323 blocksize_log2 = int_log2(blocksize);
325 // Determine number of blocks
326 kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
328 if (nblocks != kilobytes)
329 bb_error_msg_and_die("block count doesn't fit in 32 bits");
330 #define kilobytes kilobytes_unused_after_this
331 // Experimentally, standard mke2fs won't work on images smaller than 60k
333 bb_error_msg_and_die("need >= 60 blocks");
335 // How many reserved blocks?
336 if (reserved_percent > 50)
337 bb_error_msg_and_die("-%c is bad", 'm');
338 nreserved = (uint64_t)nblocks * reserved_percent / 100;
340 // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
341 nblocks_full = nblocks;
343 // If last block group is too small, nblocks may be decreased in order
344 // to discard it, and control returns here to recalculate some
346 // Note: blocksize and bytes_per_inode are never recalculated.
348 // N.B. a block group can have no more than blocks_per_group blocks
349 ngroups = div_roundup(nblocks - first_block, blocks_per_group);
351 group_desc_blocks = div_roundup(ngroups, blocksize / sizeof(*gd));
352 // TODO: reserved blocks must be marked as such in the bitmaps,
353 // or resulting filesystem is corrupt
354 if (ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT) {
356 * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
358 * The absolute maximum number of GDT blocks we can reserve is determined by
359 * the number of block pointers that can fit into a single block.
360 * We set it at 1024x the current filesystem size, or
361 * the upper block count limit (2^32), whichever is lower.
363 uint32_t reserved_group_desc_blocks = 0xFFFFFFFF; // maximum block number
364 if (nblocks < reserved_group_desc_blocks / 1024)
365 reserved_group_desc_blocks = nblocks * 1024;
366 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks - first_block, blocks_per_group);
367 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks, blocksize / sizeof(*gd)) - group_desc_blocks;
368 if (reserved_group_desc_blocks > blocksize / sizeof(uint32_t))
369 reserved_group_desc_blocks = blocksize / sizeof(uint32_t);
370 //TODO: STORE_LE(sb->s_reserved_gdt_blocks, reserved_group_desc_blocks);
371 group_desc_blocks += reserved_group_desc_blocks;
375 // N.B. e2fsprogs does as follows!
376 uint32_t overhead, remainder;
377 // ninodes is the max number of inodes in this filesystem
378 uint32_t ninodes = ((uint64_t) nblocks_full * blocksize) / bytes_per_inode;
379 if (ninodes < EXT2_GOOD_OLD_FIRST_INO+1)
380 ninodes = EXT2_GOOD_OLD_FIRST_INO+1;
381 inodes_per_group = div_roundup(ninodes, ngroups);
382 // minimum number because the first EXT2_GOOD_OLD_FIRST_INO-1 are reserved
383 if (inodes_per_group < 16)
384 inodes_per_group = 16;
385 // a block group can't have more inodes than blocks
386 if (inodes_per_group > blocks_per_group)
387 inodes_per_group = blocks_per_group;
388 // adjust inodes per group so they completely fill the inode table blocks in the descriptor
389 inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
390 // make sure the number of inodes per group is a multiple of 8
391 inodes_per_group &= ~7;
392 inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
394 // to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
395 // and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
396 /* Or e2fsprogs comment verbatim (what does it mean?):
397 * Ensure that lost+found is at least 2 blocks, so we always
398 * test large empty blocks for big-block filesystems. */
399 lost_and_found_blocks = MIN(EXT2_NDIR_BLOCKS, 16 >> (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE));
401 // the last group needs more attention: isn't it too small for possible overhead?
402 overhead = (has_super(ngroups - 1) ? (1/*sb*/ + group_desc_blocks) : 0) + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
403 remainder = (nblocks - first_block) % blocks_per_group;
404 ////can't happen, nblocks >= 60 guarantees this
405 ////if ((1 == ngroups)
407 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
409 //// bb_error_msg_and_die("way small device");
412 // Standard mke2fs uses 50. Looks like a bug in our calculation
413 // of "remainder" or "overhead" - we don't match standard mke2fs
414 // when we transition from one group to two groups
415 // (a bit after 8M image size), but it works for two->three groups
416 // transition (at 16M).
417 if (remainder && (remainder < overhead + 50)) {
418 //bb_error_msg("CHOP[%u]", remainder);
419 nblocks -= remainder;
424 if (nblocks_full - nblocks)
425 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
427 "Filesystem label=%s\n"
429 "Block size=%u (log=%u)\n"
430 "Fragment size=%u (log=%u)\n"
431 "%u inodes, %u blocks\n"
432 "%u blocks (%u%%) reserved for the super user\n"
433 "First data block=%u\n"
434 "Maximum filesystem blocks=%u\n"
436 "%u blocks per group, %u fragments per group\n"
437 "%u inodes per group"
439 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
440 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
441 , inodes_per_group * ngroups, nblocks
442 , nreserved, reserved_percent
444 , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
446 , blocks_per_group, blocks_per_group
450 const char *fmt = "\nSuperblock backups stored on blocks:\n"
453 for (i = 1; i < ngroups; i++) {
454 pos += blocks_per_group;
456 printf(fmt, (unsigned)pos);
463 if (option_mask32 & OPT_n) {
464 if (ENABLE_FEATURE_CLEAN_UP)
469 // TODO: 3/5 refuse if mounted
470 // TODO: 4/5 compat options
471 // TODO: 1/5 sanity checks
472 // TODO: 0/5 more verbose error messages
473 // TODO: 4/5 bigendianness: recheck, wait for ARM reporters
474 // TODO: 2/5 reserved GDT: how to mark but not allocate?
475 // TODO: 3/5 dir_index?
477 // fill the superblock
479 STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
480 STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
481 STORE_LE(sb->s_inode_size, inodesize);
482 // set "Required extra isize" and "Desired extra isize" fields to 28
483 if (inodesize != sizeof(*inode)) {
484 STORE_LE(sb->s_min_extra_isize, 0x001c);
485 STORE_LE(sb->s_want_extra_isize, 0x001c);
487 STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
488 STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
489 STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
490 // first 1024 bytes of the device are for boot record. If block size is 1024 bytes, then
491 // the first block is 1, otherwise 0
492 STORE_LE(sb->s_first_data_block, first_block);
493 // block and inode bitmaps occupy no more than one block, so maximum number of blocks is
494 STORE_LE(sb->s_blocks_per_group, blocks_per_group);
495 STORE_LE(sb->s_frags_per_group, blocks_per_group);
497 STORE_LE(sb->s_blocks_count, nblocks);
498 // reserve blocks for superuser
499 STORE_LE(sb->s_r_blocks_count, nreserved);
501 STORE_LE(sb->s_inodes_per_group, inodes_per_group);
502 STORE_LE(sb->s_inodes_count, inodes_per_group * ngroups);
503 STORE_LE(sb->s_free_inodes_count, inodes_per_group * ngroups - EXT2_GOOD_OLD_FIRST_INO);
505 timestamp = time(NULL);
506 STORE_LE(sb->s_mkfs_time, timestamp);
507 STORE_LE(sb->s_wtime, timestamp);
508 STORE_LE(sb->s_lastcheck, timestamp);
509 // misc. Values are chosen to match mke2fs 1.41.9
510 STORE_LE(sb->s_state, 1); // TODO: what's 1?
511 STORE_LE(sb->s_creator_os, EXT2_OS_LINUX);
512 STORE_LE(sb->s_checkinterval, 24*60*60 * 180); // 180 days
513 STORE_LE(sb->s_errors, EXT2_ERRORS_DEFAULT);
514 // mke2fs 1.41.9 also sets EXT3_FEATURE_COMPAT_RESIZE_INODE
515 // and if >= 0.5GB, EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
516 // we use values which match "mke2fs -O ^resize_inode":
517 // in this case 1.41.9 never sets EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
518 STORE_LE(sb->s_feature_compat, EXT2_FEATURE_COMPAT_SUPP
519 | (EXT2_FEATURE_COMPAT_RESIZE_INO * ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT)
520 | (EXT2_FEATURE_COMPAT_DIR_INDEX * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX)
522 STORE_LE(sb->s_feature_incompat, EXT2_FEATURE_INCOMPAT_FILETYPE);
523 STORE_LE(sb->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
524 STORE_LE(sb->s_flags, EXT2_FLAGS_UNSIGNED_HASH * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX);
525 generate_uuid(sb->s_uuid);
526 if (ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX) {
527 STORE_LE(sb->s_def_hash_version, EXT2_HASH_HALF_MD4);
528 generate_uuid((uint8_t *)sb->s_hash_seed);
531 * From e2fsprogs: add "jitter" to the superblock's check interval so that we
532 * don't check all the filesystems at the same time. We use a
533 * kludgy hack of using the UUID to derive a random jitter value.
535 STORE_LE(sb->s_max_mnt_count,
536 EXT2_DFL_MAX_MNT_COUNT
537 + (sb->s_uuid[ARRAY_SIZE(sb->s_uuid)-1] % EXT2_DFL_MAX_MNT_COUNT));
540 safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
542 // calculate filesystem skeleton structures
543 gd = xzalloc(group_desc_blocks * blocksize);
544 buf = xmalloc(blocksize);
545 sb->s_free_blocks_count = 0;
546 for (i = 0, pos = first_block, n = nblocks - first_block;
548 i++, pos += blocks_per_group, n -= blocks_per_group
550 uint32_t overhead = pos + (has_super(i) ? (1/*sb*/ + group_desc_blocks) : 0);
551 uint32_t free_blocks;
552 // fill group descriptors
553 STORE_LE(gd[i].bg_block_bitmap, overhead + 0);
554 STORE_LE(gd[i].bg_inode_bitmap, overhead + 1);
555 STORE_LE(gd[i].bg_inode_table, overhead + 2);
556 overhead = overhead - pos + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
557 gd[i].bg_free_inodes_count = inodes_per_group;
558 //STORE_LE(gd[i].bg_used_dirs_count, 0);
559 // N.B. both "/" and "/lost+found" are within the first block group
560 // "/" occupies 1 block, "/lost+found" occupies lost_and_found_blocks...
562 // ... thus increased overhead for the first block group ...
563 overhead += 1 + lost_and_found_blocks;
564 // ... and 2 used directories
565 STORE_LE(gd[i].bg_used_dirs_count, 2);
566 // well known reserved inodes belong to the first block too
567 gd[i].bg_free_inodes_count -= EXT2_GOOD_OLD_FIRST_INO;
570 // cache free block count of the group
571 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
573 // mark preallocated blocks as allocated
574 //bb_error_msg("ALLOC: [%u][%u][%u]", blocksize, overhead, blocks_per_group - (free_blocks + overhead));
575 allocate(buf, blocksize,
576 // reserve "overhead" blocks
578 // mark unused trailing blocks
579 blocks_per_group - (free_blocks + overhead)
582 PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
583 STORE_LE(gd[i].bg_free_blocks_count, free_blocks);
585 // mark preallocated inodes as allocated
586 allocate(buf, blocksize,
587 // mark reserved inodes
588 inodes_per_group - gd[i].bg_free_inodes_count,
589 // mark unused trailing inodes
590 blocks_per_group - inodes_per_group
593 //PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
594 //but it's right after block bitmap, so we can just:
595 xwrite(fd, buf, blocksize);
596 STORE_LE(gd[i].bg_free_inodes_count, gd[i].bg_free_inodes_count);
598 // count overall free blocks
599 sb->s_free_blocks_count += free_blocks;
601 STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
603 // dump filesystem skeleton structures
604 // printf("Writing superblocks and filesystem accounting information: ");
605 for (i = 0, pos = first_block; i < ngroups; i++, pos += blocks_per_group) {
606 // dump superblock and group descriptors and their backups
608 // N.B. 1024 byte blocks are special
609 PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
611 PUT(((uint64_t)pos * blocksize) + blocksize,
612 gd, group_desc_blocks * blocksize);
617 memset(buf, 0, blocksize);
618 // Disabled: standard mke2fs doesn't do this, and
619 // on SPARC this destroys Sun disklabel.
620 // Users who need/want zeroing can easily do it with dd.
621 //PUT(0, buf, 1024); // N.B. 1024 <= blocksize, so buf[0..1023] contains zeros
624 for (i = 0; i < ngroups; ++i)
625 for (n = 0; n < inode_table_blocks; ++n)
626 PUT((uint64_t)(FETCH_LE32(gd[i].bg_inode_table) + n) * blocksize,
629 // prepare directory inode
630 inode = (struct ext2_inode *)buf;
631 STORE_LE(inode->i_mode, S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
632 STORE_LE(inode->i_mtime, timestamp);
633 STORE_LE(inode->i_atime, timestamp);
634 STORE_LE(inode->i_ctime, timestamp);
635 STORE_LE(inode->i_size, blocksize);
636 // inode->i_blocks stores the number of 512 byte data blocks
637 // (512, because it goes directly to struct stat without scaling)
638 STORE_LE(inode->i_blocks, blocksize / 512);
640 // dump root dir inode
641 STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
642 STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
643 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
646 // dump lost+found dir inode
647 STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
648 STORE_LE(inode->i_size, lost_and_found_blocks * blocksize);
649 STORE_LE(inode->i_blocks, (lost_and_found_blocks * blocksize) / 512);
650 n = FETCH_LE32(inode->i_block[0]) + 1;
651 for (i = 0; i < lost_and_found_blocks; ++i)
652 STORE_LE(inode->i_block[i], i + n); // use next block
653 //bb_error_msg("LAST BLOCK USED[%u]", i + n);
654 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
658 memset(buf, 0, blocksize);
659 dir = (struct ext2_dir *)buf;
661 // dump 2nd+ blocks of "/lost+found"
662 STORE_LE(dir->rec_len1, blocksize); // e2fsck 1.41.4 compat (1.41.9 does not need this)
663 for (i = 1; i < lost_and_found_blocks; ++i)
664 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1+i) * blocksize,
667 // dump 1st block of "/lost+found"
668 STORE_LE(dir->inode1, EXT2_GOOD_OLD_FIRST_INO);
669 STORE_LE(dir->rec_len1, 12);
670 STORE_LE(dir->name_len1, 1);
671 STORE_LE(dir->file_type1, EXT2_FT_DIR);
673 STORE_LE(dir->inode2, EXT2_ROOT_INO);
674 STORE_LE(dir->rec_len2, blocksize - 12);
675 STORE_LE(dir->name_len2, 2);
676 STORE_LE(dir->file_type2, EXT2_FT_DIR);
677 dir->name2[0] = '.'; dir->name2[1] = '.';
678 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1) * blocksize, buf, blocksize);
680 // dump root dir block
681 STORE_LE(dir->inode1, EXT2_ROOT_INO);
682 STORE_LE(dir->rec_len2, 12);
683 STORE_LE(dir->inode3, EXT2_GOOD_OLD_FIRST_INO);
684 STORE_LE(dir->rec_len3, blocksize - 12 - 12);
685 STORE_LE(dir->name_len3, 10);
686 STORE_LE(dir->file_type3, EXT2_FT_DIR);
687 strcpy(dir->name3, "lost+found");
688 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 0) * blocksize, buf, blocksize);
691 if (ENABLE_FEATURE_CLEAN_UP) {