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