mkfs_reiser.c 13 KB

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