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 tarball for details.
12 #include <linux/ext2_fs.h>
13 #include "volume_id/volume_id_internal.h"
15 #define ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT 0
16 #define ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX 1
19 #define s_reserved_gdt_blocks s_padding1
20 #define s_mkfs_time s_reserved[0]
21 #define s_flags s_reserved[22]
23 #define EXT2_HASH_HALF_MD4 1
24 #define EXT2_FLAGS_SIGNED_HASH 0x0001
25 #define EXT2_FLAGS_UNSIGNED_HASH 0x0002
28 char BUG_wrong_field_size(void);
29 #define STORE_LE(field, value) \
31 if (sizeof(field) == 4) \
32 field = cpu_to_le32(value); \
33 else if (sizeof(field) == 2) \
34 field = cpu_to_le16(value); \
35 else if (sizeof(field) == 1) \
38 BUG_wrong_field_size(); \
41 #define FETCH_LE32(field) \
42 (sizeof(field) == 4 ? cpu_to_le32(field) : BUG_wrong_field_size())
44 // All fields are little-endian
63 static unsigned int_log2(unsigned arg)
66 while ((arg >>= 1) != 0)
71 // taken from mkfs_minix.c. libbb candidate?
72 // "uint32_t size", since we never use it for anything >32 bits
73 static uint32_t div_roundup(uint32_t size, uint32_t n)
76 uint32_t res = size / n;
82 static void allocate(uint8_t *bitmap, uint32_t blocksize, uint32_t start, uint32_t end)
86 //bb_info_msg("ALLOC: [%u][%u][%u]: [%u-%u]:=[%x],[%x]", blocksize, start, end, start/8, blocksize - end/8 - 1, (1 << (start & 7)) - 1, (uint8_t)(0xFF00 >> (end & 7)));
87 memset(bitmap, 0, blocksize);
89 memset(bitmap, 0xFF, i);
90 bitmap[i] = (1 << (start & 7)) - 1; //0..7 => 00000000..01111111
92 bitmap[blocksize - i - 1] |= 0x7F00 >> (end & 7); //0..7 => 00000000..11111110
93 memset(bitmap + blocksize - i, 0xFF, i); // N.B. no overflow here!
96 static uint32_t has_super(uint32_t x)
98 // 0, 1 and powers of 3, 5, 7 up to 2^32 limit
99 static const uint32_t supers[] = {
100 0, 1, 3, 5, 7, 9, 25, 27, 49, 81, 125, 243, 343, 625, 729,
101 2187, 2401, 3125, 6561, 15625, 16807, 19683, 59049, 78125,
102 117649, 177147, 390625, 531441, 823543, 1594323, 1953125,
103 4782969, 5764801, 9765625, 14348907, 40353607, 43046721,
104 48828125, 129140163, 244140625, 282475249, 387420489,
105 1162261467, 1220703125, 1977326743, 3486784401/* >2^31 */,
107 const uint32_t *sp = supers + ARRAY_SIZE(supers);
117 #define fd 3 /* predefined output descriptor */
119 static void PUT(uint64_t off, void *buf, uint32_t size)
121 // bb_info_msg("PUT[%llu]:[%u]", off, size);
122 xlseek(fd, off, SEEK_SET);
123 xwrite(fd, buf, size);
126 // 128 and 256-byte inodes:
127 // 128-byte inode is described by struct ext2_inode.
128 // 256-byte one just has these fields appended:
129 // __u16 i_extra_isize;
131 // __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
132 // __u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */
133 // __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
134 // __u32 i_crtime; /* File creation time */
135 // __u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/
136 // __u32 i_version_hi; /* high 32 bits for 64-bit version */
137 // the rest is padding.
139 // linux/ext2_fs.h has "#define i_size_high i_dir_acl" which suggests that even
140 // 128-byte inode is capable of describing large files (i_dir_acl is meaningful
141 // only for directories, which never need i_size_high).
143 // Standard mke2fs creates a filesystem with 256-byte inodes if it is
144 // bigger than 0.5GB. So far, we do not do this.
146 // Standard mke2fs 1.41.9:
147 // Usage: mke2fs [-c|-l filename] [-b block-size] [-f fragment-size]
148 // [-i bytes-per-inode] [-I inode-size] [-J journal-options]
149 // [-G meta group size] [-N number-of-inodes]
150 // [-m reserved-blocks-percentage] [-o creator-os]
151 // [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
152 // [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
153 // [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
155 // Options not commented below are taken but silently ignored:
159 OPT_b = 1 << 2, // block size, in bytes
161 OPT_i = 1 << 4, // bytes per inode
162 OPT_I = 1 << 5, // custom inode size, in bytes
166 OPT_m = 1 << 9, // percentage of blocks reserved for superuser
169 OPT_L = 1 << 12, // label
177 OPT_n = 1 << 20, // dry run: do not write anything
182 //OPT_V = 1 << 25, // -V version. bbox applets don't support that
185 int mkfs_ext2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
186 int mkfs_ext2_main(int argc UNUSED_PARAM, char **argv)
190 unsigned blocksize, blocksize_log2;
191 unsigned inodesize, user_inodesize;
192 unsigned reserved_percent = 5;
193 unsigned long long kilobytes;
194 uint32_t nblocks, nblocks_full;
197 uint32_t bytes_per_inode;
198 uint32_t first_block;
199 uint32_t inodes_per_group;
200 uint32_t group_desc_blocks;
201 uint32_t inode_table_blocks;
202 uint32_t lost_and_found_blocks;
205 const char *label = "";
207 struct ext2_super_block *sb; // superblock
208 struct ext2_group_desc *gd; // group descriptors
209 struct ext2_inode *inode;
210 struct ext2_dir *dir;
213 opt_complementary = "-1:b+:m+:i+";
214 opts = getopt32(argv, "cl:b:f:i:I:J:G:N:m:o:g:L:M:O:r:E:T:U:jnqvFS",
215 NULL, &bs, NULL, &bpi, &user_inodesize, NULL, NULL, NULL,
216 &reserved_percent, NULL, NULL, &label, NULL, NULL, NULL, NULL, NULL, NULL);
217 argv += optind; // argv[0] -- device
219 // check the device is a block device
220 xmove_fd(xopen(argv[0], O_WRONLY), fd);
222 if (!S_ISBLK(st.st_mode) && !(opts & OPT_F))
223 bb_error_msg_and_die("not a block device");
225 // check if it is mounted
226 // N.B. what if we format a file? find_mount_point will return false negative since
227 // it is loop block device which mounted!
228 if (find_mount_point(argv[0], 0))
229 bb_error_msg_and_die("can't format mounted filesystem");
231 // open the device, get size in kbytes
233 kilobytes = xatoull(argv[1]);
234 // seek past end fails on block devices but works on files
235 if (lseek(fd, kilobytes * 1024 - 1, SEEK_SET) != (off_t)-1) {
236 xwrite(fd, "", 1); // file grows if needed
239 // bb_error_msg("warning, block device is smaller");
242 kilobytes = (uoff_t)xlseek(fd, 0, SEEK_END) / 1024;
245 bytes_per_inode = 16384;
246 if (kilobytes < 512*1024)
247 bytes_per_inode = 4096;
248 if (kilobytes < 3*1024)
249 bytes_per_inode = 8192;
251 bytes_per_inode = bpi;
253 // Determine block size and inode size
254 // block size is a multiple of 1024
255 // inode size is a multiple of 128
257 inodesize = sizeof(struct ext2_inode); // 128
258 if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
262 if (EXT2_MAX_BLOCK_SIZE > 4096) {
263 // kilobytes >> 22 == size in 4gigabyte chunks.
264 // if size >= 16k gigs, blocksize must be increased.
265 // Try "mke2fs -F image $((16 * 1024*1024*1024))"
266 while ((kilobytes >> 22) >= blocksize)
271 if (blocksize < EXT2_MIN_BLOCK_SIZE
272 || blocksize > EXT2_MAX_BLOCK_SIZE
273 || (blocksize & (blocksize - 1)) // not power of 2
275 bb_error_msg_and_die("blocksize %u is bad", blocksize);
277 // Do we have custom inode size?
279 if (user_inodesize < sizeof(*inode)
280 || user_inodesize > blocksize
281 || (user_inodesize & (user_inodesize - 1)) // not power of 2
283 bb_error_msg("-%c is bad", 'I');
285 inodesize = user_inodesize;
289 if ((int32_t)bytes_per_inode < blocksize)
290 bb_error_msg_and_die("-%c is bad", 'i');
291 // number of bits in one block, i.e. 8*blocksize
292 #define blocks_per_group (8 * blocksize)
293 first_block = (EXT2_MIN_BLOCK_SIZE == blocksize);
294 blocksize_log2 = int_log2(blocksize);
296 // Determine number of blocks
297 kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
299 if (nblocks != kilobytes)
300 bb_error_msg_and_die("block count doesn't fit in 32 bits");
301 #define kilobytes kilobytes_unused_after_this
302 // Experimentally, standard mke2fs won't work on images smaller than 60k
304 bb_error_msg_and_die("need >= 60 blocks");
306 // How many reserved blocks?
307 if (reserved_percent > 50)
308 bb_error_msg_and_die("-%c is bad", 'm');
309 nreserved = (uint64_t)nblocks * reserved_percent / 100;
311 // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
312 nblocks_full = nblocks;
314 // If last block group is too small, nblocks may be decreased in order
315 // to discard it, and control returns here to recalculate some
317 // Note: blocksize and bytes_per_inode are never recalculated.
319 // N.B. a block group can have no more than blocks_per_group blocks
320 ngroups = div_roundup(nblocks - first_block, blocks_per_group);
322 group_desc_blocks = div_roundup(ngroups, blocksize / sizeof(*gd));
323 // TODO: reserved blocks must be marked as such in the bitmaps,
324 // or resulting filesystem is corrupt
325 if (ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT) {
327 * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
329 * The absolute maximum number of GDT blocks we can reserve is determined by
330 * the number of block pointers that can fit into a single block.
331 * We set it at 1024x the current filesystem size, or
332 * the upper block count limit (2^32), whichever is lower.
334 uint32_t reserved_group_desc_blocks = 0xFFFFFFFF; // maximum block number
335 if (nblocks < reserved_group_desc_blocks / 1024)
336 reserved_group_desc_blocks = nblocks * 1024;
337 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks - first_block, blocks_per_group);
338 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks, blocksize / sizeof(*gd)) - group_desc_blocks;
339 if (reserved_group_desc_blocks > blocksize / sizeof(uint32_t))
340 reserved_group_desc_blocks = blocksize / sizeof(uint32_t);
341 //TODO: STORE_LE(sb->s_reserved_gdt_blocks, reserved_group_desc_blocks);
342 group_desc_blocks += reserved_group_desc_blocks;
346 // N.B. e2fsprogs does as follows!
347 uint32_t overhead, remainder;
348 // ninodes is the max number of inodes in this filesystem
349 uint32_t ninodes = ((uint64_t) nblocks_full * blocksize) / bytes_per_inode;
350 if (ninodes < EXT2_GOOD_OLD_FIRST_INO+1)
351 ninodes = EXT2_GOOD_OLD_FIRST_INO+1;
352 inodes_per_group = div_roundup(ninodes, ngroups);
353 // minimum number because the first EXT2_GOOD_OLD_FIRST_INO-1 are reserved
354 if (inodes_per_group < 16)
355 inodes_per_group = 16;
356 // a block group can't have more inodes than blocks
357 if (inodes_per_group > blocks_per_group)
358 inodes_per_group = blocks_per_group;
359 // adjust inodes per group so they completely fill the inode table blocks in the descriptor
360 inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
361 // make sure the number of inodes per group is a multiple of 8
362 inodes_per_group &= ~7;
363 inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
365 // to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
366 // and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
367 /* Or e2fsprogs comment verbatim (what does it mean?):
368 * Ensure that lost+found is at least 2 blocks, so we always
369 * test large empty blocks for big-block filesystems. */
370 lost_and_found_blocks = MIN(EXT2_NDIR_BLOCKS, 16 >> (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE));
372 // the last group needs more attention: isn't it too small for possible overhead?
373 overhead = (has_super(ngroups - 1) ? (1/*sb*/ + group_desc_blocks) : 0) + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
374 remainder = (nblocks - first_block) % blocks_per_group;
375 ////can't happen, nblocks >= 60 guarantees this
376 ////if ((1 == ngroups)
378 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
380 //// bb_error_msg_and_die("way small device");
383 // Standard mke2fs uses 50. Looks like a bug in our calculation
384 // of "remainder" or "overhead" - we don't match standard mke2fs
385 // when we transition from one group to two groups
386 // (a bit after 8M image size), but it works for two->three groups
387 // transition (at 16M).
388 if (remainder && (remainder < overhead + 50)) {
389 //bb_info_msg("CHOP[%u]", remainder);
390 nblocks -= remainder;
395 if (nblocks_full - nblocks)
396 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
398 "Filesystem label=%s\n"
400 "Block size=%u (log=%u)\n"
401 "Fragment size=%u (log=%u)\n"
402 "%u inodes, %u blocks\n"
403 "%u blocks (%u%%) reserved for the super user\n"
404 "First data block=%u\n"
405 "Maximum filesystem blocks=%u\n"
407 "%u blocks per group, %u fragments per group\n"
408 "%u inodes per group"
410 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
411 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
412 , inodes_per_group * ngroups, nblocks
413 , nreserved, reserved_percent
415 , group_desc_blocks * (blocksize / sizeof(*gd)) * blocks_per_group
417 , blocks_per_group, blocks_per_group
421 const char *fmt = "\nSuperblock backups stored on blocks:\n"
424 for (i = 1; i < ngroups; i++) {
425 pos += blocks_per_group;
427 printf(fmt, (unsigned)pos);
435 if (ENABLE_FEATURE_CLEAN_UP)
440 // TODO: 3/5 refuse if mounted
441 // TODO: 4/5 compat options
442 // TODO: 1/5 sanity checks
443 // TODO: 0/5 more verbose error messages
444 // TODO: 4/5 bigendianness: recheck, wait for ARM reporters
445 // TODO: 2/5 reserved GDT: how to mark but not allocate?
446 // TODO: 3/5 dir_index?
448 // fill the superblock
450 STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
451 STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
452 STORE_LE(sb->s_inode_size, inodesize);
453 // set "Required extra isize" and "Desired extra isize" fields to 28
454 if (inodesize != sizeof(*inode))
455 STORE_LE(sb->s_reserved[21], 0x001C001C);
456 STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
457 STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
458 STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
459 // first 1024 bytes of the device are for boot record. If block size is 1024 bytes, then
460 // the first block is 1, otherwise 0
461 STORE_LE(sb->s_first_data_block, first_block);
462 // block and inode bitmaps occupy no more than one block, so maximum number of blocks is
463 STORE_LE(sb->s_blocks_per_group, blocks_per_group);
464 STORE_LE(sb->s_frags_per_group, blocks_per_group);
466 STORE_LE(sb->s_blocks_count, nblocks);
467 // reserve blocks for superuser
468 STORE_LE(sb->s_r_blocks_count, nreserved);
470 STORE_LE(sb->s_inodes_per_group, inodes_per_group);
471 STORE_LE(sb->s_inodes_count, inodes_per_group * ngroups);
472 STORE_LE(sb->s_free_inodes_count, inodes_per_group * ngroups - EXT2_GOOD_OLD_FIRST_INO);
474 timestamp = time(NULL);
475 STORE_LE(sb->s_mkfs_time, timestamp);
476 STORE_LE(sb->s_wtime, timestamp);
477 STORE_LE(sb->s_lastcheck, timestamp);
478 // misc. Values are chosen to match mke2fs 1.41.9
479 STORE_LE(sb->s_state, 1); // TODO: what's 1?
480 STORE_LE(sb->s_creator_os, EXT2_OS_LINUX);
481 STORE_LE(sb->s_checkinterval, 24*60*60 * 180); // 180 days
482 STORE_LE(sb->s_errors, EXT2_ERRORS_DEFAULT);
483 // mke2fs 1.41.9 also sets EXT3_FEATURE_COMPAT_RESIZE_INODE
484 // and if >= 0.5GB, EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
485 // we use values which match "mke2fs -O ^resize_inode":
486 // in this case 1.41.9 never sets EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
487 STORE_LE(sb->s_feature_compat, EXT2_FEATURE_COMPAT_SUPP
488 | (EXT2_FEATURE_COMPAT_RESIZE_INO * ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT)
489 | (EXT2_FEATURE_COMPAT_DIR_INDEX * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX)
491 STORE_LE(sb->s_feature_incompat, EXT2_FEATURE_INCOMPAT_FILETYPE);
492 STORE_LE(sb->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
493 STORE_LE(sb->s_flags, EXT2_FLAGS_UNSIGNED_HASH * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX);
494 generate_uuid(sb->s_uuid);
495 if (ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX) {
496 STORE_LE(sb->s_def_hash_version, EXT2_HASH_HALF_MD4);
497 generate_uuid((uint8_t *)sb->s_hash_seed);
500 * From e2fsprogs: add "jitter" to the superblock's check interval so that we
501 * don't check all the filesystems at the same time. We use a
502 * kludgy hack of using the UUID to derive a random jitter value.
504 STORE_LE(sb->s_max_mnt_count,
505 EXT2_DFL_MAX_MNT_COUNT
506 + (sb->s_uuid[ARRAY_SIZE(sb->s_uuid)-1] % EXT2_DFL_MAX_MNT_COUNT));
509 safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
511 // calculate filesystem skeleton structures
512 gd = xzalloc(group_desc_blocks * blocksize);
513 buf = xmalloc(blocksize);
514 sb->s_free_blocks_count = 0;
515 for (i = 0, pos = first_block, n = nblocks - first_block;
517 i++, pos += blocks_per_group, n -= blocks_per_group
519 uint32_t overhead = pos + (has_super(i) ? (1/*sb*/ + group_desc_blocks) : 0);
520 uint32_t free_blocks;
521 // fill group descriptors
522 STORE_LE(gd[i].bg_block_bitmap, overhead + 0);
523 STORE_LE(gd[i].bg_inode_bitmap, overhead + 1);
524 STORE_LE(gd[i].bg_inode_table, overhead + 2);
525 overhead = overhead - pos + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
526 gd[i].bg_free_inodes_count = inodes_per_group;
527 //STORE_LE(gd[i].bg_used_dirs_count, 0);
528 // N.B. both "/" and "/lost+found" are within the first block group
529 // "/" occupies 1 block, "/lost+found" occupies lost_and_found_blocks...
531 // ... thus increased overhead for the first block group ...
532 overhead += 1 + lost_and_found_blocks;
533 // ... and 2 used directories
534 STORE_LE(gd[i].bg_used_dirs_count, 2);
535 // well known reserved inodes belong to the first block too
536 gd[i].bg_free_inodes_count -= EXT2_GOOD_OLD_FIRST_INO;
539 // cache free block count of the group
540 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
542 // mark preallocated blocks as allocated
543 //bb_info_msg("ALLOC: [%u][%u][%u]", blocksize, overhead, blocks_per_group - (free_blocks + overhead));
544 allocate(buf, blocksize,
545 // reserve "overhead" blocks
547 // mark unused trailing blocks
548 blocks_per_group - (free_blocks + overhead)
551 PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
552 STORE_LE(gd[i].bg_free_blocks_count, free_blocks);
554 // mark preallocated inodes as allocated
555 allocate(buf, blocksize,
556 // mark reserved inodes
557 inodes_per_group - gd[i].bg_free_inodes_count,
558 // mark unused trailing inodes
559 blocks_per_group - inodes_per_group
562 //PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
563 //but it's right after block bitmap, so we can just:
564 xwrite(fd, buf, blocksize);
565 STORE_LE(gd[i].bg_free_inodes_count, gd[i].bg_free_inodes_count);
567 // count overall free blocks
568 sb->s_free_blocks_count += free_blocks;
570 STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
572 // dump filesystem skeleton structures
573 // printf("Writing superblocks and filesystem accounting information: ");
574 for (i = 0, pos = first_block; i < ngroups; i++, pos += blocks_per_group) {
575 // dump superblock and group descriptors and their backups
577 // N.B. 1024 byte blocks are special
578 PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
580 PUT(((uint64_t)pos * blocksize) + blocksize,
581 gd, group_desc_blocks * blocksize);
586 memset(buf, 0, blocksize);
587 PUT(0, buf, 1024); // N.B. 1024 <= blocksize, so buf[0..1023] contains zeros
589 for (i = 0; i < ngroups; ++i)
590 for (n = 0; n < inode_table_blocks; ++n)
591 PUT((uint64_t)(FETCH_LE32(gd[i].bg_inode_table) + n) * blocksize,
594 // prepare directory inode
595 inode = (struct ext2_inode *)buf;
596 STORE_LE(inode->i_mode, S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
597 STORE_LE(inode->i_mtime, timestamp);
598 STORE_LE(inode->i_atime, timestamp);
599 STORE_LE(inode->i_ctime, timestamp);
600 STORE_LE(inode->i_size, blocksize);
601 // inode->i_blocks stores the number of 512 byte data blocks
602 // (512, because it goes directly to struct stat without scaling)
603 STORE_LE(inode->i_blocks, blocksize / 512);
605 // dump root dir inode
606 STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
607 STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
608 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
611 // dump lost+found dir inode
612 STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
613 STORE_LE(inode->i_size, lost_and_found_blocks * blocksize);
614 STORE_LE(inode->i_blocks, (lost_and_found_blocks * blocksize) / 512);
615 n = FETCH_LE32(inode->i_block[0]) + 1;
616 for (i = 0; i < lost_and_found_blocks; ++i)
617 STORE_LE(inode->i_block[i], i + n); // use next block
618 //bb_info_msg("LAST BLOCK USED[%u]", i + n);
619 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
623 memset(buf, 0, blocksize);
624 dir = (struct ext2_dir *)buf;
626 // dump 2nd+ blocks of "/lost+found"
627 STORE_LE(dir->rec_len1, blocksize); // e2fsck 1.41.4 compat (1.41.9 does not need this)
628 for (i = 1; i < lost_and_found_blocks; ++i)
629 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1+i) * blocksize,
632 // dump 1st block of "/lost+found"
633 STORE_LE(dir->inode1, EXT2_GOOD_OLD_FIRST_INO);
634 STORE_LE(dir->rec_len1, 12);
635 STORE_LE(dir->name_len1, 1);
636 STORE_LE(dir->file_type1, EXT2_FT_DIR);
638 STORE_LE(dir->inode2, EXT2_ROOT_INO);
639 STORE_LE(dir->rec_len2, blocksize - 12);
640 STORE_LE(dir->name_len2, 2);
641 STORE_LE(dir->file_type2, EXT2_FT_DIR);
642 dir->name2[0] = '.'; dir->name2[1] = '.';
643 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1) * blocksize, buf, blocksize);
645 // dump root dir block
646 STORE_LE(dir->inode1, EXT2_ROOT_INO);
647 STORE_LE(dir->rec_len2, 12);
648 STORE_LE(dir->inode3, EXT2_GOOD_OLD_FIRST_INO);
649 STORE_LE(dir->rec_len3, blocksize - 12 - 12);
650 STORE_LE(dir->name_len3, 10);
651 STORE_LE(dir->file_type3, EXT2_FT_DIR);
652 strcpy(dir->name3, "lost+found");
653 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 0) * blocksize, buf, blocksize);
656 if (ENABLE_FEATURE_CLEAN_UP) {