busybox/util-linux/mkfs_reiser.c

/* vi: set sw=4 ts=4: */
/*
 * mkfs_reiser: utility to create ReiserFS filesystem
 *
 * Busybox'ed (2009) by Vladimir Dronnikov <dronnikov@gmail.com>
 *
 * Licensed under GPLv2, see file LICENSE in this tarball for details.
 */
#include "libbb.h"
#include <linux/fs.h>
#include "volume_id/volume_id_internal.h"

char BUG_wrong_field_size(void);
#define STORE_LE(field, value) \
do { \
	if (sizeof(field) == 4) \
		field = cpu_to_le32(value); \
	else if (sizeof(field) == 2) \
		field = cpu_to_le16(value); \
	else if (sizeof(field) == 1) \
		field = (value); \
	else \
		BUG_wrong_field_size(); \
} while (0)

#define FETCH_LE32(field) \
	(sizeof(field) == 4 ? cpu_to_le32(field) : BUG_wrong_field_size())

struct journal_params {
	uint32_t jp_journal_1st_block;      /* where does journal start from on its device */
	uint32_t jp_journal_dev;            /* journal device st_rdev */
	uint32_t jp_journal_size;           /* size of the journal on FS creation. used to make sure they don't overflow it */
	uint32_t jp_journal_trans_max;      /* max number of blocks in a transaction.  */
	uint32_t jp_journal_magic;          /* random value made on fs creation (this was sb_journal_block_count) */
	uint32_t jp_journal_max_batch;      /* max number of blocks to batch into a trans */
	uint32_t jp_journal_max_commit_age; /* in seconds, how old can an async commit be */
	uint32_t jp_journal_max_trans_age;  /* in seconds, how old can a transaction be */
};

struct reiserfs_journal_header {
	uint32_t jh_last_flush_trans_id;    /* id of last fully flushed transaction */
	uint32_t jh_first_unflushed_offset; /* offset in the log of where to start replay after a crash */
	uint32_t jh_mount_id;
	struct journal_params jh_journal;
	uint32_t jh_last_check_mount_id;    /* the mount id of the fs during the last reiserfsck --check. */
};

struct reiserfs_super_block {
	uint32_t sb_block_count;            /* 0 number of block on data device */
	uint32_t sb_free_blocks;            /* 4 free blocks count */
	uint32_t sb_root_block;             /* 8 root of the tree */

	struct journal_params sb_journal;   /* 12 */

	uint16_t sb_blocksize;          /* 44 */
	uint16_t sb_oid_maxsize;        /* 46 max size of object id array, see get_objectid() commentary */
	uint16_t sb_oid_cursize;        /* 48 current size of object id array */
	uint16_t sb_umount_state;       /* 50 this is set to 1 when filesystem was umounted, to 2 - when not */

	char s_magic[10];               /* 52 "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs" */
	uint16_t sb_fs_state;           /* 62 it is set to used by fsck to mark which phase of rebuilding is done (used for fsck debugging) */
	uint32_t sb_hash_function_code; /* 64 code of fuction which was/is/will be used to sort names in a directory. See codes in above */
	uint16_t sb_tree_height;        /* 68 height of filesytem tree. Tree consisting of only one root block has 2 here */
	uint16_t sb_bmap_nr;            /* 70 amount of bitmap blocks needed to address each block of file system */
	uint16_t sb_version;            /* 72 this field is only reliable on filesystem with non-standard journal */
	uint16_t sb_reserved_for_journal;  /* 74 size in blocks of journal area on main device, we need to keep after non-standard journal relocation */
	uint32_t sb_inode_generation;   /* 76 */
	uint32_t sb_flags;              /* 80 Right now used only by inode-attributes, if enabled */
	unsigned char s_uuid[16];       /* 84 filesystem unique identifier */
	unsigned char s_label[16];      /* 100 filesystem volume label */
	uint16_t sb_mnt_count;          /* 116 */
	uint16_t sb_max_mnt_count;      /* 118 */
	uint32_t sb_lastcheck;          /* 120 */
	uint32_t sb_check_interval;     /* 124 */
/* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1() so any additions must be updated there as well. */
	char s_unused[76];              /* 128 */
	/* 204 */
};

/* Header of a disk block.  More precisely, header of a formatted leaf
   or internal node, and not the header of an unformatted node. */
struct block_head {
	uint16_t blk2_level;        /* Level of a block in the tree. */
	uint16_t blk2_nr_item;      /* Number of keys/items in a block. */
	uint16_t blk2_free_space;   /* Block free space in bytes. */
	uint16_t blk_reserved;
	uint32_t reserved[4];
};

#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)

#define REISERFS_3_6_SUPER_MAGIC_STRING "ReIsEr2Fs"
#define REISERFS_FORMAT_3_6     2
#define DEFAULT_MAX_MNT_COUNT   30                      /* 30 mounts */
#define DEFAULT_CHECK_INTERVAL  (180 * 60 * 60 * 24)    /* 180 days */

#define FS_CLEANLY_UMOUNTED     1 /* this was REISERFS_VALID_FS */

#define JOURNAL_MIN_SIZE        512
/* biggest possible single transaction, don't change for now (8/3/99) */
#define JOURNAL_TRANS_MAX       1024
#define JOURNAL_TRANS_MIN       256     /* need to check whether it works */
#define JOURNAL_DEFAULT_RATIO   8       /* default journal size / max trans length */
#define JOURNAL_MIN_RATIO       2
/* max blocks to batch into one transaction, don't make this any bigger than 900 */
#define JOURNAL_MAX_BATCH       900
#define JOURNAL_MAX_COMMIT_AGE  30


// Standard mkreiserfs 3.6.21:
//   -b | --block-size N              size of file-system block, in bytes
//   -j | --journal-device FILE       path to separate device to hold journal
//   -s | --journal-size N            size of the journal in blocks
//   -o | --journal-offset N          offset of the journal from the start of
//                                    the separate device, in blocks
//   -t | --transaction-max-size N    maximal size of transaction, in blocks
//   -B | --badblocks file            store all bad blocks given in file on the fs
//   -h | --hash rupasov|tea|r5       hash function to use by default
//   -u | --uuid UUID                 store UUID in the superblock
//   -l | --label LABEL               store LABEL in the superblock
//   --format 3.5|3.6                 old 3.5 format or newer 3.6
//   -f | --force                     specified once, make mkreiserfs the whole
//                                    disk, not block device or mounted partition;
//                                    specified twice, do not ask for confirmation
//   -q | --quiet                     quiet work without messages, progress and
//                                    questions. Useful if run in a script. For use
//                                    by end users only.
//   -d | --debug                     print debugging information during mkreiser
//   -V                               print version and exit

// Options not commented below are taken but silently ignored:
enum {
	OPT_b = 1 << 0,
	OPT_j = 1 << 1,
	OPT_s = 1 << 2,
	OPT_o = 1 << 3,
	OPT_t = 1 << 4,
	OPT_B = 1 << 5,
	OPT_h = 1 << 6,
	OPT_u = 1 << 7,
	OPT_l = 1 << 8,		// label
	OPT_f = 1 << 9,		// ask no questions
	OPT_q = 1 << 10,
	OPT_d = 1 << 11,
	//OPT_V = 1 << 12,	// -V version. bbox applets don't support that
};

int mkfs_reiser_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int mkfs_reiser_main(int argc UNUSED_PARAM, char **argv)
{
	unsigned blocksize = 4096;
	unsigned journal_blocks = 8192;
	unsigned blocks, bitmap_blocks, i, block;
	time_t timestamp;
	const char *label = "";
	struct stat st;
	int fd;
	uint8_t *buf;
	struct reiserfs_super_block *sb;
	struct journal_params *jp;
	struct block_head *root;

	// using global "option_mask32" instead of local "opts":
	// we are register starved here
	opt_complementary = "-1:b+";
	/*opts =*/ getopt32(argv, "b:j:s:o:t:B:h:u:l:fqd",
		NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &label);
	argv += optind; // argv[0] -- device

	// check the device is a block device
	fd = xopen(argv[0], O_WRONLY | O_EXCL);
	fstat(fd, &st);
	if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_f))
		bb_error_msg_and_die("not a block device");

	// check if it is mounted
	// N.B. what if we format a file? find_mount_point will return false negative since
	// it is loop block device which mounted!
	if (find_mount_point(argv[0], 0))
		bb_error_msg_and_die("can't format mounted filesystem");

	// open the device, get size in blocks
	if (argv[1]) {
		blocks = xatoull(argv[1]);
		// seek past end fails on block devices but works on files
		if (lseek(fd, blocks * blocksize - 1, SEEK_SET) != (off_t)-1) {
			xwrite(fd, "", 1); // file grows if needed
		}
		//else {
		//	bb_error_msg("warning, block device is smaller");
		//}
	} else {
		blocks = (uoff_t)xlseek(fd, 0, SEEK_END) / blocksize;
	}

	// block number sanity check
	// we have a limit: skipped area, super block, journal and root block
	// all have to be addressed by one first bitmap
	block = REISERFS_DISK_OFFSET_IN_BYTES / blocksize // boot area
		+ 1		// sb
		+ 1		// bitmap#0
		+ journal_blocks+1	// journal
	;

	// count overhead
	bitmap_blocks = (blocks - 1) / (blocksize * 8) + 1;
	i = block + bitmap_blocks;

	// check overhead
	if (MIN(blocksize * 8, blocks) < i)
		bb_error_msg_and_die("need >= %u blocks", i);

	// ask confirmation?
	// TODO: ???

	// wipe out first REISERFS_DISK_OFFSET_IN_BYTES of device
	// TODO: do we really need to wipe?!
	xlseek(fd, REISERFS_DISK_OFFSET_IN_BYTES, SEEK_SET);

	// fill superblock
	sb = (struct reiserfs_super_block *)xzalloc(blocksize);
	// block count
	STORE_LE(sb->sb_block_count, blocks);
	STORE_LE(sb->sb_free_blocks, blocks - i);
	// TODO: decypher!
	STORE_LE(sb->sb_root_block, block);
	// fill journal related fields
	jp = &sb->sb_journal;
	STORE_LE(jp->jp_journal_1st_block, REISERFS_DISK_OFFSET_IN_BYTES / blocksize + 1/*sb*/ + 1/*bmp#0*/);
	timestamp = time(NULL);
	srandom(timestamp);
	STORE_LE(jp->jp_journal_magic, random());
	STORE_LE(jp->jp_journal_size, journal_blocks);
	STORE_LE(jp->jp_journal_trans_max, JOURNAL_TRANS_MAX);
	STORE_LE(jp->jp_journal_max_batch, JOURNAL_MAX_BATCH);
	STORE_LE(jp->jp_journal_max_commit_age, JOURNAL_MAX_COMMIT_AGE);
	// sizes
	STORE_LE(sb->sb_blocksize, blocksize);
	STORE_LE(sb->sb_oid_maxsize, (blocksize - sizeof(*sb)) / sizeof(uint32_t) / 2 * 2);
	STORE_LE(sb->sb_oid_cursize, 2); // "." and ".."
	strcpy(sb->s_magic, REISERFS_3_6_SUPER_MAGIC_STRING);
	STORE_LE(sb->sb_bmap_nr, (bitmap_blocks > ((1LL << 16) - 1)) ? 0 : bitmap_blocks);
	// misc
	STORE_LE(sb->sb_version, REISERFS_FORMAT_3_6);
	STORE_LE(sb->sb_lastcheck, timestamp);
	STORE_LE(sb->sb_check_interval, DEFAULT_CHECK_INTERVAL);
	STORE_LE(sb->sb_mnt_count, 1);
	STORE_LE(sb->sb_max_mnt_count, DEFAULT_MAX_MNT_COUNT);
	STORE_LE(sb->sb_umount_state, FS_CLEANLY_UMOUNTED);
	STORE_LE(sb->sb_tree_height, 2);
	STORE_LE(sb->sb_hash_function_code, 3); // R5_HASH
	STORE_LE(sb->sb_flags, 1);
	//STORE_LE(sb->sb_reserved_for_journal, 0);
	// create UUID
	generate_uuid(sb->s_uuid);
	// write the label
	safe_strncpy((char *)sb->s_label, label, sizeof(sb->s_label));

	// TODO: EMPIRIC! ENDIANNESS!
	// superblock has only 204 bytes. What are these?
	buf = (uint8_t *)sb;
	buf[205] = 1;
	buf[209] = 3;

	// put superblock
	xwrite(fd, sb, blocksize);

	// create bitmaps
	buf = xzalloc(blocksize);

	// bitmap #0 uses initial "block"+1 blocks
	i = block + 1;
	memset(buf, 0xFF, i / 8);
	buf[i / 8] = (1 << (i & 7)) - 1; //0..7 => 00000000..01111111
	// mark trailing absent blocks, if any
	if (blocks < 8*blocksize) {
		unsigned n = 8*blocksize - blocks;
		i = n / 8;
		buf[blocksize - i - 1] |= 0x7F00 >> (n & 7); //0..7 => 00000000..11111110
		memset(buf + blocksize - i, 0xFF, i); // N.B. no overflow here!
	}
	// put bitmap #0
	xwrite(fd, buf, blocksize);

	// now go journal blocks
	memset(buf, 0, blocksize);
	for (i = 0; i < journal_blocks; i++)
		xwrite(fd, buf, blocksize);
	// dump journal control block
	memcpy(&((struct reiserfs_journal_header *)buf)->jh_journal, &sb->sb_journal, sizeof(sb->sb_journal));
	xwrite(fd, buf, blocksize);

	// other bitmaps are in every (8*blocksize)-th block
	// N.B. they use the only block -- namely bitmap itself!
	buf[0] = 0x01;
	// put bitmaps
	for (i = 1; i < bitmap_blocks; i++) {
		xlseek(fd, i*8*blocksize * blocksize, SEEK_SET);
		// mark trailing absent blocks, if any
		if (i == bitmap_blocks - 1 && (blocks % (8*blocksize))) {
			unsigned n = 8*blocksize - blocks % (8*blocksize);
			unsigned j = n / 8;
			buf[blocksize - j - 1] |= 0x7F00 >> (n & 7); //0..7 => 00000000..11111110
			memset(buf + blocksize - j, 0xFF, j); // N.B. no overflow here!
		}
		xwrite(fd, buf, blocksize);
	}

	// fill root block
	// block head
	memset(buf, 0, blocksize);
	root = (struct block_head *)buf;
	STORE_LE(root->blk2_level, 1); // leaf node
	STORE_LE(root->blk2_nr_item, 2); // "." and ".."
	STORE_LE(root->blk2_free_space, blocksize - sizeof(struct block_head));
	// item head
	// root directory
	// TODO: EMPIRIC! ENDIANNESS!
	// TODO: indented assignments seem to be timestamps
buf[4] = 0134;
buf[24] = 01;
buf[28] = 02;
buf[42] = 054;
buf[44] = 0324;
buf[45] = 017;
buf[46] = 01;
buf[48] = 01;
buf[52] = 02;
buf[56] = 01;
buf[60] = 0364;
buf[61] = 01;
buf[64] = 02;
buf[66] = 060;
buf[68] = 0244;
buf[69] = 017;
buf[4004] = 01;
buf[4008] = 01;
buf[4012] = 02;
buf[4016] = 050;
buf[4018] = 04;
buf[4020] = 02;
buf[4028] = 01;
buf[4032] = 040;
buf[4034] = 04;

buf[4036] = 056; buf[4037] = 056;	// ".."
buf[4044] = 056;			// "."

buf[4052] = 0355;
buf[4053] = 0101;
buf[4056] = 03;
buf[4060] = 060;
		buf[4076] = 0173;
		buf[4077] = 0240;
	buf[4078] = 0344;
	buf[4079] = 0112;
		buf[4080] = 0173;
		buf[4081] = 0240;
	buf[4082] = 0344;
	buf[4083] = 0112;
		buf[4084] = 0173;
		buf[4085] = 0240;
	buf[4086] = 0344;
	buf[4087] = 0112;
buf[4088] = 01;

	// put root block
	xlseek(fd, block * blocksize, SEEK_SET);
	xwrite(fd, buf, blocksize);

	// cleanup
	if (ENABLE_FEATURE_CLEAN_UP) {
		free(buf);
		free(sb);
	}

	xclose(fd);
	return EXIT_SUCCESS;
}
1	/* vi: set sw=4 ts=4: */
2	/*
3	* mkfs_reiser: utility to create ReiserFS filesystem
4	*
5	* Busybox'ed (2009) by Vladimir Dronnikov <dronnikov@gmail.com>
6	*
7	* Licensed under GPLv2, see file LICENSE in this tarball for details.
8	*/
9	#include "libbb.h"
10	#include <linux/fs.h>
11	#include "volume_id/volume_id_internal.h"
12
13	char BUG_wrong_field_size(void);
14	#define STORE_LE(field, value) \
15	do { \
16	if (sizeof(field) == 4) \
17	field = cpu_to_le32(value); \
18	else if (sizeof(field) == 2) \
19	field = cpu_to_le16(value); \
20	else if (sizeof(field) == 1) \
21	field = (value); \
22	else \
23	BUG_wrong_field_size(); \
24	} while (0)
25
26	#define FETCH_LE32(field) \
27	(sizeof(field) == 4 ? cpu_to_le32(field) : BUG_wrong_field_size())
28
29	struct journal_params {
30	uint32_t jp_journal_1st_block; /* where does journal start from on its device */
31	uint32_t jp_journal_dev; /* journal device st_rdev */
32	uint32_t jp_journal_size; /* size of the journal on FS creation. used to make sure they don't overflow it */
33	uint32_t jp_journal_trans_max; /* max number of blocks in a transaction. */
34	uint32_t jp_journal_magic; /* random value made on fs creation (this was sb_journal_block_count) */
35	uint32_t jp_journal_max_batch; /* max number of blocks to batch into a trans */
36	uint32_t jp_journal_max_commit_age; /* in seconds, how old can an async commit be */
37	uint32_t jp_journal_max_trans_age; /* in seconds, how old can a transaction be */
38	};
39
40	struct reiserfs_journal_header {
41	uint32_t jh_last_flush_trans_id; /* id of last fully flushed transaction */
42	uint32_t jh_first_unflushed_offset; /* offset in the log of where to start replay after a crash */
43	uint32_t jh_mount_id;
44	struct journal_params jh_journal;
45	uint32_t jh_last_check_mount_id; /* the mount id of the fs during the last reiserfsck --check. */
46	};
47
48	struct reiserfs_super_block {
49	uint32_t sb_block_count; /* 0 number of block on data device */
50	uint32_t sb_free_blocks; /* 4 free blocks count */
51	uint32_t sb_root_block; /* 8 root of the tree */
52
53	struct journal_params sb_journal; /* 12 */
54
55	uint16_t sb_blocksize; /* 44 */
56	uint16_t sb_oid_maxsize; /* 46 max size of object id array, see get_objectid() commentary */
57	uint16_t sb_oid_cursize; /* 48 current size of object id array */
58	uint16_t sb_umount_state; /* 50 this is set to 1 when filesystem was umounted, to 2 - when not */
59
60	char s_magic[10]; /* 52 "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs" */
61	uint16_t sb_fs_state; /* 62 it is set to used by fsck to mark which phase of rebuilding is done (used for fsck debugging) */
62	uint32_t sb_hash_function_code; /* 64 code of fuction which was/is/will be used to sort names in a directory. See codes in above */
63	uint16_t sb_tree_height; /* 68 height of filesytem tree. Tree consisting of only one root block has 2 here */
64	uint16_t sb_bmap_nr; /* 70 amount of bitmap blocks needed to address each block of file system */
65	uint16_t sb_version; /* 72 this field is only reliable on filesystem with non-standard journal */
66	uint16_t sb_reserved_for_journal; /* 74 size in blocks of journal area on main device, we need to keep after non-standard journal relocation */
67	uint32_t sb_inode_generation; /* 76 */
68	uint32_t sb_flags; /* 80 Right now used only by inode-attributes, if enabled */
69	unsigned char s_uuid[16]; /* 84 filesystem unique identifier */
70	unsigned char s_label[16]; /* 100 filesystem volume label */
71	uint16_t sb_mnt_count; /* 116 */
72	uint16_t sb_max_mnt_count; /* 118 */
73	uint32_t sb_lastcheck; /* 120 */
74	uint32_t sb_check_interval; /* 124 */
75	/* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1() so any additions must be updated there as well. */
76	char s_unused[76]; /* 128 */
77	/* 204 */
78	};
79
80	/* Header of a disk block. More precisely, header of a formatted leaf
81	or internal node, and not the header of an unformatted node. */
82	struct block_head {
83	uint16_t blk2_level; /* Level of a block in the tree. */
84	uint16_t blk2_nr_item; /* Number of keys/items in a block. */
85	uint16_t blk2_free_space; /* Block free space in bytes. */
86	uint16_t blk_reserved;
87	uint32_t reserved[4];
88	};
89
90	#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)
91
92	#define REISERFS_3_6_SUPER_MAGIC_STRING "ReIsEr2Fs"
93	#define REISERFS_FORMAT_3_6 2
94	#define DEFAULT_MAX_MNT_COUNT 30 /* 30 mounts */
95	#define DEFAULT_CHECK_INTERVAL (180 * 60 * 60 * 24) /* 180 days */
96
97	#define FS_CLEANLY_UMOUNTED 1 /* this was REISERFS_VALID_FS */
98
99	#define JOURNAL_MIN_SIZE 512
100	/* biggest possible single transaction, don't change for now (8/3/99) */
101	#define JOURNAL_TRANS_MAX 1024
102	#define JOURNAL_TRANS_MIN 256 /* need to check whether it works */
103	#define JOURNAL_DEFAULT_RATIO 8 /* default journal size / max trans length */
104	#define JOURNAL_MIN_RATIO 2
105	/* max blocks to batch into one transaction, don't make this any bigger than 900 */
106	#define JOURNAL_MAX_BATCH 900
107	#define JOURNAL_MAX_COMMIT_AGE 30
108
109
110	// Standard mkreiserfs 3.6.21:
111	// -b \| --block-size N size of file-system block, in bytes
112	// -j \| --journal-device FILE path to separate device to hold journal
113	// -s \| --journal-size N size of the journal in blocks
114	// -o \| --journal-offset N offset of the journal from the start of
115	// the separate device, in blocks
116	// -t \| --transaction-max-size N maximal size of transaction, in blocks
117	// -B \| --badblocks file store all bad blocks given in file on the fs
118	// -h \| --hash rupasov\|tea\|r5 hash function to use by default
119	// -u \| --uuid UUID store UUID in the superblock
120	// -l \| --label LABEL store LABEL in the superblock
121	// --format 3.5\|3.6 old 3.5 format or newer 3.6
122	// -f \| --force specified once, make mkreiserfs the whole
123	// disk, not block device or mounted partition;
124	// specified twice, do not ask for confirmation
125	// -q \| --quiet quiet work without messages, progress and
126	// questions. Useful if run in a script. For use
127	// by end users only.
128	// -d \| --debug print debugging information during mkreiser
129	// -V print version and exit
130
131	// Options not commented below are taken but silently ignored:
132	enum {
133	OPT_b = 1 << 0,
134	OPT_j = 1 << 1,
135	OPT_s = 1 << 2,
136	OPT_o = 1 << 3,
137	OPT_t = 1 << 4,
138	OPT_B = 1 << 5,
139	OPT_h = 1 << 6,
140	OPT_u = 1 << 7,
141	OPT_l = 1 << 8, // label
142	OPT_f = 1 << 9, // ask no questions
143	OPT_q = 1 << 10,
144	OPT_d = 1 << 11,
145	//OPT_V = 1 << 12, // -V version. bbox applets don't support that
146	};
147
148	int mkfs_reiser_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
149	int mkfs_reiser_main(int argc UNUSED_PARAM, char **argv)
150	{
151	unsigned blocksize = 4096;
152	unsigned journal_blocks = 8192;
153	unsigned blocks, bitmap_blocks, i, block;
154	time_t timestamp;
155	const char *label = "";
156	struct stat st;
157	int fd;
158	uint8_t *buf;
159	struct reiserfs_super_block *sb;
160	struct journal_params *jp;
161	struct block_head *root;
162
163	// using global "option_mask32" instead of local "opts":
164	// we are register starved here
165	opt_complementary = "-1:b+";
166	/opts =/ getopt32(argv, "b:j:s:o:t:B:h:u:l:fqd",
167	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &label);
168	argv += optind; // argv[0] -- device
169
170	// check the device is a block device
171	fd = xopen(argv[0], O_WRONLY \| O_EXCL);
172	fstat(fd, &st);
173	if (!S_ISBLK(st.st_mode) && !(option_mask32 & OPT_f))
174	bb_error_msg_and_die("not a block device");
175
176	// check if it is mounted
177	// N.B. what if we format a file? find_mount_point will return false negative since
178	// it is loop block device which mounted!
179	if (find_mount_point(argv[0], 0))
180	bb_error_msg_and_die("can't format mounted filesystem");
181
182	// open the device, get size in blocks
183	if (argv[1]) {
184	blocks = xatoull(argv[1]);
185	// seek past end fails on block devices but works on files
186	if (lseek(fd, blocks * blocksize - 1, SEEK_SET) != (off_t)-1) {
187	xwrite(fd, "", 1); // file grows if needed
188	}
189	//else {
190	// bb_error_msg("warning, block device is smaller");
191	//}
192	} else {
193	blocks = (uoff_t)xlseek(fd, 0, SEEK_END) / blocksize;
194	}
195
196	// block number sanity check
197	// we have a limit: skipped area, super block, journal and root block
198	// all have to be addressed by one first bitmap
199	block = REISERFS_DISK_OFFSET_IN_BYTES / blocksize // boot area
200	+ 1 // sb
201	+ 1 // bitmap#0
202	+ journal_blocks+1 // journal
203	;
204
205	// count overhead
206	bitmap_blocks = (blocks - 1) / (blocksize * 8) + 1;
207	i = block + bitmap_blocks;
208
209	// check overhead
210	if (MIN(blocksize * 8, blocks) < i)
211	bb_error_msg_and_die("need >= %u blocks", i);
212
213	// ask confirmation?
214	// TODO: ???
215
216	// wipe out first REISERFS_DISK_OFFSET_IN_BYTES of device
217	// TODO: do we really need to wipe?!
218	xlseek(fd, REISERFS_DISK_OFFSET_IN_BYTES, SEEK_SET);
219
220	// fill superblock
221	sb = (struct reiserfs_super_block *)xzalloc(blocksize);
222	// block count
223	STORE_LE(sb->sb_block_count, blocks);
224	STORE_LE(sb->sb_free_blocks, blocks - i);
225	// TODO: decypher!
226	STORE_LE(sb->sb_root_block, block);
227	// fill journal related fields
228	jp = &sb->sb_journal;
229	STORE_LE(jp->jp_journal_1st_block, REISERFS_DISK_OFFSET_IN_BYTES / blocksize + 1/sb/ + 1/bmp#0/);
230	timestamp = time(NULL);
231	srandom(timestamp);
232	STORE_LE(jp->jp_journal_magic, random());
233	STORE_LE(jp->jp_journal_size, journal_blocks);
234	STORE_LE(jp->jp_journal_trans_max, JOURNAL_TRANS_MAX);
235	STORE_LE(jp->jp_journal_max_batch, JOURNAL_MAX_BATCH);
236	STORE_LE(jp->jp_journal_max_commit_age, JOURNAL_MAX_COMMIT_AGE);
237	// sizes
238	STORE_LE(sb->sb_blocksize, blocksize);
239	STORE_LE(sb->sb_oid_maxsize, (blocksize - sizeof(sb)) / sizeof(uint32_t) / 2 2);
240	STORE_LE(sb->sb_oid_cursize, 2); // "." and ".."
241	strcpy(sb->s_magic, REISERFS_3_6_SUPER_MAGIC_STRING);
242	STORE_LE(sb->sb_bmap_nr, (bitmap_blocks > ((1LL << 16) - 1)) ? 0 : bitmap_blocks);
243	// misc
244	STORE_LE(sb->sb_version, REISERFS_FORMAT_3_6);
245	STORE_LE(sb->sb_lastcheck, timestamp);
246	STORE_LE(sb->sb_check_interval, DEFAULT_CHECK_INTERVAL);
247	STORE_LE(sb->sb_mnt_count, 1);
248	STORE_LE(sb->sb_max_mnt_count, DEFAULT_MAX_MNT_COUNT);
249	STORE_LE(sb->sb_umount_state, FS_CLEANLY_UMOUNTED);
250	STORE_LE(sb->sb_tree_height, 2);
251	STORE_LE(sb->sb_hash_function_code, 3); // R5_HASH
252	STORE_LE(sb->sb_flags, 1);
253	//STORE_LE(sb->sb_reserved_for_journal, 0);
254	// create UUID
255	generate_uuid(sb->s_uuid);
256	// write the label
257	safe_strncpy((char *)sb->s_label, label, sizeof(sb->s_label));
258
259	// TODO: EMPIRIC! ENDIANNESS!
260	// superblock has only 204 bytes. What are these?
261	buf = (uint8_t *)sb;
262	buf[205] = 1;
263	buf[209] = 3;
264
265	// put superblock
266	xwrite(fd, sb, blocksize);
267
268	// create bitmaps
269	buf = xzalloc(blocksize);
270
271	// bitmap #0 uses initial "block"+1 blocks
272	i = block + 1;
273	memset(buf, 0xFF, i / 8);
274	buf[i / 8] = (1 << (i & 7)) - 1; //0..7 => 00000000..01111111
275	// mark trailing absent blocks, if any
276	if (blocks < 8*blocksize) {
277	unsigned n = 8*blocksize - blocks;
278	i = n / 8;
279	buf[blocksize - i - 1] \|= 0x7F00 >> (n & 7); //0..7 => 00000000..11111110
280	memset(buf + blocksize - i, 0xFF, i); // N.B. no overflow here!
281	}
282	// put bitmap #0
283	xwrite(fd, buf, blocksize);
284
285	// now go journal blocks
286	memset(buf, 0, blocksize);
287	for (i = 0; i < journal_blocks; i++)
288	xwrite(fd, buf, blocksize);
289	// dump journal control block
290	memcpy(&((struct reiserfs_journal_header *)buf)->jh_journal, &sb->sb_journal, sizeof(sb->sb_journal));
291	xwrite(fd, buf, blocksize);
292
293	// other bitmaps are in every (8*blocksize)-th block
294	// N.B. they use the only block -- namely bitmap itself!
295	buf[0] = 0x01;
296	// put bitmaps
297	for (i = 1; i < bitmap_blocks; i++) {
298	xlseek(fd, i8blocksize * blocksize, SEEK_SET);
299	// mark trailing absent blocks, if any
300	if (i == bitmap_blocks - 1 && (blocks % (8*blocksize))) {
301	unsigned n = 8blocksize - blocks % (8blocksize);
302	unsigned j = n / 8;
303	buf[blocksize - j - 1] \|= 0x7F00 >> (n & 7); //0..7 => 00000000..11111110
304	memset(buf + blocksize - j, 0xFF, j); // N.B. no overflow here!
305	}
306	xwrite(fd, buf, blocksize);
307	}
308
309	// fill root block
310	// block head
311	memset(buf, 0, blocksize);
312	root = (struct block_head *)buf;
313	STORE_LE(root->blk2_level, 1); // leaf node
314	STORE_LE(root->blk2_nr_item, 2); // "." and ".."
315	STORE_LE(root->blk2_free_space, blocksize - sizeof(struct block_head));
316	// item head
317	// root directory
318	// TODO: EMPIRIC! ENDIANNESS!
319	// TODO: indented assignments seem to be timestamps
320	buf[4] = 0134;
321	buf[24] = 01;
322	buf[28] = 02;
323	buf[42] = 054;
324	buf[44] = 0324;
325	buf[45] = 017;
326	buf[46] = 01;
327	buf[48] = 01;
328	buf[52] = 02;
329	buf[56] = 01;
330	buf[60] = 0364;
331	buf[61] = 01;
332	buf[64] = 02;
333	buf[66] = 060;
334	buf[68] = 0244;
335	buf[69] = 017;
336	buf[4004] = 01;
337	buf[4008] = 01;
338	buf[4012] = 02;
339	buf[4016] = 050;
340	buf[4018] = 04;
341	buf[4020] = 02;
342	buf[4028] = 01;
343	buf[4032] = 040;
344	buf[4034] = 04;
345
346	buf[4036] = 056; buf[4037] = 056; // ".."
347	buf[4044] = 056; // "."
348
349	buf[4052] = 0355;
350	buf[4053] = 0101;
351	buf[4056] = 03;
352	buf[4060] = 060;
353	buf[4076] = 0173;
354	buf[4077] = 0240;
355	buf[4078] = 0344;
356	buf[4079] = 0112;
357	buf[4080] = 0173;
358	buf[4081] = 0240;
359	buf[4082] = 0344;
360	buf[4083] = 0112;
361	buf[4084] = 0173;
362	buf[4085] = 0240;
363	buf[4086] = 0344;
364	buf[4087] = 0112;
365	buf[4088] = 01;
366
367	// put root block
368	xlseek(fd, block * blocksize, SEEK_SET);
369	xwrite(fd, buf, blocksize);
370
371	// cleanup
372	if (ENABLE_FEATURE_CLEAN_UP) {
373	free(buf);
374	free(sb);
375	}
376
377	xclose(fd);
378	return EXIT_SUCCESS;
379	}