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