blob: 413e7aa15cd168ea5ecd793ec2c3c5026305f0bb [file] [log] [blame]
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +02001/* 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 *
Denys Vlasenko0ef64bd2010-08-16 20:14:46 +02008 * Licensed under GPLv2, see file LICENSE in this source tree.
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +02009 */
Pere Orga5bc8c002011-04-11 03:29:49 +020010
11//usage:#define mkfs_ext2_trivial_usage
12//usage: "[-Fn] "
13/* //usage: "[-c|-l filename] " */
14//usage: "[-b BLK_SIZE] "
15/* //usage: "[-f fragment-size] [-g blocks-per-group] " */
16//usage: "[-i INODE_RATIO] [-I INODE_SIZE] "
17/* //usage: "[-j] [-J journal-options] [-N number-of-inodes] " */
18//usage: "[-m RESERVED_PERCENT] "
19/* //usage: "[-o creator-os] [-O feature[,...]] [-q] " */
20/* //usage: "[r fs-revision-level] [-E extended-options] [-v] [-F] " */
21//usage: "[-L LABEL] "
22/* //usage: "[-M last-mounted-directory] [-S] [-T filesystem-type] " */
23//usage: "BLOCKDEV [KBYTES]"
24//usage:#define mkfs_ext2_full_usage "\n\n"
25//usage: " -b BLK_SIZE Block size, bytes"
26/* //usage: "\n -c Check device for bad blocks" */
27/* //usage: "\n -E opts Set extended options" */
28/* //usage: "\n -f size Fragment size in bytes" */
29//usage: "\n -F Force"
30/* //usage: "\n -g N Number of blocks in a block group" */
31//usage: "\n -i RATIO Max number of files is filesystem_size / RATIO"
32//usage: "\n -I BYTES Inode size (min 128)"
33/* //usage: "\n -j Create a journal (ext3)" */
34/* //usage: "\n -J opts Set journal options (size/device)" */
35/* //usage: "\n -l file Read bad blocks list from file" */
36//usage: "\n -L LBL Volume label"
37//usage: "\n -m PERCENT Percent of blocks to reserve for admin"
38/* //usage: "\n -M dir Set last mounted directory" */
39//usage: "\n -n Dry run"
40/* //usage: "\n -N N Number of inodes to create" */
41/* //usage: "\n -o os Set the 'creator os' field" */
42/* //usage: "\n -O features Dir_index/filetype/has_journal/journal_dev/sparse_super" */
43/* //usage: "\n -q Quiet" */
44/* //usage: "\n -r rev Set filesystem revision" */
45/* //usage: "\n -S Write superblock and group descriptors only" */
46/* //usage: "\n -T fs-type Set usage type (news/largefile/largefile4)" */
47/* //usage: "\n -v Verbose" */
48
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020049#include "libbb.h"
50#include <linux/fs.h>
Denys Vlasenko176bc342012-04-17 15:06:55 +020051#include "bb_e2fs_defs.h"
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020052
Denys Vlasenkoe4dcba12010-10-28 18:57:19 +020053#define ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT 0
54#define ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX 1
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020055
Denys Vlasenko481ca962009-10-22 00:38:52 +020056#define EXT2_HASH_HALF_MD4 1
57#define EXT2_FLAGS_SIGNED_HASH 0x0001
58#define EXT2_FLAGS_UNSIGNED_HASH 0x0002
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020059
Denys Vlasenko05647b52009-10-20 00:06:03 +020060// storage helpers
61char BUG_wrong_field_size(void);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020062#define STORE_LE(field, value) \
63do { \
64 if (sizeof(field) == 4) \
Denys Vlasenko67743862010-05-09 00:13:40 +020065 field = SWAP_LE32(value); \
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020066 else if (sizeof(field) == 2) \
Denys Vlasenko67743862010-05-09 00:13:40 +020067 field = SWAP_LE16(value); \
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020068 else if (sizeof(field) == 1) \
69 field = (value); \
70 else \
Denys Vlasenko05647b52009-10-20 00:06:03 +020071 BUG_wrong_field_size(); \
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020072} while (0)
73
Denys Vlasenko05647b52009-10-20 00:06:03 +020074#define FETCH_LE32(field) \
Denys Vlasenko67743862010-05-09 00:13:40 +020075 (sizeof(field) == 4 ? SWAP_LE32(field) : BUG_wrong_field_size())
Denys Vlasenko05647b52009-10-20 00:06:03 +020076
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020077// All fields are little-endian
78struct ext2_dir {
79 uint32_t inode1;
80 uint16_t rec_len1;
81 uint8_t name_len1;
82 uint8_t file_type1;
83 char name1[4];
84 uint32_t inode2;
85 uint16_t rec_len2;
86 uint8_t name_len2;
87 uint8_t file_type2;
88 char name2[4];
89 uint32_t inode3;
90 uint16_t rec_len3;
91 uint8_t name_len3;
92 uint8_t file_type3;
93 char name3[12];
94};
95
Denys Vlasenko9c2708e2009-10-17 23:27:29 +020096static unsigned int_log2(unsigned arg)
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020097{
Denys Vlasenko9c2708e2009-10-17 23:27:29 +020098 unsigned r = 0;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +020099 while ((arg >>= 1) != 0)
100 r++;
101 return r;
102}
103
104// taken from mkfs_minix.c. libbb candidate?
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200105// "uint32_t size", since we never use it for anything >32 bits
106static uint32_t div_roundup(uint32_t size, uint32_t n)
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200107{
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200108 // Overflow-resistant
Denys Vlasenko69f2e2c2009-10-20 00:16:24 +0200109 uint32_t res = size / n;
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200110 if (res * n != size)
111 res++;
112 return res;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200113}
114
115static void allocate(uint8_t *bitmap, uint32_t blocksize, uint32_t start, uint32_t end)
116{
117 uint32_t i;
Denys Vlasenkocbeb4522009-10-20 16:21:29 +0200118
Denys Vlasenko76b680c2016-03-30 16:04:37 +0200119//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)));
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200120 memset(bitmap, 0, blocksize);
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200121 i = start / 8;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200122 memset(bitmap, 0xFF, i);
Denys Vlasenkocbeb4522009-10-20 16:21:29 +0200123 bitmap[i] = (1 << (start & 7)) - 1; //0..7 => 00000000..01111111
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200124 i = end / 8;
Denys Vlasenkocbeb4522009-10-20 16:21:29 +0200125 bitmap[blocksize - i - 1] |= 0x7F00 >> (end & 7); //0..7 => 00000000..11111110
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200126 memset(bitmap + blocksize - i, 0xFF, i); // N.B. no overflow here!
127}
128
Denys Vlasenko45887752009-10-17 23:13:31 +0200129static uint32_t has_super(uint32_t x)
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200130{
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200131 // 0, 1 and powers of 3, 5, 7 up to 2^32 limit
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200132 static const uint32_t supers[] = {
133 0, 1, 3, 5, 7, 9, 25, 27, 49, 81, 125, 243, 343, 625, 729,
134 2187, 2401, 3125, 6561, 15625, 16807, 19683, 59049, 78125,
135 117649, 177147, 390625, 531441, 823543, 1594323, 1953125,
136 4782969, 5764801, 9765625, 14348907, 40353607, 43046721,
137 48828125, 129140163, 244140625, 282475249, 387420489,
138 1162261467, 1220703125, 1977326743, 3486784401/* >2^31 */,
139 };
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200140 const uint32_t *sp = supers + ARRAY_SIZE(supers);
Denys Vlasenko7d8ab842009-10-17 23:23:45 +0200141 while (1) {
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200142 sp--;
Denys Vlasenko7d8ab842009-10-17 23:23:45 +0200143 if (x == *sp)
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200144 return 1;
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200145 if (x > *sp)
Denys Vlasenko7d8ab842009-10-17 23:23:45 +0200146 return 0;
Denys Vlasenko7d8ab842009-10-17 23:23:45 +0200147 }
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200148}
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200149
Denys Vlasenko2ee27242009-10-21 11:34:32 +0200150#define fd 3 /* predefined output descriptor */
151
152static void PUT(uint64_t off, void *buf, uint32_t size)
153{
Denys Vlasenko066e76b2016-03-30 16:20:28 +0200154 //bb_error_msg("PUT[%llu]:[%u]", off, size);
Denys Vlasenko2ee27242009-10-21 11:34:32 +0200155 xlseek(fd, off, SEEK_SET);
156 xwrite(fd, buf, size);
157}
158
159// 128 and 256-byte inodes:
160// 128-byte inode is described by struct ext2_inode.
161// 256-byte one just has these fields appended:
162// __u16 i_extra_isize;
163// __u16 i_pad1;
164// __u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
165// __u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */
166// __u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
167// __u32 i_crtime; /* File creation time */
168// __u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/
169// __u32 i_version_hi; /* high 32 bits for 64-bit version */
170// the rest is padding.
171//
172// linux/ext2_fs.h has "#define i_size_high i_dir_acl" which suggests that even
173// 128-byte inode is capable of describing large files (i_dir_acl is meaningful
174// only for directories, which never need i_size_high).
175//
176// Standard mke2fs creates a filesystem with 256-byte inodes if it is
Denys Vlasenko8f599f92010-06-18 12:40:57 +0200177// bigger than 0.5GB.
Denys Vlasenko2ee27242009-10-21 11:34:32 +0200178
179// Standard mke2fs 1.41.9:
180// Usage: mke2fs [-c|-l filename] [-b block-size] [-f fragment-size]
Denys Vlasenko3581c622010-01-25 13:39:24 +0100181// [-i bytes-per-inode] [-I inode-size] [-J journal-options]
182// [-G meta group size] [-N number-of-inodes]
183// [-m reserved-blocks-percentage] [-o creator-os]
184// [-g blocks-per-group] [-L volume-label] [-M last-mounted-directory]
185// [-O feature[,...]] [-r fs-revision] [-E extended-option[,...]]
186// [-T fs-type] [-U UUID] [-jnqvFSV] device [blocks-count]
Denys Vlasenko2ee27242009-10-21 11:34:32 +0200187//
188// Options not commented below are taken but silently ignored:
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200189enum {
190 OPT_c = 1 << 0,
191 OPT_l = 1 << 1,
192 OPT_b = 1 << 2, // block size, in bytes
193 OPT_f = 1 << 3,
194 OPT_i = 1 << 4, // bytes per inode
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200195 OPT_I = 1 << 5, // custom inode size, in bytes
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200196 OPT_J = 1 << 6,
197 OPT_G = 1 << 7,
198 OPT_N = 1 << 8,
199 OPT_m = 1 << 9, // percentage of blocks reserved for superuser
200 OPT_o = 1 << 10,
201 OPT_g = 1 << 11,
202 OPT_L = 1 << 12, // label
203 OPT_M = 1 << 13,
204 OPT_O = 1 << 14,
205 OPT_r = 1 << 15,
206 OPT_E = 1 << 16,
207 OPT_T = 1 << 17,
208 OPT_U = 1 << 18,
209 OPT_j = 1 << 19,
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200210 OPT_n = 1 << 20, // dry run: do not write anything
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200211 OPT_q = 1 << 21,
212 OPT_v = 1 << 22,
213 OPT_F = 1 << 23,
214 OPT_S = 1 << 24,
215 //OPT_V = 1 << 25, // -V version. bbox applets don't support that
216};
217
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200218int mkfs_ext2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
219int mkfs_ext2_main(int argc UNUSED_PARAM, char **argv)
220{
221 unsigned i, pos, n;
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200222 unsigned bs, bpi;
223 unsigned blocksize, blocksize_log2;
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200224 unsigned inodesize, user_inodesize;
Denys Vlasenko95484c82009-10-20 13:34:16 +0200225 unsigned reserved_percent = 5;
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200226 unsigned long long kilobytes;
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200227 uint32_t nblocks, nblocks_full;
228 uint32_t nreserved;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200229 uint32_t ngroups;
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200230 uint32_t bytes_per_inode;
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200231 uint32_t first_block;
Denys Vlasenko05647b52009-10-20 00:06:03 +0200232 uint32_t inodes_per_group;
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200233 uint32_t group_desc_blocks;
234 uint32_t inode_table_blocks;
235 uint32_t lost_and_found_blocks;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200236 time_t timestamp;
Denys Vlasenko05647b52009-10-20 00:06:03 +0200237 const char *label = "";
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200238 struct stat st;
239 struct ext2_super_block *sb; // superblock
240 struct ext2_group_desc *gd; // group descriptors
241 struct ext2_inode *inode;
242 struct ext2_dir *dir;
243 uint8_t *buf;
244
Denys Vlasenko46e364d2009-10-22 12:41:44 +0200245 // using global "option_mask32" instead of local "opts":
246 // we are register starved here
Denys Vlasenko237bedd2016-07-06 21:58:02 +0200247 /*opts =*/ getopt32(argv, "cl:b:+f:i:+I:+J:G:N:m:+o:g:L:M:O:r:E:T:U:jnqvFS",
Denys Vlasenko8f599f92010-06-18 12:40:57 +0200248 /*lbfi:*/ NULL, &bs, NULL, &bpi,
249 /*IJGN:*/ &user_inodesize, NULL, NULL, NULL,
250 /*mogL:*/ &reserved_percent, NULL, NULL, &label,
251 /*MOrE:*/ NULL, NULL, NULL, NULL,
252 /*TU:*/ NULL, NULL);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200253 argv += optind; // argv[0] -- device
254
Denys Vlasenkobaad6d82010-02-02 12:54:19 +0100255 // open the device, check the device is a block device
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200256 xmove_fd(xopen(argv[0], O_WRONLY), fd);
Denys Vlasenko8d3e2252010-08-31 12:42:06 +0200257 xfstat(fd, &st, argv[0]);
Denys Vlasenko46e364d2009-10-22 12:41:44 +0200258 if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_F))
Bernhard Reutner-Fischer50701242010-06-18 11:49:44 +0200259 bb_error_msg_and_die("%s: not a block device", argv[0]);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200260
261 // check if it is mounted
262 // N.B. what if we format a file? find_mount_point will return false negative since
Denys Vlasenkobaad6d82010-02-02 12:54:19 +0100263 // it is loop block device which is mounted!
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200264 if (find_mount_point(argv[0], 0))
265 bb_error_msg_and_die("can't format mounted filesystem");
266
Denys Vlasenkobaad6d82010-02-02 12:54:19 +0100267 // get size in kbytes
Denys Vlasenko40e7d252010-02-01 23:48:27 +0100268 kilobytes = get_volume_size_in_bytes(fd, argv[1], 1024, /*extend:*/ !(option_mask32 & OPT_n)) / 1024;
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200269
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200270 bytes_per_inode = 16384;
271 if (kilobytes < 512*1024)
272 bytes_per_inode = 4096;
273 if (kilobytes < 3*1024)
274 bytes_per_inode = 8192;
Denys Vlasenko46e364d2009-10-22 12:41:44 +0200275 if (option_mask32 & OPT_i)
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200276 bytes_per_inode = bpi;
277
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200278 // Determine block size and inode size
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200279 // block size is a multiple of 1024
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200280 // inode size is a multiple of 128
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200281 blocksize = 1024;
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200282 inodesize = sizeof(struct ext2_inode); // 128
283 if (kilobytes >= 512*1024) { // mke2fs 1.41.9 compat
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200284 blocksize = 4096;
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200285 inodesize = 256;
286 }
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200287 if (EXT2_MAX_BLOCK_SIZE > 4096) {
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200288 // kilobytes >> 22 == size in 4gigabyte chunks.
Denys Vlasenko95484c82009-10-20 13:34:16 +0200289 // if size >= 16k gigs, blocksize must be increased.
290 // Try "mke2fs -F image $((16 * 1024*1024*1024))"
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200291 while ((kilobytes >> 22) >= blocksize)
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200292 blocksize *= 2;
293 }
Denys Vlasenko46e364d2009-10-22 12:41:44 +0200294 if (option_mask32 & OPT_b)
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200295 blocksize = bs;
296 if (blocksize < EXT2_MIN_BLOCK_SIZE
297 || blocksize > EXT2_MAX_BLOCK_SIZE
298 || (blocksize & (blocksize - 1)) // not power of 2
299 ) {
300 bb_error_msg_and_die("blocksize %u is bad", blocksize);
301 }
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200302 // Do we have custom inode size?
Denys Vlasenko46e364d2009-10-22 12:41:44 +0200303 if (option_mask32 & OPT_I) {
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200304 if (user_inodesize < sizeof(*inode)
305 || user_inodesize > blocksize
306 || (user_inodesize & (user_inodesize - 1)) // not power of 2
307 ) {
308 bb_error_msg("-%c is bad", 'I');
309 } else {
310 inodesize = user_inodesize;
311 }
312 }
313
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200314 if ((int32_t)bytes_per_inode < blocksize)
315 bb_error_msg_and_die("-%c is bad", 'i');
Denys Vlasenko95484c82009-10-20 13:34:16 +0200316 // number of bits in one block, i.e. 8*blocksize
317#define blocks_per_group (8 * blocksize)
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200318 first_block = (EXT2_MIN_BLOCK_SIZE == blocksize);
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200319 blocksize_log2 = int_log2(blocksize);
Denys Vlasenko95484c82009-10-20 13:34:16 +0200320
321 // Determine number of blocks
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200322 kilobytes >>= (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200323 nblocks = kilobytes;
324 if (nblocks != kilobytes)
Denys Vlasenkof9d3a912009-10-18 18:05:27 +0200325 bb_error_msg_and_die("block count doesn't fit in 32 bits");
Denys Vlasenko05647b52009-10-20 00:06:03 +0200326#define kilobytes kilobytes_unused_after_this
Denys Vlasenko95484c82009-10-20 13:34:16 +0200327 // Experimentally, standard mke2fs won't work on images smaller than 60k
328 if (nblocks < 60)
329 bb_error_msg_and_die("need >= 60 blocks");
330
331 // How many reserved blocks?
332 if (reserved_percent > 50)
333 bb_error_msg_and_die("-%c is bad", 'm');
Denys Vlasenko95484c82009-10-20 13:34:16 +0200334 nreserved = (uint64_t)nblocks * reserved_percent / 100;
Denys Vlasenko05647b52009-10-20 00:06:03 +0200335
336 // N.B. killing e2fsprogs feature! Unused blocks don't account in calculations
Denys Vlasenko3581c622010-01-25 13:39:24 +0100337 nblocks_full = nblocks;
Denys Vlasenko95484c82009-10-20 13:34:16 +0200338
339 // If last block group is too small, nblocks may be decreased in order
340 // to discard it, and control returns here to recalculate some
341 // parameters.
342 // Note: blocksize and bytes_per_inode are never recalculated.
Denys Vlasenko05647b52009-10-20 00:06:03 +0200343 retry:
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200344 // N.B. a block group can have no more than blocks_per_group blocks
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200345 ngroups = div_roundup(nblocks - first_block, blocks_per_group);
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200346
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200347 group_desc_blocks = div_roundup(ngroups, blocksize / sizeof(*gd));
Denys Vlasenko05647b52009-10-20 00:06:03 +0200348 // TODO: reserved blocks must be marked as such in the bitmaps,
349 // or resulting filesystem is corrupt
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200350 if (ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT) {
Denys Vlasenko05647b52009-10-20 00:06:03 +0200351 /*
352 * From e2fsprogs: Calculate the number of GDT blocks to reserve for online
353 * filesystem growth.
354 * The absolute maximum number of GDT blocks we can reserve is determined by
355 * the number of block pointers that can fit into a single block.
356 * We set it at 1024x the current filesystem size, or
357 * the upper block count limit (2^32), whichever is lower.
358 */
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200359 uint32_t reserved_group_desc_blocks = 0xFFFFFFFF; // maximum block number
360 if (nblocks < reserved_group_desc_blocks / 1024)
361 reserved_group_desc_blocks = nblocks * 1024;
362 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks - first_block, blocks_per_group);
363 reserved_group_desc_blocks = div_roundup(reserved_group_desc_blocks, blocksize / sizeof(*gd)) - group_desc_blocks;
364 if (reserved_group_desc_blocks > blocksize / sizeof(uint32_t))
365 reserved_group_desc_blocks = blocksize / sizeof(uint32_t);
366 //TODO: STORE_LE(sb->s_reserved_gdt_blocks, reserved_group_desc_blocks);
367 group_desc_blocks += reserved_group_desc_blocks;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200368 }
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200369
Denys Vlasenko05647b52009-10-20 00:06:03 +0200370 {
371 // N.B. e2fsprogs does as follows!
Denys Vlasenko05647b52009-10-20 00:06:03 +0200372 uint32_t overhead, remainder;
Denys Vlasenko2288d862009-10-21 00:34:27 +0200373 // ninodes is the max number of inodes in this filesystem
374 uint32_t ninodes = ((uint64_t) nblocks_full * blocksize) / bytes_per_inode;
Denys Vlasenko05647b52009-10-20 00:06:03 +0200375 if (ninodes < EXT2_GOOD_OLD_FIRST_INO+1)
376 ninodes = EXT2_GOOD_OLD_FIRST_INO+1;
377 inodes_per_group = div_roundup(ninodes, ngroups);
378 // minimum number because the first EXT2_GOOD_OLD_FIRST_INO-1 are reserved
379 if (inodes_per_group < 16)
380 inodes_per_group = 16;
Denys Vlasenko2288d862009-10-21 00:34:27 +0200381 // a block group can't have more inodes than blocks
Denys Vlasenko05647b52009-10-20 00:06:03 +0200382 if (inodes_per_group > blocks_per_group)
383 inodes_per_group = blocks_per_group;
384 // adjust inodes per group so they completely fill the inode table blocks in the descriptor
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200385 inodes_per_group = (div_roundup(inodes_per_group * inodesize, blocksize) * blocksize) / inodesize;
Denys Vlasenko05647b52009-10-20 00:06:03 +0200386 // make sure the number of inodes per group is a multiple of 8
387 inodes_per_group &= ~7;
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200388 inode_table_blocks = div_roundup(inodes_per_group * inodesize, blocksize);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200389
390 // to be useful, lost+found should occupy at least 2 blocks (but not exceeding 16*1024 bytes),
391 // and at most EXT2_NDIR_BLOCKS. So reserve these blocks right now
392 /* Or e2fsprogs comment verbatim (what does it mean?):
393 * Ensure that lost+found is at least 2 blocks, so we always
394 * test large empty blocks for big-block filesystems. */
395 lost_and_found_blocks = MIN(EXT2_NDIR_BLOCKS, 16 >> (blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE));
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200396
Denys Vlasenko95484c82009-10-20 13:34:16 +0200397 // the last group needs more attention: isn't it too small for possible overhead?
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200398 overhead = (has_super(ngroups - 1) ? (1/*sb*/ + group_desc_blocks) : 0) + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200399 remainder = (nblocks - first_block) % blocks_per_group;
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200400 ////can't happen, nblocks >= 60 guarantees this
401 ////if ((1 == ngroups)
402 //// && remainder
403 //// && (remainder < overhead + 1/* "/" */ + lost_and_found_blocks)
404 ////) {
405 //// bb_error_msg_and_die("way small device");
406 ////}
Denys Vlasenko2288d862009-10-21 00:34:27 +0200407
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200408 // Standard mke2fs uses 50. Looks like a bug in our calculation
Denys Vlasenkoa4e4a652009-10-20 17:49:50 +0200409 // of "remainder" or "overhead" - we don't match standard mke2fs
410 // when we transition from one group to two groups
411 // (a bit after 8M image size), but it works for two->three groups
412 // transition (at 16M).
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200413 if (remainder && (remainder < overhead + 50)) {
Denys Vlasenko76b680c2016-03-30 16:04:37 +0200414//bb_error_msg("CHOP[%u]", remainder);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200415 nblocks -= remainder;
416 goto retry;
417 }
418 }
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200419
Denys Vlasenko05647b52009-10-20 00:06:03 +0200420 if (nblocks_full - nblocks)
421 printf("warning: %u blocks unused\n\n", nblocks_full - nblocks);
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200422 printf(
423 "Filesystem label=%s\n"
424 "OS type: Linux\n"
425 "Block size=%u (log=%u)\n"
426 "Fragment size=%u (log=%u)\n"
427 "%u inodes, %u blocks\n"
428 "%u blocks (%u%%) reserved for the super user\n"
429 "First data block=%u\n"
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200430 "Maximum filesystem blocks=%u\n"
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200431 "%u block groups\n"
432 "%u blocks per group, %u fragments per group\n"
433 "%u inodes per group"
Denys Vlasenko05647b52009-10-20 00:06:03 +0200434 , label
435 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
436 , blocksize, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE
437 , inodes_per_group * ngroups, nblocks
Denys Vlasenko95484c82009-10-20 13:34:16 +0200438 , nreserved, reserved_percent
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200439 , first_block
Denys Vlasenko4b8b37f2009-10-24 17:20:29 +0200440 , group_desc_blocks * (blocksize / (unsigned)sizeof(*gd)) * blocks_per_group
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200441 , ngroups
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200442 , blocks_per_group, blocks_per_group
Denys Vlasenko05647b52009-10-20 00:06:03 +0200443 , inodes_per_group
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200444 );
445 {
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200446 const char *fmt = "\nSuperblock backups stored on blocks:\n"
447 "\t%u";
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200448 pos = first_block;
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200449 for (i = 1; i < ngroups; i++) {
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200450 pos += blocks_per_group;
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200451 if (has_super(i)) {
452 printf(fmt, (unsigned)pos);
453 fmt = ", %u";
454 }
455 }
456 }
457 bb_putchar('\n');
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200458
Denys Vlasenko46e364d2009-10-22 12:41:44 +0200459 if (option_mask32 & OPT_n) {
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200460 if (ENABLE_FEATURE_CLEAN_UP)
461 close(fd);
462 return EXIT_SUCCESS;
463 }
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200464
Denys Vlasenko05647b52009-10-20 00:06:03 +0200465 // TODO: 3/5 refuse if mounted
466 // TODO: 4/5 compat options
467 // TODO: 1/5 sanity checks
468 // TODO: 0/5 more verbose error messages
469 // TODO: 4/5 bigendianness: recheck, wait for ARM reporters
470 // TODO: 2/5 reserved GDT: how to mark but not allocate?
471 // TODO: 3/5 dir_index?
472
473 // fill the superblock
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200474 sb = xzalloc(1024);
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200475 STORE_LE(sb->s_rev_level, EXT2_DYNAMIC_REV); // revision 1 filesystem
Denys Vlasenko05647b52009-10-20 00:06:03 +0200476 STORE_LE(sb->s_magic, EXT2_SUPER_MAGIC);
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200477 STORE_LE(sb->s_inode_size, inodesize);
478 // set "Required extra isize" and "Desired extra isize" fields to 28
Denys Vlasenkoc9a13112012-06-21 16:50:46 +0200479 if (inodesize != sizeof(*inode)) {
480 STORE_LE(sb->s_min_extra_isize, 0x001c);
481 STORE_LE(sb->s_want_extra_isize, 0x001c);
482 }
Denys Vlasenko05647b52009-10-20 00:06:03 +0200483 STORE_LE(sb->s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
484 STORE_LE(sb->s_log_block_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
485 STORE_LE(sb->s_log_frag_size, blocksize_log2 - EXT2_MIN_BLOCK_LOG_SIZE);
486 // first 1024 bytes of the device are for boot record. If block size is 1024 bytes, then
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200487 // the first block is 1, otherwise 0
488 STORE_LE(sb->s_first_data_block, first_block);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200489 // block and inode bitmaps occupy no more than one block, so maximum number of blocks is
490 STORE_LE(sb->s_blocks_per_group, blocks_per_group);
491 STORE_LE(sb->s_frags_per_group, blocks_per_group);
492 // blocks
493 STORE_LE(sb->s_blocks_count, nblocks);
494 // reserve blocks for superuser
Denys Vlasenko95484c82009-10-20 13:34:16 +0200495 STORE_LE(sb->s_r_blocks_count, nreserved);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200496 // ninodes
497 STORE_LE(sb->s_inodes_per_group, inodes_per_group);
498 STORE_LE(sb->s_inodes_count, inodes_per_group * ngroups);
499 STORE_LE(sb->s_free_inodes_count, inodes_per_group * ngroups - EXT2_GOOD_OLD_FIRST_INO);
500 // timestamps
501 timestamp = time(NULL);
502 STORE_LE(sb->s_mkfs_time, timestamp);
503 STORE_LE(sb->s_wtime, timestamp);
504 STORE_LE(sb->s_lastcheck, timestamp);
Denys Vlasenko481ca962009-10-22 00:38:52 +0200505 // misc. Values are chosen to match mke2fs 1.41.9
Denys Vlasenko05647b52009-10-20 00:06:03 +0200506 STORE_LE(sb->s_state, 1); // TODO: what's 1?
507 STORE_LE(sb->s_creator_os, EXT2_OS_LINUX);
508 STORE_LE(sb->s_checkinterval, 24*60*60 * 180); // 180 days
509 STORE_LE(sb->s_errors, EXT2_ERRORS_DEFAULT);
Denys Vlasenko481ca962009-10-22 00:38:52 +0200510 // mke2fs 1.41.9 also sets EXT3_FEATURE_COMPAT_RESIZE_INODE
511 // and if >= 0.5GB, EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
512 // we use values which match "mke2fs -O ^resize_inode":
513 // in this case 1.41.9 never sets EXT3_FEATURE_RO_COMPAT_LARGE_FILE.
Denys Vlasenko05647b52009-10-20 00:06:03 +0200514 STORE_LE(sb->s_feature_compat, EXT2_FEATURE_COMPAT_SUPP
515 | (EXT2_FEATURE_COMPAT_RESIZE_INO * ENABLE_FEATURE_MKFS_EXT2_RESERVED_GDT)
516 | (EXT2_FEATURE_COMPAT_DIR_INDEX * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX)
517 );
Denys Vlasenko481ca962009-10-22 00:38:52 +0200518 STORE_LE(sb->s_feature_incompat, EXT2_FEATURE_INCOMPAT_FILETYPE);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200519 STORE_LE(sb->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER);
Denys Vlasenko481ca962009-10-22 00:38:52 +0200520 STORE_LE(sb->s_flags, EXT2_FLAGS_UNSIGNED_HASH * ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200521 generate_uuid(sb->s_uuid);
522 if (ENABLE_FEATURE_MKFS_EXT2_DIR_INDEX) {
523 STORE_LE(sb->s_def_hash_version, EXT2_HASH_HALF_MD4);
524 generate_uuid((uint8_t *)sb->s_hash_seed);
525 }
526 /*
527 * From e2fsprogs: add "jitter" to the superblock's check interval so that we
528 * don't check all the filesystems at the same time. We use a
529 * kludgy hack of using the UUID to derive a random jitter value.
530 */
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200531 STORE_LE(sb->s_max_mnt_count,
532 EXT2_DFL_MAX_MNT_COUNT
Denys Vlasenko05647b52009-10-20 00:06:03 +0200533 + (sb->s_uuid[ARRAY_SIZE(sb->s_uuid)-1] % EXT2_DFL_MAX_MNT_COUNT));
534
Denys Vlasenko95484c82009-10-20 13:34:16 +0200535 // write the label
536 safe_strncpy((char *)sb->s_volume_name, label, sizeof(sb->s_volume_name));
Denys Vlasenko05647b52009-10-20 00:06:03 +0200537
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200538 // calculate filesystem skeleton structures
539 gd = xzalloc(group_desc_blocks * blocksize);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200540 buf = xmalloc(blocksize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200541 sb->s_free_blocks_count = 0;
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200542 for (i = 0, pos = first_block, n = nblocks - first_block;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200543 i < ngroups;
Denys Vlasenkoe8405612009-10-18 20:57:52 +0200544 i++, pos += blocks_per_group, n -= blocks_per_group
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200545 ) {
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200546 uint32_t overhead = pos + (has_super(i) ? (1/*sb*/ + group_desc_blocks) : 0);
547 uint32_t free_blocks;
548 // fill group descriptors
Denys Vlasenko05647b52009-10-20 00:06:03 +0200549 STORE_LE(gd[i].bg_block_bitmap, overhead + 0);
550 STORE_LE(gd[i].bg_inode_bitmap, overhead + 1);
551 STORE_LE(gd[i].bg_inode_table, overhead + 2);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200552 overhead = overhead - pos + 1/*bbmp*/ + 1/*ibmp*/ + inode_table_blocks;
Denys Vlasenko05647b52009-10-20 00:06:03 +0200553 gd[i].bg_free_inodes_count = inodes_per_group;
554 //STORE_LE(gd[i].bg_used_dirs_count, 0);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200555 // N.B. both "/" and "/lost+found" are within the first block group
556 // "/" occupies 1 block, "/lost+found" occupies lost_and_found_blocks...
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200557 if (0 == i) {
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200558 // ... thus increased overhead for the first block group ...
559 overhead += 1 + lost_and_found_blocks;
560 // ... and 2 used directories
Denys Vlasenko05647b52009-10-20 00:06:03 +0200561 STORE_LE(gd[i].bg_used_dirs_count, 2);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200562 // well known reserved inodes belong to the first block too
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200563 gd[i].bg_free_inodes_count -= EXT2_GOOD_OLD_FIRST_INO;
564 }
Denys Vlasenko05647b52009-10-20 00:06:03 +0200565
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200566 // cache free block count of the group
567 free_blocks = (n < blocks_per_group ? n : blocks_per_group) - overhead;
568
Denys Vlasenko05647b52009-10-20 00:06:03 +0200569 // mark preallocated blocks as allocated
Denys Vlasenko76b680c2016-03-30 16:04:37 +0200570//bb_error_msg("ALLOC: [%u][%u][%u]", blocksize, overhead, blocks_per_group - (free_blocks + overhead));
Denys Vlasenko05647b52009-10-20 00:06:03 +0200571 allocate(buf, blocksize,
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200572 // reserve "overhead" blocks
Denys Vlasenko05647b52009-10-20 00:06:03 +0200573 overhead,
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200574 // mark unused trailing blocks
575 blocks_per_group - (free_blocks + overhead)
Denys Vlasenko05647b52009-10-20 00:06:03 +0200576 );
577 // dump block bitmap
578 PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200579 STORE_LE(gd[i].bg_free_blocks_count, free_blocks);
Denys Vlasenko05647b52009-10-20 00:06:03 +0200580
581 // mark preallocated inodes as allocated
582 allocate(buf, blocksize,
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200583 // mark reserved inodes
Denys Vlasenko05647b52009-10-20 00:06:03 +0200584 inodes_per_group - gd[i].bg_free_inodes_count,
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200585 // mark unused trailing inodes
Denys Vlasenko05647b52009-10-20 00:06:03 +0200586 blocks_per_group - inodes_per_group
587 );
588 // dump inode bitmap
589 //PUT((uint64_t)(FETCH_LE32(gd[i].bg_block_bitmap)) * blocksize, buf, blocksize);
590 //but it's right after block bitmap, so we can just:
591 xwrite(fd, buf, blocksize);
592 STORE_LE(gd[i].bg_free_inodes_count, gd[i].bg_free_inodes_count);
593
594 // count overall free blocks
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200595 sb->s_free_blocks_count += free_blocks;
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200596 }
597 STORE_LE(sb->s_free_blocks_count, sb->s_free_blocks_count);
598
599 // dump filesystem skeleton structures
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200600// printf("Writing superblocks and filesystem accounting information: ");
Denys Vlasenkoc708a6d2009-10-20 17:47:23 +0200601 for (i = 0, pos = first_block; i < ngroups; i++, pos += blocks_per_group) {
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200602 // dump superblock and group descriptors and their backups
Denys Vlasenko05647b52009-10-20 00:06:03 +0200603 if (has_super(i)) {
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200604 // N.B. 1024 byte blocks are special
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200605 PUT(((uint64_t)pos * blocksize) + ((0 == i && 1024 != blocksize) ? 1024 : 0),
606 sb, 1024);
607 PUT(((uint64_t)pos * blocksize) + blocksize,
608 gd, group_desc_blocks * blocksize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200609 }
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200610 }
611
612 // zero boot sectors
613 memset(buf, 0, blocksize);
Denys Vlasenko75502012012-01-11 01:02:31 +0100614 // Disabled: standard mke2fs doesn't do this, and
615 // on SPARC this destroys Sun disklabel.
616 // Users who need/want zeroing can easily do it with dd.
617 //PUT(0, buf, 1024); // N.B. 1024 <= blocksize, so buf[0..1023] contains zeros
618
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200619 // zero inode tables
620 for (i = 0; i < ngroups; ++i)
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200621 for (n = 0; n < inode_table_blocks; ++n)
622 PUT((uint64_t)(FETCH_LE32(gd[i].bg_inode_table) + n) * blocksize,
623 buf, blocksize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200624
625 // prepare directory inode
626 inode = (struct ext2_inode *)buf;
627 STORE_LE(inode->i_mode, S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH);
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200628 STORE_LE(inode->i_mtime, timestamp);
629 STORE_LE(inode->i_atime, timestamp);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200630 STORE_LE(inode->i_ctime, timestamp);
631 STORE_LE(inode->i_size, blocksize);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200632 // inode->i_blocks stores the number of 512 byte data blocks
633 // (512, because it goes directly to struct stat without scaling)
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200634 STORE_LE(inode->i_blocks, blocksize / 512);
635
636 // dump root dir inode
637 STORE_LE(inode->i_links_count, 3); // "/.", "/..", "/lost+found/.." point to this inode
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200638 STORE_LE(inode->i_block[0], FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks);
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200639 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_ROOT_INO-1) * inodesize,
640 buf, inodesize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200641
642 // dump lost+found dir inode
643 STORE_LE(inode->i_links_count, 2); // both "/lost+found" and "/lost+found/." point to this inode
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200644 STORE_LE(inode->i_size, lost_and_found_blocks * blocksize);
645 STORE_LE(inode->i_blocks, (lost_and_found_blocks * blocksize) / 512);
646 n = FETCH_LE32(inode->i_block[0]) + 1;
647 for (i = 0; i < lost_and_found_blocks; ++i)
648 STORE_LE(inode->i_block[i], i + n); // use next block
Denys Vlasenko76b680c2016-03-30 16:04:37 +0200649//bb_error_msg("LAST BLOCK USED[%u]", i + n);
Denys Vlasenko149a32a2009-10-22 12:12:17 +0200650 PUT(((uint64_t)FETCH_LE32(gd[0].bg_inode_table) * blocksize) + (EXT2_GOOD_OLD_FIRST_INO-1) * inodesize,
651 buf, inodesize);
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200652
Denys Vlasenkoece01ee2009-10-21 14:01:25 +0200653 // dump directories
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200654 memset(buf, 0, blocksize);
Denys Vlasenkoece01ee2009-10-21 14:01:25 +0200655 dir = (struct ext2_dir *)buf;
656
657 // dump 2nd+ blocks of "/lost+found"
Denys Vlasenko010fb002009-10-21 23:23:55 +0200658 STORE_LE(dir->rec_len1, blocksize); // e2fsck 1.41.4 compat (1.41.9 does not need this)
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200659 for (i = 1; i < lost_and_found_blocks; ++i)
660 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1+i) * blocksize,
661 buf, blocksize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200662
Denys Vlasenkoece01ee2009-10-21 14:01:25 +0200663 // dump 1st block of "/lost+found"
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200664 STORE_LE(dir->inode1, EXT2_GOOD_OLD_FIRST_INO);
665 STORE_LE(dir->rec_len1, 12);
666 STORE_LE(dir->name_len1, 1);
667 STORE_LE(dir->file_type1, EXT2_FT_DIR);
668 dir->name1[0] = '.';
669 STORE_LE(dir->inode2, EXT2_ROOT_INO);
670 STORE_LE(dir->rec_len2, blocksize - 12);
671 STORE_LE(dir->name_len2, 2);
672 STORE_LE(dir->file_type2, EXT2_FT_DIR);
673 dir->name2[0] = '.'; dir->name2[1] = '.';
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200674 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 1) * blocksize, buf, blocksize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200675
676 // dump root dir block
677 STORE_LE(dir->inode1, EXT2_ROOT_INO);
678 STORE_LE(dir->rec_len2, 12);
679 STORE_LE(dir->inode3, EXT2_GOOD_OLD_FIRST_INO);
680 STORE_LE(dir->rec_len3, blocksize - 12 - 12);
681 STORE_LE(dir->name_len3, 10);
682 STORE_LE(dir->file_type3, EXT2_FT_DIR);
683 strcpy(dir->name3, "lost+found");
Denys Vlasenko5e1dbd52009-10-20 22:12:11 +0200684 PUT((uint64_t)(FETCH_LE32(gd[0].bg_inode_table) + inode_table_blocks + 0) * blocksize, buf, blocksize);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200685
686 // cleanup
687 if (ENABLE_FEATURE_CLEAN_UP) {
688 free(buf);
689 free(gd);
690 free(sb);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200691 }
692
Denys Vlasenko77da1ca2009-10-18 16:29:30 +0200693 xclose(fd);
Vladimir Dronnikov823b4e62009-10-17 21:38:19 +0200694 return EXIT_SUCCESS;
695}