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