Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 2 | /* |
| 3 | * mkfs.c - make a linux (minix) file-system. |
| 4 | * |
Denis Vlasenko | db12d1d | 2008-12-07 00:52:58 +0000 | [diff] [blame] | 5 | * (C) 1991 Linus Torvalds. |
| 6 | * |
Denys Vlasenko | 0ef64bd | 2010-08-16 20:14:46 +0200 | [diff] [blame] | 7 | * Licensed under GPLv2, see file LICENSE in this source tree. |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 8 | */ |
| 9 | |
| 10 | /* |
| 11 | * DD.MM.YY |
| 12 | * |
| 13 | * 24.11.91 - Time began. Used the fsck sources to get started. |
| 14 | * |
| 15 | * 25.11.91 - Corrected some bugs. Added support for ".badblocks" |
| 16 | * The algorithm for ".badblocks" is a bit weird, but |
| 17 | * it should work. Oh, well. |
| 18 | * |
| 19 | * 25.01.92 - Added the -l option for getting the list of bad blocks |
| 20 | * out of a named file. (Dave Rivers, rivers@ponds.uucp) |
| 21 | * |
| 22 | * 28.02.92 - Added %-information when using -c. |
| 23 | * |
| 24 | * 28.02.93 - Added support for other namelengths than the original |
| 25 | * 14 characters so that I can test the new kernel routines.. |
| 26 | * |
| 27 | * 09.10.93 - Make exit status conform to that required by fsutil |
| 28 | * (Rik Faith, faith@cs.unc.edu) |
| 29 | * |
| 30 | * 31.10.93 - Added inode request feature, for backup floppies: use |
| 31 | * 32 inodes, for a news partition use more. |
| 32 | * (Scott Heavner, sdh@po.cwru.edu) |
| 33 | * |
| 34 | * 03.01.94 - Added support for file system valid flag. |
| 35 | * (Dr. Wettstein, greg%wind.uucp@plains.nodak.edu) |
| 36 | * |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 37 | * 30.10.94 - added support for v2 filesystem |
| 38 | * (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de) |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 39 | * |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 40 | * 09.11.94 - Added test to prevent overwrite of mounted fs adapted |
| 41 | * from Theodore Ts'o's (tytso@athena.mit.edu) mke2fs |
| 42 | * program. (Daniel Quinlan, quinlan@yggdrasil.com) |
| 43 | * |
| 44 | * 03.20.95 - Clear first 512 bytes of filesystem to make certain that |
| 45 | * the filesystem is not misidentified as a MS-DOS FAT filesystem. |
| 46 | * (Daniel Quinlan, quinlan@yggdrasil.com) |
| 47 | * |
| 48 | * 02.07.96 - Added small patch from Russell King to make the program a |
| 49 | * good deal more portable (janl@math.uio.no) |
| 50 | * |
| 51 | * Usage: mkfs [-c | -l filename ] [-v] [-nXX] [-iXX] device [size-in-blocks] |
| 52 | * |
Eric Andersen | aff114c | 2004-04-14 17:51:38 +0000 | [diff] [blame] | 53 | * -c for readability checking (SLOW!) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 54 | * -l for getting a list of bad blocks from a file. |
| 55 | * -n for namelength (currently the kernel only uses 14 or 30) |
| 56 | * -i for number of inodes |
| 57 | * -v for v2 filesystem |
| 58 | * |
| 59 | * The device may be a block device or a image of one, but this isn't |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 60 | * enforced (but it's not much fun on a character device :-). |
Erik Andersen | 330fd2b | 2000-05-19 05:35:19 +0000 | [diff] [blame] | 61 | * |
| 62 | * Modified for BusyBox by Erik Andersen <andersen@debian.org> -- |
| 63 | * removed getopt based parser and added a hand rolled one. |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 64 | */ |
Denys Vlasenko | dd898c9 | 2016-11-23 11:46:32 +0100 | [diff] [blame] | 65 | //config:config MKFS_MINIX |
| 66 | //config: bool "mkfs_minix" |
| 67 | //config: default y |
| 68 | //config: select PLATFORM_LINUX |
| 69 | //config: help |
| 70 | //config: The minix filesystem is a nice, small, compact, read-write filesystem |
| 71 | //config: with little overhead. If you wish to be able to create minix |
| 72 | //config: filesystems this utility will do the job for you. |
| 73 | //config: |
| 74 | //config:config FEATURE_MINIX2 |
| 75 | //config: bool "Support Minix fs v2 (fsck_minix/mkfs_minix)" |
| 76 | //config: default y |
| 77 | //config: depends on FSCK_MINIX || MKFS_MINIX |
| 78 | //config: help |
| 79 | //config: If you wish to be able to create version 2 minix filesystems, enable |
| 80 | //config: this. If you enabled 'mkfs_minix' then you almost certainly want to |
| 81 | //config: be using the version 2 filesystem support. |
| 82 | |
Denys Vlasenko | 205d48e | 2017-01-29 14:57:33 +0100 | [diff] [blame] | 83 | // APPLET_ODDNAME:name main location suid_type help |
Denys Vlasenko | dd898c9 | 2016-11-23 11:46:32 +0100 | [diff] [blame] | 84 | //applet:IF_MKFS_MINIX(APPLET_ODDNAME(mkfs.minix, mkfs_minix, BB_DIR_SBIN, BB_SUID_DROP, mkfs_minix)) |
| 85 | |
| 86 | //kbuild:lib-$(CONFIG_MKFS_MINIX) += mkfs_minix.o |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 87 | |
Pere Orga | 5bc8c00 | 2011-04-11 03:29:49 +0200 | [diff] [blame] | 88 | //usage:#define mkfs_minix_trivial_usage |
| 89 | //usage: "[-c | -l FILE] [-nXX] [-iXX] BLOCKDEV [KBYTES]" |
| 90 | //usage:#define mkfs_minix_full_usage "\n\n" |
| 91 | //usage: "Make a MINIX filesystem\n" |
Pere Orga | 5bc8c00 | 2011-04-11 03:29:49 +0200 | [diff] [blame] | 92 | //usage: "\n -c Check device for bad blocks" |
| 93 | //usage: "\n -n [14|30] Maximum length of filenames" |
| 94 | //usage: "\n -i INODES Number of inodes for the filesystem" |
| 95 | //usage: "\n -l FILE Read bad blocks list from FILE" |
| 96 | //usage: "\n -v Make version 2 filesystem" |
| 97 | |
Denis Vlasenko | b6adbf1 | 2007-05-26 19:00:18 +0000 | [diff] [blame] | 98 | #include "libbb.h" |
Rob Landley | d921b2e | 2006-08-03 15:41:12 +0000 | [diff] [blame] | 99 | #include <mntent.h> |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 100 | |
Denis Vlasenko | aa95959 | 2007-01-03 00:43:19 +0000 | [diff] [blame] | 101 | #include "minix.h" |
| 102 | |
Denis Vlasenko | 7ab3699 | 2007-12-02 08:55:34 +0000 | [diff] [blame] | 103 | /* Store the very same times/uids/gids for image consistency */ |
| 104 | #if 1 |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 105 | # define CUR_TIME 0 |
| 106 | # define GETUID 0 |
| 107 | # define GETGID 0 |
| 108 | #else |
Denis Vlasenko | 7ab3699 | 2007-12-02 08:55:34 +0000 | [diff] [blame] | 109 | /* Was using this. Is it useful? NB: this will break testsuite */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 110 | # define CUR_TIME time(NULL) |
| 111 | # define GETUID getuid() |
| 112 | # define GETGID getgid() |
| 113 | #endif |
Eric Andersen | 85c5520 | 2000-07-10 22:46:55 +0000 | [diff] [blame] | 114 | |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 115 | enum { |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 116 | MAX_GOOD_BLOCKS = 512, |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 117 | TEST_BUFFER_BLOCKS = 16, |
| 118 | }; |
Eric Andersen | 85c5520 | 2000-07-10 22:46:55 +0000 | [diff] [blame] | 119 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 120 | #if !ENABLE_FEATURE_MINIX2 |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 121 | enum { version2 = 0 }; |
| 122 | #endif |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 123 | |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 124 | enum { dev_fd = 3 }; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 125 | |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 126 | struct globals { |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 127 | #if ENABLE_FEATURE_MINIX2 |
Denis Vlasenko | ca525b4 | 2007-06-13 12:27:17 +0000 | [diff] [blame] | 128 | smallint version2; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 129 | #define version2 G.version2 |
| 130 | #endif |
| 131 | char *device_name; |
| 132 | uint32_t total_blocks; |
| 133 | int badblocks; |
| 134 | int namelen; |
| 135 | int dirsize; |
| 136 | int magic; |
| 137 | char *inode_buffer; |
| 138 | char *inode_map; |
| 139 | char *zone_map; |
| 140 | int used_good_blocks; |
| 141 | unsigned long req_nr_inodes; |
| 142 | unsigned currently_testing; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 143 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 144 | char root_block[BLOCK_SIZE]; |
Bernhard Reutner-Fischer | e1e5174 | 2008-07-21 13:33:22 +0000 | [diff] [blame] | 145 | char superblock_buffer[BLOCK_SIZE]; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 146 | char boot_block_buffer[512]; |
| 147 | unsigned short good_blocks_table[MAX_GOOD_BLOCKS]; |
Denis Vlasenko | 83bb98f | 2007-03-18 14:43:21 +0000 | [diff] [blame] | 148 | /* check_blocks(): buffer[] was the biggest static in entire bbox */ |
| 149 | char check_blocks_buffer[BLOCK_SIZE * TEST_BUFFER_BLOCKS]; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 150 | |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 151 | unsigned short ind_block1[BLOCK_SIZE >> 1]; |
| 152 | unsigned short dind_block1[BLOCK_SIZE >> 1]; |
| 153 | unsigned long ind_block2[BLOCK_SIZE >> 2]; |
| 154 | unsigned long dind_block2[BLOCK_SIZE >> 2]; |
| 155 | }; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 156 | #define G (*ptr_to_globals) |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 157 | #define INIT_G() do { \ |
Denis Vlasenko | 574f2f4 | 2008-02-27 18:41:59 +0000 | [diff] [blame] | 158 | SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \ |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 159 | } while (0) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 160 | |
Denis Vlasenko | 3ad5d0c | 2007-06-12 20:54:54 +0000 | [diff] [blame] | 161 | static ALWAYS_INLINE unsigned div_roundup(unsigned size, unsigned n) |
Eric Andersen | 56f3e35 | 2000-09-19 21:13:55 +0000 | [diff] [blame] | 162 | { |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 163 | return (size + n-1) / n; |
Eric Andersen | 56f3e35 | 2000-09-19 21:13:55 +0000 | [diff] [blame] | 164 | } |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 165 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 166 | #define INODE_BUF1 (((struct minix1_inode*)G.inode_buffer) - 1) |
| 167 | #define INODE_BUF2 (((struct minix2_inode*)G.inode_buffer) - 1) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 168 | |
Bernhard Reutner-Fischer | e1e5174 | 2008-07-21 13:33:22 +0000 | [diff] [blame] | 169 | #define SB (*(struct minix_superblock*)G.superblock_buffer) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 170 | |
| 171 | #define SB_INODES (SB.s_ninodes) |
| 172 | #define SB_IMAPS (SB.s_imap_blocks) |
| 173 | #define SB_ZMAPS (SB.s_zmap_blocks) |
| 174 | #define SB_FIRSTZONE (SB.s_firstdatazone) |
| 175 | #define SB_ZONE_SIZE (SB.s_log_zone_size) |
| 176 | #define SB_MAXSIZE (SB.s_max_size) |
| 177 | #define SB_MAGIC (SB.s_magic) |
| 178 | |
| 179 | #if !ENABLE_FEATURE_MINIX2 |
| 180 | # define SB_ZONES (SB.s_nzones) |
| 181 | # define INODE_BLOCKS div_roundup(SB_INODES, MINIX1_INODES_PER_BLOCK) |
| 182 | #else |
| 183 | # define SB_ZONES (version2 ? SB.s_zones : SB.s_nzones) |
| 184 | # define INODE_BLOCKS div_roundup(SB_INODES, \ |
Denis Vlasenko | 7049ff8 | 2008-06-25 09:53:17 +0000 | [diff] [blame] | 185 | (version2 ? MINIX2_INODES_PER_BLOCK : MINIX1_INODES_PER_BLOCK)) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 186 | #endif |
| 187 | |
| 188 | #define INODE_BUFFER_SIZE (INODE_BLOCKS * BLOCK_SIZE) |
| 189 | #define NORM_FIRSTZONE (2 + SB_IMAPS + SB_ZMAPS + INODE_BLOCKS) |
| 190 | |
Denis Vlasenko | cc24419 | 2007-02-06 00:37:40 +0000 | [diff] [blame] | 191 | /* Before you ask "where they come from?": */ |
| 192 | /* setbit/clrbit are supplied by sys/param.h */ |
| 193 | |
| 194 | static int minix_bit(const char* a, unsigned i) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 195 | { |
Denis Vlasenko | 12ff9dc | 2008-11-22 18:58:11 +0000 | [diff] [blame] | 196 | return a[i >> 3] & (1<<(i & 7)); |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 197 | } |
| 198 | |
Denis Vlasenko | cc24419 | 2007-02-06 00:37:40 +0000 | [diff] [blame] | 199 | static void minix_setbit(char *a, unsigned i) |
| 200 | { |
| 201 | setbit(a, i); |
| 202 | } |
| 203 | static void minix_clrbit(char *a, unsigned i) |
| 204 | { |
| 205 | clrbit(a, i); |
| 206 | } |
Denis Vlasenko | dc485c9 | 2007-02-06 00:36:53 +0000 | [diff] [blame] | 207 | |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 208 | /* Note: do not assume 0/1, it is 0/nonzero */ |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 209 | #define zone_in_use(x) minix_bit(G.zone_map,(x)-SB_FIRSTZONE+1) |
| 210 | /*#define inode_in_use(x) minix_bit(G.inode_map,(x))*/ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 211 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 212 | #define mark_inode(x) minix_setbit(G.inode_map,(x)) |
| 213 | #define unmark_inode(x) minix_clrbit(G.inode_map,(x)) |
| 214 | #define mark_zone(x) minix_setbit(G.zone_map,(x)-SB_FIRSTZONE+1) |
| 215 | #define unmark_zone(x) minix_clrbit(G.zone_map,(x)-SB_FIRSTZONE+1) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 216 | |
| 217 | #ifndef BLKGETSIZE |
| 218 | # define BLKGETSIZE _IO(0x12,96) /* return device size */ |
| 219 | #endif |
| 220 | |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 221 | static void write_tables(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 222 | { |
Bernhard Reutner-Fischer | e1e5174 | 2008-07-21 13:33:22 +0000 | [diff] [blame] | 223 | /* Mark the superblock valid. */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 224 | SB.s_state |= MINIX_VALID_FS; |
| 225 | SB.s_state &= ~MINIX_ERROR_FS; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 226 | |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 227 | msg_eol = "seek to 0 failed"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 228 | xlseek(dev_fd, 0, SEEK_SET); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 229 | |
Denys Vlasenko | 6331cf0 | 2009-11-13 09:08:27 +0100 | [diff] [blame] | 230 | msg_eol = "can't clear boot sector"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 231 | xwrite(dev_fd, G.boot_block_buffer, 512); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 232 | |
| 233 | msg_eol = "seek to BLOCK_SIZE failed"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 234 | xlseek(dev_fd, BLOCK_SIZE, SEEK_SET); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 235 | |
Denys Vlasenko | 6331cf0 | 2009-11-13 09:08:27 +0100 | [diff] [blame] | 236 | msg_eol = "can't write superblock"; |
Bernhard Reutner-Fischer | e1e5174 | 2008-07-21 13:33:22 +0000 | [diff] [blame] | 237 | xwrite(dev_fd, G.superblock_buffer, BLOCK_SIZE); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 238 | |
Denys Vlasenko | 6331cf0 | 2009-11-13 09:08:27 +0100 | [diff] [blame] | 239 | msg_eol = "can't write inode map"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 240 | xwrite(dev_fd, G.inode_map, SB_IMAPS * BLOCK_SIZE); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 241 | |
Denys Vlasenko | 6331cf0 | 2009-11-13 09:08:27 +0100 | [diff] [blame] | 242 | msg_eol = "can't write zone map"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 243 | xwrite(dev_fd, G.zone_map, SB_ZMAPS * BLOCK_SIZE); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 244 | |
Denys Vlasenko | 6331cf0 | 2009-11-13 09:08:27 +0100 | [diff] [blame] | 245 | msg_eol = "can't write inodes"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 246 | xwrite(dev_fd, G.inode_buffer, INODE_BUFFER_SIZE); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 247 | |
| 248 | msg_eol = "\n"; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 249 | } |
| 250 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 251 | static void write_block(int blk, char *buffer) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 252 | { |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 253 | xlseek(dev_fd, blk * BLOCK_SIZE, SEEK_SET); |
| 254 | xwrite(dev_fd, buffer, BLOCK_SIZE); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 255 | } |
| 256 | |
Eric Andersen | e674eb7 | 1999-10-19 20:52:57 +0000 | [diff] [blame] | 257 | static int get_free_block(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 258 | { |
| 259 | int blk; |
| 260 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 261 | if (G.used_good_blocks + 1 >= MAX_GOOD_BLOCKS) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 262 | bb_error_msg_and_die("too many bad blocks"); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 263 | if (G.used_good_blocks) |
| 264 | blk = G.good_blocks_table[G.used_good_blocks - 1] + 1; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 265 | else |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 266 | blk = SB_FIRSTZONE; |
| 267 | while (blk < SB_ZONES && zone_in_use(blk)) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 268 | blk++; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 269 | if (blk >= SB_ZONES) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 270 | bb_error_msg_and_die("not enough good blocks"); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 271 | G.good_blocks_table[G.used_good_blocks] = blk; |
| 272 | G.used_good_blocks++; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 273 | return blk; |
| 274 | } |
| 275 | |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 276 | static void mark_good_blocks(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 277 | { |
| 278 | int blk; |
| 279 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 280 | for (blk = 0; blk < G.used_good_blocks; blk++) |
| 281 | mark_zone(G.good_blocks_table[blk]); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 282 | } |
| 283 | |
Eric Andersen | 92d2324 | 2001-03-19 23:49:41 +0000 | [diff] [blame] | 284 | static int next(int zone) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 285 | { |
| 286 | if (!zone) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 287 | zone = SB_FIRSTZONE - 1; |
| 288 | while (++zone < SB_ZONES) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 289 | if (zone_in_use(zone)) |
| 290 | return zone; |
| 291 | return 0; |
| 292 | } |
| 293 | |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 294 | static void make_bad_inode(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 295 | { |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 296 | struct minix1_inode *inode = &INODE_BUF1[MINIX_BAD_INO]; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 297 | int i, j, zone; |
| 298 | int ind = 0, dind = 0; |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 299 | /* moved to globals to reduce stack usage |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 300 | unsigned short ind_block[BLOCK_SIZE >> 1]; |
| 301 | unsigned short dind_block[BLOCK_SIZE >> 1]; |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 302 | */ |
| 303 | #define ind_block (G.ind_block1) |
| 304 | #define dind_block (G.dind_block1) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 305 | |
| 306 | #define NEXT_BAD (zone = next(zone)) |
| 307 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 308 | if (!G.badblocks) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 309 | return; |
| 310 | mark_inode(MINIX_BAD_INO); |
| 311 | inode->i_nlinks = 1; |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 312 | /* BTW, setting this makes all images different */ |
| 313 | /* it's harder to check for bugs then - diff isn't helpful :(... */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 314 | inode->i_time = CUR_TIME; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 315 | inode->i_mode = S_IFREG + 0000; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 316 | inode->i_size = G.badblocks * BLOCK_SIZE; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 317 | zone = next(0); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 318 | for (i = 0; i < 7; i++) { |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 319 | inode->i_zone[i] = zone; |
| 320 | if (!NEXT_BAD) |
| 321 | goto end_bad; |
| 322 | } |
| 323 | inode->i_zone[7] = ind = get_free_block(); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 324 | memset(ind_block, 0, BLOCK_SIZE); |
| 325 | for (i = 0; i < 512; i++) { |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 326 | ind_block[i] = zone; |
| 327 | if (!NEXT_BAD) |
| 328 | goto end_bad; |
| 329 | } |
| 330 | inode->i_zone[8] = dind = get_free_block(); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 331 | memset(dind_block, 0, BLOCK_SIZE); |
| 332 | for (i = 0; i < 512; i++) { |
| 333 | write_block(ind, (char *) ind_block); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 334 | dind_block[i] = ind = get_free_block(); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 335 | memset(ind_block, 0, BLOCK_SIZE); |
| 336 | for (j = 0; j < 512; j++) { |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 337 | ind_block[j] = zone; |
| 338 | if (!NEXT_BAD) |
| 339 | goto end_bad; |
| 340 | } |
| 341 | } |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 342 | bb_error_msg_and_die("too many bad blocks"); |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 343 | end_bad: |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 344 | if (ind) |
| 345 | write_block(ind, (char *) ind_block); |
| 346 | if (dind) |
| 347 | write_block(dind, (char *) dind_block); |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 348 | #undef ind_block |
| 349 | #undef dind_block |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 350 | } |
| 351 | |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 352 | #if ENABLE_FEATURE_MINIX2 |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 353 | static void make_bad_inode2(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 354 | { |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 355 | struct minix2_inode *inode = &INODE_BUF2[MINIX_BAD_INO]; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 356 | int i, j, zone; |
| 357 | int ind = 0, dind = 0; |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 358 | /* moved to globals to reduce stack usage |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 359 | unsigned long ind_block[BLOCK_SIZE >> 2]; |
| 360 | unsigned long dind_block[BLOCK_SIZE >> 2]; |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 361 | */ |
| 362 | #define ind_block (G.ind_block2) |
| 363 | #define dind_block (G.dind_block2) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 364 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 365 | if (!G.badblocks) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 366 | return; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 367 | mark_inode(MINIX_BAD_INO); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 368 | inode->i_nlinks = 1; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 369 | inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 370 | inode->i_mode = S_IFREG + 0000; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 371 | inode->i_size = G.badblocks * BLOCK_SIZE; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 372 | zone = next(0); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 373 | for (i = 0; i < 7; i++) { |
| 374 | inode->i_zone[i] = zone; |
| 375 | if (!NEXT_BAD) |
| 376 | goto end_bad; |
| 377 | } |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 378 | inode->i_zone[7] = ind = get_free_block(); |
| 379 | memset(ind_block, 0, BLOCK_SIZE); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 380 | for (i = 0; i < 256; i++) { |
| 381 | ind_block[i] = zone; |
| 382 | if (!NEXT_BAD) |
| 383 | goto end_bad; |
| 384 | } |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 385 | inode->i_zone[8] = dind = get_free_block(); |
| 386 | memset(dind_block, 0, BLOCK_SIZE); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 387 | for (i = 0; i < 256; i++) { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 388 | write_block(ind, (char *) ind_block); |
| 389 | dind_block[i] = ind = get_free_block(); |
| 390 | memset(ind_block, 0, BLOCK_SIZE); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 391 | for (j = 0; j < 256; j++) { |
| 392 | ind_block[j] = zone; |
| 393 | if (!NEXT_BAD) |
| 394 | goto end_bad; |
| 395 | } |
| 396 | } |
| 397 | /* Could make triple indirect block here */ |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 398 | bb_error_msg_and_die("too many bad blocks"); |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 399 | end_bad: |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 400 | if (ind) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 401 | write_block(ind, (char *) ind_block); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 402 | if (dind) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 403 | write_block(dind, (char *) dind_block); |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 404 | #undef ind_block |
| 405 | #undef dind_block |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 406 | } |
Denis Vlasenko | 3bba545 | 2006-12-30 17:57:03 +0000 | [diff] [blame] | 407 | #else |
| 408 | void make_bad_inode2(void); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 409 | #endif |
| 410 | |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 411 | static void make_root_inode(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 412 | { |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 413 | struct minix1_inode *inode = &INODE_BUF1[MINIX_ROOT_INO]; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 414 | |
| 415 | mark_inode(MINIX_ROOT_INO); |
| 416 | inode->i_zone[0] = get_free_block(); |
| 417 | inode->i_nlinks = 2; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 418 | inode->i_time = CUR_TIME; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 419 | if (G.badblocks) |
| 420 | inode->i_size = 3 * G.dirsize; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 421 | else { |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 422 | G.root_block[2 * G.dirsize] = '\0'; |
| 423 | G.root_block[2 * G.dirsize + 1] = '\0'; |
| 424 | inode->i_size = 2 * G.dirsize; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 425 | } |
| 426 | inode->i_mode = S_IFDIR + 0755; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 427 | inode->i_uid = GETUID; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 428 | if (inode->i_uid) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 429 | inode->i_gid = GETGID; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 430 | write_block(inode->i_zone[0], G.root_block); |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 431 | } |
| 432 | |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 433 | #if ENABLE_FEATURE_MINIX2 |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 434 | static void make_root_inode2(void) |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 435 | { |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 436 | struct minix2_inode *inode = &INODE_BUF2[MINIX_ROOT_INO]; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 437 | |
| 438 | mark_inode(MINIX_ROOT_INO); |
| 439 | inode->i_zone[0] = get_free_block(); |
| 440 | inode->i_nlinks = 2; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 441 | inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 442 | if (G.badblocks) |
| 443 | inode->i_size = 3 * G.dirsize; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 444 | else { |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 445 | G.root_block[2 * G.dirsize] = '\0'; |
| 446 | G.root_block[2 * G.dirsize + 1] = '\0'; |
| 447 | inode->i_size = 2 * G.dirsize; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 448 | } |
| 449 | inode->i_mode = S_IFDIR + 0755; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 450 | inode->i_uid = GETUID; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 451 | if (inode->i_uid) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 452 | inode->i_gid = GETGID; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 453 | write_block(inode->i_zone[0], G.root_block); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 454 | } |
Denis Vlasenko | 3bba545 | 2006-12-30 17:57:03 +0000 | [diff] [blame] | 455 | #else |
| 456 | void make_root_inode2(void); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 457 | #endif |
| 458 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 459 | /* |
| 460 | * Perform a test of a block; return the number of |
| 461 | * blocks readable. |
| 462 | */ |
| 463 | static size_t do_check(char *buffer, size_t try, unsigned current_block) |
| 464 | { |
| 465 | ssize_t got; |
| 466 | |
| 467 | /* Seek to the correct loc. */ |
| 468 | msg_eol = "seek failed during testing of blocks"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 469 | xlseek(dev_fd, current_block * BLOCK_SIZE, SEEK_SET); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 470 | msg_eol = "\n"; |
| 471 | |
| 472 | /* Try the read */ |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 473 | got = read(dev_fd, buffer, try * BLOCK_SIZE); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 474 | if (got < 0) |
| 475 | got = 0; |
| 476 | try = ((size_t)got) / BLOCK_SIZE; |
| 477 | |
| 478 | if (got & (BLOCK_SIZE - 1)) |
| 479 | fprintf(stderr, "Short read at block %u\n", (unsigned)(current_block + try)); |
| 480 | return try; |
| 481 | } |
| 482 | |
Denis Vlasenko | a60f84e | 2008-07-05 09:18:54 +0000 | [diff] [blame] | 483 | static void alarm_intr(int alnum UNUSED_PARAM) |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 484 | { |
| 485 | if (G.currently_testing >= SB_ZONES) |
| 486 | return; |
| 487 | signal(SIGALRM, alarm_intr); |
| 488 | alarm(5); |
| 489 | if (!G.currently_testing) |
| 490 | return; |
| 491 | printf("%d ...", G.currently_testing); |
Denys Vlasenko | 8131eea | 2009-11-02 14:19:51 +0100 | [diff] [blame] | 492 | fflush_all(); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 493 | } |
| 494 | |
| 495 | static void check_blocks(void) |
| 496 | { |
| 497 | size_t try, got; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 498 | |
| 499 | G.currently_testing = 0; |
| 500 | signal(SIGALRM, alarm_intr); |
| 501 | alarm(5); |
| 502 | while (G.currently_testing < SB_ZONES) { |
| 503 | msg_eol = "seek failed in check_blocks"; |
Denis Vlasenko | e06f61d | 2008-06-25 10:00:58 +0000 | [diff] [blame] | 504 | xlseek(dev_fd, G.currently_testing * BLOCK_SIZE, SEEK_SET); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 505 | msg_eol = "\n"; |
| 506 | try = TEST_BUFFER_BLOCKS; |
| 507 | if (G.currently_testing + try > SB_ZONES) |
| 508 | try = SB_ZONES - G.currently_testing; |
Denis Vlasenko | 83bb98f | 2007-03-18 14:43:21 +0000 | [diff] [blame] | 509 | got = do_check(G.check_blocks_buffer, try, G.currently_testing); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 510 | G.currently_testing += got; |
| 511 | if (got == try) |
| 512 | continue; |
| 513 | if (G.currently_testing < SB_FIRSTZONE) |
| 514 | bb_error_msg_and_die("bad blocks before data-area: cannot make fs"); |
| 515 | mark_zone(G.currently_testing); |
| 516 | G.badblocks++; |
| 517 | G.currently_testing++; |
| 518 | } |
| 519 | alarm(0); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 520 | printf("%d bad block(s)\n", G.badblocks); |
| 521 | } |
| 522 | |
| 523 | static void get_list_blocks(char *filename) |
| 524 | { |
| 525 | FILE *listfile; |
| 526 | unsigned long blockno; |
| 527 | |
Denis Vlasenko | 5415c85 | 2008-07-21 23:05:26 +0000 | [diff] [blame] | 528 | listfile = xfopen_for_read(filename); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 529 | while (!feof(listfile)) { |
Denys Vlasenko | 327f550 | 2013-11-29 16:45:45 +0100 | [diff] [blame] | 530 | fscanf(listfile, "%lu\n", &blockno); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 531 | mark_zone(blockno); |
| 532 | G.badblocks++; |
| 533 | } |
| 534 | printf("%d bad block(s)\n", G.badblocks); |
| 535 | } |
| 536 | |
Rob Landley | 88621d7 | 2006-08-29 19:41:06 +0000 | [diff] [blame] | 537 | static void setup_tables(void) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 538 | { |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 539 | unsigned long inodes; |
Denis Vlasenko | 016a82e | 2006-11-29 22:47:42 +0000 | [diff] [blame] | 540 | unsigned norm_firstzone; |
Denis Vlasenko | 28bb84b | 2006-11-29 23:15:04 +0000 | [diff] [blame] | 541 | unsigned sb_zmaps; |
| 542 | unsigned i; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 543 | |
Bernhard Reutner-Fischer | e1e5174 | 2008-07-21 13:33:22 +0000 | [diff] [blame] | 544 | /* memset(G.superblock_buffer, 0, BLOCK_SIZE); */ |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 545 | /* memset(G.boot_block_buffer, 0, 512); */ |
| 546 | SB_MAGIC = G.magic; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 547 | SB_ZONE_SIZE = 0; |
| 548 | SB_MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024; |
| 549 | if (version2) |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 550 | SB.s_zones = G.total_blocks; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 551 | else |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 552 | SB.s_nzones = G.total_blocks; |
Eric Andersen | b225e2a | 2004-08-28 00:43:07 +0000 | [diff] [blame] | 553 | |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 554 | /* some magic nrs: 1 inode / 3 blocks */ |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 555 | if (G.req_nr_inodes == 0) |
| 556 | inodes = G.total_blocks / 3; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 557 | else |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 558 | inodes = G.req_nr_inodes; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 559 | /* Round up inode count to fill block size */ |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 560 | if (version2) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 561 | inodes = (inodes + MINIX2_INODES_PER_BLOCK - 1) & |
| 562 | ~(MINIX2_INODES_PER_BLOCK - 1); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 563 | else |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 564 | inodes = (inodes + MINIX1_INODES_PER_BLOCK - 1) & |
| 565 | ~(MINIX1_INODES_PER_BLOCK - 1); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 566 | if (inodes > 65535) |
| 567 | inodes = 65535; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 568 | SB_INODES = inodes; |
| 569 | SB_IMAPS = div_roundup(SB_INODES + 1, BITS_PER_BLOCK); |
| 570 | |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 571 | /* Real bad hack but overwise mkfs.minix can be thrown |
| 572 | * in infinite loop... |
| 573 | * try: |
| 574 | * dd if=/dev/zero of=test.fs count=10 bs=1024 |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 575 | * mkfs.minix -i 200 test.fs |
| 576 | */ |
Denis Vlasenko | 016a82e | 2006-11-29 22:47:42 +0000 | [diff] [blame] | 577 | /* This code is not insane: NORM_FIRSTZONE is not a constant, |
| 578 | * it is calculated from SB_INODES, SB_IMAPS and SB_ZMAPS */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 579 | i = 999; |
| 580 | SB_ZMAPS = 0; |
| 581 | do { |
Denis Vlasenko | 016a82e | 2006-11-29 22:47:42 +0000 | [diff] [blame] | 582 | norm_firstzone = NORM_FIRSTZONE; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 583 | sb_zmaps = div_roundup(G.total_blocks - norm_firstzone + 1, BITS_PER_BLOCK); |
Denis Vlasenko | 016a82e | 2006-11-29 22:47:42 +0000 | [diff] [blame] | 584 | if (SB_ZMAPS == sb_zmaps) goto got_it; |
| 585 | SB_ZMAPS = sb_zmaps; |
| 586 | /* new SB_ZMAPS, need to recalc NORM_FIRSTZONE */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 587 | } while (--i); |
| 588 | bb_error_msg_and_die("incompatible size/inode count, try different -i N"); |
| 589 | got_it: |
| 590 | |
Denis Vlasenko | 016a82e | 2006-11-29 22:47:42 +0000 | [diff] [blame] | 591 | SB_FIRSTZONE = norm_firstzone; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 592 | G.inode_map = xmalloc(SB_IMAPS * BLOCK_SIZE); |
| 593 | G.zone_map = xmalloc(SB_ZMAPS * BLOCK_SIZE); |
| 594 | memset(G.inode_map, 0xff, SB_IMAPS * BLOCK_SIZE); |
| 595 | memset(G.zone_map, 0xff, SB_ZMAPS * BLOCK_SIZE); |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 596 | for (i = SB_FIRSTZONE; i < SB_ZONES; i++) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 597 | unmark_zone(i); |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 598 | for (i = MINIX_ROOT_INO; i <= SB_INODES; i++) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 599 | unmark_inode(i); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 600 | G.inode_buffer = xzalloc(INODE_BUFFER_SIZE); |
Denys Vlasenko | 7f3a2a2 | 2015-10-08 11:24:44 +0200 | [diff] [blame] | 601 | printf("%lu inodes\n", (unsigned long)SB_INODES); |
| 602 | printf("%lu blocks\n", (unsigned long)SB_ZONES); |
| 603 | printf("Firstdatazone=%lu (%lu)\n", (unsigned long)SB_FIRSTZONE, (unsigned long)norm_firstzone); |
| 604 | printf("Zonesize=%u\n", BLOCK_SIZE << SB_ZONE_SIZE); |
| 605 | printf("Maxsize=%lu\n", (unsigned long)SB_MAXSIZE); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 606 | } |
| 607 | |
Denis Vlasenko | 9b49a5e | 2007-10-11 10:05:36 +0000 | [diff] [blame] | 608 | int mkfs_minix_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
Denis Vlasenko | a60f84e | 2008-07-05 09:18:54 +0000 | [diff] [blame] | 609 | int mkfs_minix_main(int argc UNUSED_PARAM, char **argv) |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 610 | { |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 611 | unsigned opt; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 612 | char *tmp; |
Denis Vlasenko | 1d42665 | 2008-03-17 09:09:09 +0000 | [diff] [blame] | 613 | char *str_i; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 614 | char *listfile = NULL; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 615 | |
Denis Vlasenko | ab80187 | 2007-12-02 08:35:37 +0000 | [diff] [blame] | 616 | INIT_G(); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 617 | /* default (changed to 30, per Linus's suggestion, Sun Nov 21 08:05:07 1993) */ |
| 618 | G.namelen = 30; |
| 619 | G.dirsize = 32; |
| 620 | G.magic = MINIX1_SUPER_MAGIC2; |
| 621 | |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 622 | if (INODE_SIZE1 * MINIX1_INODES_PER_BLOCK != BLOCK_SIZE) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 623 | bb_error_msg_and_die("bad inode size"); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 624 | #if ENABLE_FEATURE_MINIX2 |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 625 | if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 626 | bb_error_msg_and_die("bad inode size"); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 627 | #endif |
Eric Andersen | c7bda1c | 2004-03-15 08:29:22 +0000 | [diff] [blame] | 628 | |
Denys Vlasenko | 237bedd | 2016-07-06 21:58:02 +0200 | [diff] [blame] | 629 | opt = getopt32(argv, "ci:l:n:+v", &str_i, &listfile, &G.namelen); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 630 | argv += optind; |
| 631 | //if (opt & 1) -c |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 632 | if (opt & 2) G.req_nr_inodes = xatoul(str_i); // -i |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 633 | //if (opt & 4) -l |
| 634 | if (opt & 8) { // -n |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 635 | if (G.namelen == 14) G.magic = MINIX1_SUPER_MAGIC; |
| 636 | else if (G.namelen == 30) G.magic = MINIX1_SUPER_MAGIC2; |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 637 | else bb_show_usage(); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 638 | G.dirsize = G.namelen + 2; |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 639 | } |
| 640 | if (opt & 0x10) { // -v |
| 641 | #if ENABLE_FEATURE_MINIX2 |
| 642 | version2 = 1; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 643 | #else |
Denis Vlasenko | dc485c9 | 2007-02-06 00:36:53 +0000 | [diff] [blame] | 644 | bb_error_msg_and_die("not compiled with minix v2 support"); |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 645 | #endif |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 646 | } |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 647 | |
Denys Vlasenko | 7c6f2d4 | 2013-03-18 02:26:58 +0100 | [diff] [blame] | 648 | G.device_name = argv[0]; |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 649 | if (!G.device_name) |
Manuel Novoa III | cad5364 | 2003-03-19 09:13:01 +0000 | [diff] [blame] | 650 | bb_show_usage(); |
Denys Vlasenko | 7c6f2d4 | 2013-03-18 02:26:58 +0100 | [diff] [blame] | 651 | |
| 652 | /* Check if it is mounted */ |
| 653 | if (find_mount_point(G.device_name, 0)) |
| 654 | bb_error_msg_and_die("can't format mounted filesystem"); |
| 655 | |
| 656 | xmove_fd(xopen(G.device_name, O_RDWR), dev_fd); |
| 657 | |
| 658 | G.total_blocks = get_volume_size_in_bytes(dev_fd, argv[1], 1024, /*extend:*/ 1) / 1024; |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 659 | |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 660 | if (G.total_blocks < 10) |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 661 | bb_error_msg_and_die("must have at least 10 blocks"); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 662 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 663 | if (version2) { |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 664 | G.magic = MINIX2_SUPER_MAGIC2; |
| 665 | if (G.namelen == 14) |
| 666 | G.magic = MINIX2_SUPER_MAGIC; |
| 667 | } else if (G.total_blocks > 65535) |
| 668 | G.total_blocks = 65535; |
Denys Vlasenko | 7c6f2d4 | 2013-03-18 02:26:58 +0100 | [diff] [blame] | 669 | #if 0 |
| 670 | struct stat statbuf; |
Denys Vlasenko | 8d3e225 | 2010-08-31 12:42:06 +0200 | [diff] [blame] | 671 | xfstat(dev_fd, &statbuf, G.device_name); |
Denys Vlasenko | 7c6f2d4 | 2013-03-18 02:26:58 +0100 | [diff] [blame] | 672 | /* why? */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 673 | if (!S_ISBLK(statbuf.st_mode)) |
| 674 | opt &= ~1; // clear -c (check) |
Denys Vlasenko | 7c6f2d4 | 2013-03-18 02:26:58 +0100 | [diff] [blame] | 675 | #if 0 |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 676 | /* I don't know why someone has special code to prevent mkfs.minix |
| 677 | * on IDE devices. Why IDE but not SCSI, etc?... */ |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 678 | else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340) |
| 679 | /* what is this? */ |
| 680 | bb_error_msg_and_die("will not try " |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 681 | "to make filesystem on '%s'", G.device_name); |
Denis Vlasenko | 66b86c6 | 2006-11-29 22:33:47 +0000 | [diff] [blame] | 682 | #endif |
Denys Vlasenko | 7c6f2d4 | 2013-03-18 02:26:58 +0100 | [diff] [blame] | 683 | #endif |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 684 | tmp = G.root_block; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 685 | *(short *) tmp = 1; |
| 686 | strcpy(tmp + 2, "."); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 687 | tmp += G.dirsize; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 688 | *(short *) tmp = 1; |
| 689 | strcpy(tmp + 2, ".."); |
Denis Vlasenko | 4efeaee | 2007-03-15 19:52:42 +0000 | [diff] [blame] | 690 | tmp += G.dirsize; |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 691 | *(short *) tmp = 2; |
| 692 | strcpy(tmp + 2, ".badblocks"); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 693 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 694 | setup_tables(); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 695 | |
| 696 | if (opt & 1) // -c ? |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 697 | check_blocks(); |
| 698 | else if (listfile) |
| 699 | get_list_blocks(listfile); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 700 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 701 | if (version2) { |
| 702 | make_root_inode2(); |
| 703 | make_bad_inode2(); |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 704 | } else { |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 705 | make_root_inode(); |
| 706 | make_bad_inode(); |
| 707 | } |
Denis Vlasenko | c6ce873 | 2006-11-29 18:15:52 +0000 | [diff] [blame] | 708 | |
Erik Andersen | e49d5ec | 2000-02-08 19:58:47 +0000 | [diff] [blame] | 709 | mark_good_blocks(); |
| 710 | write_tables(); |
"Vladimir N. Oleynik" | 1f2dc40 | 2005-10-15 13:56:17 +0000 | [diff] [blame] | 711 | return 0; |
Eric Andersen | e494fdd | 1999-10-19 20:23:03 +0000 | [diff] [blame] | 712 | } |