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>
14 #define ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT 0
15 #define ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX 1
18 #define s_reserved_gdt_blocks s_padding1
19 #define s_mkfs_time s_reserved[0]
20 #define s_flags s_reserved[22]
22 #define EXT2_HASH_HALF_MD4 1
23 #define EXT2_FLAGS_SIGNED_HASH 0x0001
24 #define EXT2_FLAGS_UNSIGNED_HASH 0x0002
27 char BUG_wrong_field_size(void);
28 #define STORE_LE(field, value) \
30 if (sizeof(field) == 4) \
31 field = SWAP_LE32(value); \
32 else if (sizeof(field) == 2) \
33 field = SWAP_LE16(value); \
34 else if (sizeof(field) == 1) \
37 BUG_wrong_field_size(); \
40 #define FETCH_LE32(field) \
41 (sizeof(field) == 4 ? SWAP_LE32(field) : BUG_wrong_field_size())
43 // All fields are little-endian
62 static unsigned int_log2(unsigned arg)
65 while ((arg >>= 1) != 0)
70 // taken from mkfs_minix.c. libbb candidate?
71 // "uint32_t size", since we never use it for anything >32 bits
72 static uint32_t div_roundup(uint32_t size, uint32_t n)
75 uint32_t res = size / n;
81 static void allocate(uint8_t *bitmap, uint32_t blocksize, uint32_t start, uint32_t end)
85 //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)));
86 memset(bitmap, 0, blocksize);
88 memset(bitmap, 0xFF, i);
89 bitmap[i] = (1 << (start & 7)) - 1; //0..7 => 00000000..01111111
91 bitmap[blocksize - i - 1] |= 0x7F00 >> (end & 7); //0..7 => 00000000..11111110
92 memset(bitmap + blocksize - i, 0xFF, i); // N.B. no overflow here!
95 static uint32_t has_super(uint32_t x)
97 // 0, 1 and powers of 3, 5, 7 up to 2^32 limit
98 static const uint32_t supers[] = {
99 0, 1, 3, 5, 7, 9, 25, 27, 49, 81, 125, 243, 343, 625, 729,
100 2187, 2401, 3125, 6561, 15625, 16807, 19683, 59049, 78125,
101 117649, 177147, 390625, 531441, 823543, 1594323, 1953125,
102 4782969, 5764801, 9765625, 14348907, 40353607, 43046721,
103 48828125, 129140163, 244140625, 282475249, 387420489,
104 1162261467, 1220703125, 1977326743, 3486784401/* >2^31 */,
106 const uint32_t *sp = supers + ARRAY_SIZE(supers);
116 #define fd 3 /* predefined output descriptor */
118 static void PUT(uint64_t off, void *buf, uint32_t size)
120 // bb_info_msg("PUT[%llu]:[%u]", off, size);
121 xlseek(fd, off, SEEK_SET);
122 xwrite(fd, buf, size);
125 // 128 and 256-byte inodes:
126 // 128-byte inode is described by struct ext2_inode.
127 // 256-byte one just has these fields appended:
128 // __u16 i_extra_isize;
130 // __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
131 // __u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */
132 // __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
133 // __u32 i_crtime; /* File creation time */
134 // __u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/
135 // __u32 i_version_hi; /* high 32 bits for 64-bit version */
136 // the rest is padding.
138 // linux/ext2_fs.h has "#define i_size_high i_dir_acl" which suggests that even
139 // 128-byte inode is capable of describing large files (i_dir_acl is meaningful
140 // only for directories, which never need i_size_high).
142 // Standard mke2fs creates a filesystem with 256-byte inodes if it is
143 // bigger than 0.5GB. So far, we do not do this.
145 // Standard mke2fs 1.41.9:
146 // Usage: mke2fs [-c|-l filename] [-b block-size] [-f fragment-size]
147 // [-i bytes-per-inode] [-I inode-size] [-J journal-options]
148 // [-G meta group size] [-N number-of-inodes]
149 // [-m reserved-blocks-percentage] [-o creator-os]
150 // [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
151 // [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
152 // [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
154 // Options not commented below are taken but silently ignored:
158 OPT_b = 1 << 2, // block size, in bytes
160 OPT_i = 1 << 4, // bytes per inode
161 OPT_I = 1 << 5, // custom inode size, in bytes
165 OPT_m = 1 << 9, // percentage of blocks reserved for superuser
168 OPT_L = 1 << 12, // label
176 OPT_n = 1 << 20, // dry run: do not write anything
181 //OPT_V = 1 << 25, // -V version. bbox applets don't support that
184 int mkfs_ext2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
185 int mkfs_ext2_main(int argc UNUSED_PARAM, char **argv)
189 unsigned blocksize, blocksize_log2;
190 unsigned inodesize, user_inodesize;
191 unsigned reserved_percent = 5;
192 unsigned long long kilobytes;
193 uint32_t nblocks, nblocks_full;
196 uint32_t bytes_per_inode;
197 uint32_t first_block;
198 uint32_t inodes_per_group;
199 uint32_t group_desc_blocks;
200 uint32_t inode_table_blocks;
201 uint32_t lost_and_found_blocks;
203 const char *label = "";
205 struct ext2_super_block *sb; // superblock
206 struct ext2_group_desc *gd; // group descriptors
207 struct ext2_inode *inode;
208 struct ext2_dir *dir;
211 // using global "option_mask32" instead of local "opts":
212 // we are register starved here
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 // open the device, check the device is a block device
220 xmove_fd(xopen(argv[0], O_WRONLY), fd);
222 if (!S_ISBLK(st.st_mode) && !(option_mask32 & 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 is mounted!
228 if (find_mount_point(argv[0], 0))
229 bb_error_msg_and_die("can't format mounted filesystem");
231 // get size in kbytes
232 kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
234 bytes_per_inode = 16384;
235 if (kilobytes < 512*1024)
236 bytes_per_inode = 4096;
237 if (kilobytes < 3*1024)
238 bytes_per_inode = 8192;
239 if (option_mask32 & OPT_i)
240 bytes_per_inode = bpi;
242 // Determine block size and inode size
243 // block size is a multiple of 1024
244 // inode size is a multiple of 128
246 inodesize = sizeof(struct ext2_inode); // 128
247 if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
251 if (EXT2_MAX_BLOCK_SIZE > 4096) {
252 // kilobytes >> 22 == size in 4gigabyte chunks.
253 // if size >= 16k gigs, blocksize must be increased.
254 // Try "mke2fs -F image $((16 * 1024*1024*1024))"
255 while ((kilobytes >> 22) >= blocksize)
258 if (option_mask32 & OPT_b)
260 if (blocksize < EXT2_MIN_BLOCK_SIZE
261 || blocksize > EXT2_MAX_BLOCK_SIZE
262 || (blocksize & (blocksize - 1)) // not power of 2
264 bb_error_msg_and_die("blocksize %u is bad", blocksize);
266 // Do we have custom inode size?
267 if (option_mask32 & OPT_I) {
268 if (user_inodesize < sizeof(*inode)
269 || user_inodesize > blocksize
270 || (user_inodesize & (user_inodesize - 1)) // not power of 2
272 bb_error_msg("-%c is bad", 'I');
274 inodesize = user_inodesize;
278 if ((int32_t)bytes_per_inode < blocksize)
279 bb_error_msg_and_die("-%c is bad", 'i');
280 // number of bits in one block, i.e. 8*blocksize
281 #define blocks_per_group (8 * blocksize)
282 first_block = (EXT2_MIN_BLOCK_SIZE == blocksize);
283 blocksize_log2 = int_log2(blocksize);
285 // Determine number of blocks
286 kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
288 if (nblocks != kilobytes)
289 bb_error_msg_and_die("block count doesn't fit in 32 bits");
290 #define kilobytes kilobytes_unused_after_this
291 // Experimentally, standard mke2fs won't work on images smaller than 60k
293 bb_error_msg_and_die("need >= 60 blocks");
295 // How many reserved blocks?
296 if (reserved_percent > 50)
297 bb_error_msg_and_die("-%c is bad", 'm');
298 nreserved = (uint64_t)nblocks * reserved_percent / 100;
300 // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
301 nblocks_full = nblocks;
303 // If last block group is too small, nblocks may be decreased in order
304 // to discard it, and control returns here to recalculate some
306 // Note: blocksize and bytes_per_inode are never recalculated.
308 // N.B. a block group can have no more than blocks_per_group blocks
309 ngroups = div_roundup(nblocks - first_block, blocks_per_group);
311 group_desc_blocks = div_roundup(ngroups, blocksize / sizeof(*gd));
312 // TODO: reserved blocks must be marked as such in the bitmaps,
313 // or resulting filesystem is corrupt
314 if (ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT) {
316 * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
318 * The absolute maximum number of GDT blocks we can reserve is determined by
319 * the number of block pointers that can fit into a single block.
320 * We set it at 1024x the current filesystem size, or
321 * the upper block count limit (2^32), whichever is lower.
323 uint32_t reserved_group_desc_blocks = 0xFFFFFFFF; // maximum block number
324 if (nblocks < reserved_group_desc_blocks / 1024)
325 reserved_group_desc_blocks = nblocks * 1024;
326 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks - first_block, blocks_per_group);
327 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks, blocksize / sizeof(*gd)) - group_desc_blocks;
328 if (reserved_group_desc_blocks > blocksize / sizeof(uint32_t))
329 reserved_group_desc_blocks = blocksize / sizeof(uint32_t);
330 //TODO: STORE_LE(sb->s_reserved_gdt_blocks, reserved_group_desc_blocks);
331 group_desc_blocks += reserved_group_desc_blocks;
335 // N.B. e2fsprogs does as follows!
336 uint32_t overhead, remainder;
337 // ninodes is the max number of inodes in this filesystem
338 uint32_t ninodes = ((uint64_t) nblocks_full * blocksize) / bytes_per_inode;
339 if (ninodes < EXT2_GOOD_OLD_FIRST_INO+1)
340 ninodes = EXT2_GOOD_OLD_FIRST_INO+1;
341 inodes_per_group = div_roundup(ninodes, ngroups);
342 // minimum number because the first EXT2_GOOD_OLD_FIRST_INO-1 are reserved
343 if (inodes_per_group < 16)
344 inodes_per_group = 16;
345 // a block group can't have more inodes than blocks
346 if (inodes_per_group > blocks_per_group)
347 inodes_per_group = blocks_per_group;
348 // adjust inodes per group so they completely fill the inode table blocks in the descriptor
349 inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
350 // make sure the number of inodes per group is a multiple of 8
351 inodes_per_group &= ~7;
352 inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
354 // to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
355 // and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
356 /* Or e2fsprogs comment verbatim (what does it mean?):
357 * Ensure that lost+found is at least 2 blocks, so we always
358 * test large empty blocks for big-block filesystems. */
359 lost_and_found_blocks = MIN(EXT2_NDIR_BLOCKS, 16 >> (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE));
361 // the last group needs more attention: isn't it too small for possible overhead?
362 overhead = (has_super(ngroups - 1) ? (1/*sb*/ + group_desc_blocks) : 0) + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
363 remainder = (nblocks - first_block) % blocks_per_group;
364 ////can't happen, nblocks >= 60 guarantees this
365 ////if ((1 == ngroups)
367 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
369 //// bb_error_msg_and_die("way small device");
372 // Standard mke2fs uses 50. Looks like a bug in our calculation
373 // of "remainder" or "overhead" - we don't match standard mke2fs
374 // when we transition from one group to two groups
375 // (a bit after 8M image size), but it works for two->three groups
376 // transition (at 16M).
377 if (remainder && (remainder < overhead + 50)) {
378 //bb_info_msg("CHOP[%u]", remainder);
379 nblocks -= remainder;
384 if (nblocks_full - nblocks)
385 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
387 "Filesystem label=%s\n"
389 "Block size=%u (log=%u)\n"
390 "Fragment size=%u (log=%u)\n"
391 "%u inodes, %u blocks\n"
392 "%u blocks (%u%%) reserved for the super user\n"
393 "First data block=%u\n"
394 "Maximum filesystem blocks=%u\n"
396 "%u blocks per group, %u fragments per group\n"
397 "%u inodes per group"
399 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
400 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
401 , inodes_per_group * ngroups, nblocks
402 , nreserved, reserved_percent
404 , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
406 , blocks_per_group, blocks_per_group
410 const char *fmt = "\nSuperblock backups stored on blocks:\n"
413 for (i = 1; i < ngroups; i++) {
414 pos += blocks_per_group;
416 printf(fmt, (unsigned)pos);
423 if (option_mask32 & OPT_n) {
424 if (ENABLE_FEATURE_CLEAN_UP)
429 // TODO: 3/5 refuse if mounted
430 // TODO: 4/5 compat options
431 // TODO: 1/5 sanity checks
432 // TODO: 0/5 more verbose error messages
433 // TODO: 4/5 bigendianness: recheck, wait for ARM reporters
434 // TODO: 2/5 reserved GDT: how to mark but not allocate?
435 // TODO: 3/5 dir_index?
437 // fill the superblock
439 STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
440 STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
441 STORE_LE(sb->s_inode_size, inodesize);
442 // set "Required extra isize" and "Desired extra isize" fields to 28
443 if (inodesize != sizeof(*inode))
444 STORE_LE(sb->s_reserved[21], 0x001C001C);
445 STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
446 STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
447 STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
448 // first 1024 bytes of the device are for boot record. If block size is 1024 bytes, then
449 // the first block is 1, otherwise 0
450 STORE_LE(sb->s_first_data_block, first_block);
451 // block and inode bitmaps occupy no more than one block, so maximum number of blocks is
452 STORE_LE(sb->s_blocks_per_group, blocks_per_group);
453 STORE_LE(sb->s_frags_per_group, blocks_per_group);
455 STORE_LE(sb->s_blocks_count, nblocks);
456 // reserve blocks for superuser
457 STORE_LE(sb->s_r_blocks_count, nreserved);
459 STORE_LE(sb->s_inodes_per_group, inodes_per_group);
460 STORE_LE(sb->s_inodes_count, inodes_per_group * ngroups);
461 STORE_LE(sb->s_free_inodes_count, inodes_per_group * ngroups - EXT2_GOOD_OLD_FIRST_INO);
463 timestamp = time(NULL);
464 STORE_LE(sb->s_mkfs_time, timestamp);
465 STORE_LE(sb->s_wtime, timestamp);
466 STORE_LE(sb->s_lastcheck, timestamp);
467 // misc. Values are chosen to match mke2fs 1.41.9
468 STORE_LE(sb->s_state, 1); // TODO: what's 1?
469 STORE_LE(sb->s_creator_os, EXT2_OS_LINUX);
470 STORE_LE(sb->s_checkinterval, 24*60*60 * 180); // 180 days
471 STORE_LE(sb->s_errors, EXT2_ERRORS_DEFAULT);
472 // mke2fs 1.41.9 also sets EXT3_FEATURE_COMPAT_RESIZE_INODE
473 // and if >= 0.5GB, EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
474 // we use values which match "mke2fs -O ^resize_inode":
475 // in this case 1.41.9 never sets EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
476 STORE_LE(sb->s_feature_compat, EXT2_FEATURE_COMPAT_SUPP
477 | (EXT2_FEATURE_COMPAT_RESIZE_INO * ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT)
478 | (EXT2_FEATURE_COMPAT_DIR_INDEX * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX)
480 STORE_LE(sb->s_feature_incompat, EXT2_FEATURE_INCOMPAT_FILETYPE);
481 STORE_LE(sb->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
482 STORE_LE(sb->s_flags, EXT2_FLAGS_UNSIGNED_HASH * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX);
483 generate_uuid(sb->s_uuid);
484 if (ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX) {
485 STORE_LE(sb->s_def_hash_version, EXT2_HASH_HALF_MD4);
486 generate_uuid((uint8_t *)sb->s_hash_seed);
489 * From e2fsprogs: add "jitter" to the superblock's check interval so that we
490 * don't check all the filesystems at the same time. We use a
491 * kludgy hack of using the UUID to derive a random jitter value.
493 STORE_LE(sb->s_max_mnt_count,
494 EXT2_DFL_MAX_MNT_COUNT
495 + (sb->s_uuid[ARRAY_SIZE(sb->s_uuid)-1] % EXT2_DFL_MAX_MNT_COUNT));
498 safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
500 // calculate filesystem skeleton structures
501 gd = xzalloc(group_desc_blocks * blocksize);
502 buf = xmalloc(blocksize);
503 sb->s_free_blocks_count = 0;
504 for (i = 0, pos = first_block, n = nblocks - first_block;
506 i++, pos += blocks_per_group, n -= blocks_per_group
508 uint32_t overhead = pos + (has_super(i) ? (1/*sb*/ + group_desc_blocks) : 0);
509 uint32_t free_blocks;
510 // fill group descriptors
511 STORE_LE(gd[i].bg_block_bitmap, overhead + 0);
512 STORE_LE(gd[i].bg_inode_bitmap, overhead + 1);
513 STORE_LE(gd[i].bg_inode_table, overhead + 2);
514 overhead = overhead - pos + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
515 gd[i].bg_free_inodes_count = inodes_per_group;
516 //STORE_LE(gd[i].bg_used_dirs_count, 0);
517 // N.B. both "/" and "/lost+found" are within the first block group
518 // "/" occupies 1 block, "/lost+found" occupies lost_and_found_blocks...
520 // ... thus increased overhead for the first block group ...
521 overhead += 1 + lost_and_found_blocks;
522 // ... and 2 used directories
523 STORE_LE(gd[i].bg_used_dirs_count, 2);
524 // well known reserved inodes belong to the first block too
525 gd[i].bg_free_inodes_count -= EXT2_GOOD_OLD_FIRST_INO;
528 // cache free block count of the group
529 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
531 // mark preallocated blocks as allocated
532 //bb_info_msg("ALLOC: [%u][%u][%u]", blocksize, overhead, blocks_per_group - (free_blocks + overhead));
533 allocate(buf, blocksize,
534 // reserve "overhead" blocks
536 // mark unused trailing blocks
537 blocks_per_group - (free_blocks + overhead)
540 PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
541 STORE_LE(gd[i].bg_free_blocks_count, free_blocks);
543 // mark preallocated inodes as allocated
544 allocate(buf, blocksize,
545 // mark reserved inodes
546 inodes_per_group - gd[i].bg_free_inodes_count,
547 // mark unused trailing inodes
548 blocks_per_group - inodes_per_group
551 //PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
552 //but it's right after block bitmap, so we can just:
553 xwrite(fd, buf, blocksize);
554 STORE_LE(gd[i].bg_free_inodes_count, gd[i].bg_free_inodes_count);
556 // count overall free blocks
557 sb->s_free_blocks_count += free_blocks;
559 STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
561 // dump filesystem skeleton structures
562 // printf("Writing superblocks and filesystem accounting information: ");
563 for (i = 0, pos = first_block; i < ngroups; i++, pos += blocks_per_group) {
564 // dump superblock and group descriptors and their backups
566 // N.B. 1024 byte blocks are special
567 PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
569 PUT(((uint64_t)pos * blocksize) + blocksize,
570 gd, group_desc_blocks * blocksize);
575 memset(buf, 0, blocksize);
576 PUT(0, buf, 1024); // N.B. 1024 <= blocksize, so buf[0..1023] contains zeros
578 for (i = 0; i < ngroups; ++i)
579 for (n = 0; n < inode_table_blocks; ++n)
580 PUT((uint64_t)(FETCH_LE32(gd[i].bg_inode_table) + n) * blocksize,
583 // prepare directory inode
584 inode = (struct ext2_inode *)buf;
585 STORE_LE(inode->i_mode, S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
586 STORE_LE(inode->i_mtime, timestamp);
587 STORE_LE(inode->i_atime, timestamp);
588 STORE_LE(inode->i_ctime, timestamp);
589 STORE_LE(inode->i_size, blocksize);
590 // inode->i_blocks stores the number of 512 byte data blocks
591 // (512, because it goes directly to struct stat without scaling)
592 STORE_LE(inode->i_blocks, blocksize / 512);
594 // dump root dir inode
595 STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
596 STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
597 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
600 // dump lost+found dir inode
601 STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
602 STORE_LE(inode->i_size, lost_and_found_blocks * blocksize);
603 STORE_LE(inode->i_blocks, (lost_and_found_blocks * blocksize) / 512);
604 n = FETCH_LE32(inode->i_block[0]) + 1;
605 for (i = 0; i < lost_and_found_blocks; ++i)
606 STORE_LE(inode->i_block[i], i + n); // use next block
607 //bb_info_msg("LAST BLOCK USED[%u]", i + n);
608 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
612 memset(buf, 0, blocksize);
613 dir = (struct ext2_dir *)buf;
615 // dump 2nd+ blocks of "/lost+found"
616 STORE_LE(dir->rec_len1, blocksize); // e2fsck 1.41.4 compat (1.41.9 does not need this)
617 for (i = 1; i < lost_and_found_blocks; ++i)
618 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1+i) * blocksize,
621 // dump 1st block of "/lost+found"
622 STORE_LE(dir->inode1, EXT2_GOOD_OLD_FIRST_INO);
623 STORE_LE(dir->rec_len1, 12);
624 STORE_LE(dir->name_len1, 1);
625 STORE_LE(dir->file_type1, EXT2_FT_DIR);
627 STORE_LE(dir->inode2, EXT2_ROOT_INO);
628 STORE_LE(dir->rec_len2, blocksize - 12);
629 STORE_LE(dir->name_len2, 2);
630 STORE_LE(dir->file_type2, EXT2_FT_DIR);
631 dir->name2[0] = '.'; dir->name2[1] = '.';
632 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1) * blocksize, buf, blocksize);
634 // dump root dir block
635 STORE_LE(dir->inode1, EXT2_ROOT_INO);
636 STORE_LE(dir->rec_len2, 12);
637 STORE_LE(dir->inode3, EXT2_GOOD_OLD_FIRST_INO);
638 STORE_LE(dir->rec_len3, blocksize - 12 - 12);
639 STORE_LE(dir->name_len3, 10);
640 STORE_LE(dir->file_type3, EXT2_FT_DIR);
641 strcpy(dir->name3, "lost+found");
642 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 0) * blocksize, buf, blocksize);
645 if (ENABLE_FEATURE_CLEAN_UP) {