util-linux/mkfs_minix.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * mkfs.c - make a linux (minix) file-system.
   4  *
   5  * (C) 1991 Linus Torvalds. This file may be redistributed as per
   6  * the Linux copyright.
   7  */
   8
   9 /*
  10  * DD.MM.YY
  11  *
  12  * 24.11.91  -  Time began. Used the fsck sources to get started.
  13  *
  14  * 25.11.91  -  Corrected some bugs. Added support for ".badblocks"
  15  *              The algorithm for ".badblocks" is a bit weird, but
  16  *              it should work. Oh, well.
  17  *
  18  * 25.01.92  -  Added the -l option for getting the list of bad blocks
  19  *              out of a named file. (Dave Rivers, rivers@ponds.uucp)
  20  *
  21  * 28.02.92  -  Added %-information when using -c.
  22  *
  23  * 28.02.93  -  Added support for other namelengths than the original
  24  *              14 characters so that I can test the new kernel routines..
  25  *
  26  * 09.10.93  -  Make exit status conform to that required by fsutil
  27  *              (Rik Faith, faith@cs.unc.edu)
  28  *
  29  * 31.10.93  -  Added inode request feature, for backup floppies: use
  30  *              32 inodes, for a news partition use more.
  31  *              (Scott Heavner, sdh@po.cwru.edu)
  32  *
  33  * 03.01.94  -  Added support for file system valid flag.
  34  *              (Dr. Wettstein, greg%wind.uucp@plains.nodak.edu)
  35  *
  36  * 30.10.94  -  added support for v2 filesystem
  37  *              (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de)
  38  *
  39  * 09.11.94  -  Added test to prevent overwrite of mounted fs adapted
  40  *              from Theodore Ts'o's (tytso@athena.mit.edu) mke2fs
  41  *              program.  (Daniel Quinlan, quinlan@yggdrasil.com)
  42  *
  43  * 03.20.95  -  Clear first 512 bytes of filesystem to make certain that
  44  *              the filesystem is not misidentified as a MS-DOS FAT filesystem.
  45  *              (Daniel Quinlan, quinlan@yggdrasil.com)
  46  *
  47  * 02.07.96  -  Added small patch from Russell King to make the program a
  48  *              good deal more portable (janl@math.uio.no)
  49  *
  50  * Usage:  mkfs [-c | -l filename ] [-v] [-nXX] [-iXX] device [size-in-blocks]
  51  *
  52  *      -c for readability checking (SLOW!)
  53  *      -l for getting a list of bad blocks from a file.
  54  *      -n for namelength (currently the kernel only uses 14 or 30)
  55  *      -i for number of inodes
  56  *      -v for v2 filesystem
  57  *
  58  * The device may be a block device or a image of one, but this isn't
  59  * enforced (but it's not much fun on a character device :-).
  60  *
  61  * Modified for BusyBox by Erik Andersen <andersen@debian.org> --
  62  *      removed getopt based parser and added a hand rolled one.
  63  */
  64
  65 #include "busybox.h"
  66 #include <mntent.h>
  67
  68 #define DEBUG 0
  69
  70 /* If debugging, store the very same times/uids/gids for image consistency */
  71 #if DEBUG
  72 # define CUR_TIME 0
  73 # define GETUID 0
  74 # define GETGID 0
  75 #else
  76 # define CUR_TIME time(NULL)
  77 # define GETUID getuid()
  78 # define GETGID getgid()
  79 #endif
  80
  81 /*
  82  * This is the original minix inode layout on disk.
  83  * Note the 8-bit gid and atime and ctime.
  84  */
  85 struct minix1_inode {
  86         uint16_t i_mode;
  87         uint16_t i_uid;
  88         uint32_t i_size;
  89         uint32_t i_time;
  90         uint8_t  i_gid;
  91         uint8_t  i_nlinks;
  92         uint16_t i_zone[9];
  93 };
  94
  95 /*
  96  * The new minix inode has all the time entries, as well as
  97  * long block numbers and a third indirect block (7+1+1+1
  98  * instead of 7+1+1). Also, some previously 8-bit values are
  99  * now 16-bit. The inode is now 64 bytes instead of 32.
 100  */
 101 struct minix2_inode {
 102         uint16_t i_mode;
 103         uint16_t i_nlinks;
 104         uint16_t i_uid;
 105         uint16_t i_gid;
 106         uint32_t i_size;
 107         uint32_t i_atime;
 108         uint32_t i_mtime;
 109         uint32_t i_ctime;
 110         uint32_t i_zone[10];
 111 };
 112
 113 /*
 114  * minix super-block data on disk
 115  */
 116 struct minix_super_block {
 117         uint16_t s_ninodes;
 118         uint16_t s_nzones;
 119         uint16_t s_imap_blocks;
 120         uint16_t s_zmap_blocks;
 121         uint16_t s_firstdatazone;
 122         uint16_t s_log_zone_size;
 123         uint32_t s_max_size;
 124         uint16_t s_magic;
 125         uint16_t s_state;
 126         uint32_t s_zones;
 127 };
 128
 129 struct minix_dir_entry {
 130         uint16_t inode;
 131         char name[0];
 132 };
 133
 134 /* Believe it or not, but mount.h has this one */
 135 #undef BLOCK_SIZE
 136 enum {
 137         BLOCK_SIZE              = 1024,
 138         BITS_PER_BLOCK          = BLOCK_SIZE << 3,
 139
 140         MINIX_ROOT_INO          = 1,
 141         MINIX_BAD_INO           = 2,
 142         MAX_GOOD_BLOCKS         = 512,
 143
 144         MINIX1_SUPER_MAGIC      = 0x137F,       /* original minix fs */
 145         MINIX1_SUPER_MAGIC2     = 0x138F,       /* minix fs, 30 char names */
 146         MINIX2_SUPER_MAGIC      = 0x2468,       /* minix V2 fs */
 147         MINIX2_SUPER_MAGIC2     = 0x2478,       /* minix V2 fs, 30 char names */
 148         MINIX_VALID_FS          = 0x0001,       /* clean fs */
 149         MINIX_ERROR_FS          = 0x0002,       /* fs has errors */
 150
 151         INODE_SIZE1             = sizeof(struct minix1_inode),
 152         INODE_SIZE2             = sizeof(struct minix2_inode),
 153         MINIX1_INODES_PER_BLOCK = BLOCK_SIZE / sizeof(struct minix1_inode),
 154         MINIX2_INODES_PER_BLOCK = BLOCK_SIZE / sizeof(struct minix2_inode),
 155
 156         TEST_BUFFER_BLOCKS      = 16,
 157 };
 158
 159 #if ENABLE_FEATURE_MINIX2
 160 static int version2;
 161 #else
 162 enum { version2 = 0 };
 163 #endif
 164
 165 static char *device_name;
 166 static int dev_fd = -1;
 167 static uint32_t total_blocks;
 168 static int badblocks;
 169 /* default (changed to 30, per Linus's suggestion, Sun Nov 21 08:05:07 1993) */
 170 static int namelen = 30;
 171 static int dirsize = 32;
 172 static int magic = MINIX1_SUPER_MAGIC2;
 173
 174 static char root_block[BLOCK_SIZE];
 175 static char super_block_buffer[BLOCK_SIZE];
 176 static char boot_block_buffer[512];
 177 static char *inode_buffer;
 178
 179 static char *inode_map;
 180 static char *zone_map;
 181
 182 static int used_good_blocks;
 183 static unsigned short good_blocks_table[MAX_GOOD_BLOCKS];
 184 static unsigned long req_nr_inodes;
 185
 186 extern inline unsigned div_roundup(unsigned size, unsigned n)
 187 {
 188         return (size + n-1) / n;
 189 }
 190
 191 #define INODE_BUF1              (((struct minix1_inode*)inode_buffer) - 1)
 192 #define INODE_BUF2              (((struct minix2_inode*)inode_buffer) - 1)
 193
 194 #define SB                      (*(struct minix_super_block*)super_block_buffer)
 195
 196 #define SB_INODES               (SB.s_ninodes)
 197 #define SB_IMAPS                (SB.s_imap_blocks)
 198 #define SB_ZMAPS                (SB.s_zmap_blocks)
 199 #define SB_FIRSTZONE            (SB.s_firstdatazone)
 200 #define SB_ZONE_SIZE            (SB.s_log_zone_size)
 201 #define SB_MAXSIZE              (SB.s_max_size)
 202 #define SB_MAGIC                (SB.s_magic)
 203
 204 #if !ENABLE_FEATURE_MINIX2
 205 # define SB_ZONES               (SB.s_nzones)
 206 # define INODE_BLOCKS           div_roundup(SB_INODES, MINIX1_INODES_PER_BLOCK)
 207 #else
 208 # define SB_ZONES               (version2 ? SB.s_zones : SB.s_nzones)
 209 # define INODE_BLOCKS           div_roundup(SB_INODES, \
 210                                 version2 ? MINIX2_INODES_PER_BLOCK : MINIX1_INODES_PER_BLOCK)
 211 #endif
 212
 213 #define INODE_BUFFER_SIZE       (INODE_BLOCKS * BLOCK_SIZE)
 214 #define NORM_FIRSTZONE          (2 + SB_IMAPS + SB_ZMAPS + INODE_BLOCKS)
 215
 216 static int bit(const char* a, unsigned i)
 217 {
 218           return a[i >> 3] & (1<<(i & 7));
 219 }
 220
 221 /* Note: do not assume 0/1, it is 0/nonzero */
 222 #define inode_in_use(x) bit(inode_map,(x))
 223 #define zone_in_use(x)  bit(zone_map,(x)-SB_FIRSTZONE+1)
 224
 225 #define mark_inode(x)   setbit(inode_map,(x))
 226 #define unmark_inode(x) clrbit(inode_map,(x))
 227 #define mark_zone(x)    setbit(zone_map,(x)-SB_FIRSTZONE+1)
 228 #define unmark_zone(x)  clrbit(zone_map,(x)-SB_FIRSTZONE+1)
 229
 230 #ifndef BLKGETSIZE
 231 # define BLKGETSIZE     _IO(0x12,96)    /* return device size */
 232 #endif
 233
 234
 235 static long valid_offset(int fd, int offset)
 236 {
 237         char ch;
 238
 239         if (lseek(fd, offset, SEEK_SET) < 0)
 240                 return 0;
 241         if (read(fd, &ch, 1) < 1)
 242                 return 0;
 243         return 1;
 244 }
 245
 246 static int count_blocks(int fd)
 247 {
 248         int high, low;
 249
 250         low = 0;
 251         for (high = 1; valid_offset(fd, high); high *= 2)
 252                 low = high;
 253
 254         while (low < high - 1) {
 255                 const int mid = (low + high) / 2;
 256
 257                 if (valid_offset(fd, mid))
 258                         low = mid;
 259                 else
 260                         high = mid;
 261         }
 262         valid_offset(fd, 0);
 263         return (low + 1);
 264 }
 265
 266 static int get_size(const char *file)
 267 {
 268         int fd;
 269         long size;
 270
 271         fd = xopen(file, O_RDWR);
 272         if (ioctl(fd, BLKGETSIZE, &size) >= 0) {
 273                 close(fd);
 274                 return (size * 512);
 275         }
 276
 277         size = count_blocks(fd);
 278         close(fd);
 279         return size;
 280 }
 281
 282 static void write_tables(void)
 283 {
 284         /* Mark the super block valid. */
 285         SB.s_state |= MINIX_VALID_FS;
 286         SB.s_state &= ~MINIX_ERROR_FS;
 287
 288         msg_eol = "seek to 0 failed";
 289         xlseek(dev_fd, 0, SEEK_SET);
 290
 291         msg_eol = "cannot clear boot sector";
 292         xwrite(dev_fd, boot_block_buffer, 512);
 293
 294         msg_eol = "seek to BLOCK_SIZE failed";
 295         xlseek(dev_fd, BLOCK_SIZE, SEEK_SET);
 296
 297         msg_eol = "cannot write superblock";
 298         xwrite(dev_fd, super_block_buffer, BLOCK_SIZE);
 299
 300         msg_eol = "cannot write inode map";
 301         xwrite(dev_fd, inode_map, SB_IMAPS * BLOCK_SIZE);
 302
 303         msg_eol = "cannot write zone map";
 304         xwrite(dev_fd, zone_map, SB_ZMAPS * BLOCK_SIZE);
 305
 306         msg_eol = "cannot write inodes";
 307         xwrite(dev_fd, inode_buffer, INODE_BUFFER_SIZE);
 308
 309         msg_eol = "\n";
 310 }
 311
 312 static void write_block(int blk, char *buffer)
 313 {
 314         xlseek(dev_fd, blk * BLOCK_SIZE, SEEK_SET);
 315         xwrite(dev_fd, buffer, BLOCK_SIZE);
 316 }
 317
 318 static int get_free_block(void)
 319 {
 320         int blk;
 321
 322         if (used_good_blocks + 1 >= MAX_GOOD_BLOCKS)
 323                 bb_error_msg_and_die("too many bad blocks");
 324         if (used_good_blocks)
 325                 blk = good_blocks_table[used_good_blocks - 1] + 1;
 326         else
 327                 blk = SB_FIRSTZONE;
 328         while (blk < SB_ZONES && zone_in_use(blk))
 329                 blk++;
 330         if (blk >= SB_ZONES)
 331                 bb_error_msg_and_die("not enough good blocks");
 332         good_blocks_table[used_good_blocks] = blk;
 333         used_good_blocks++;
 334         return blk;
 335 }
 336
 337 static void mark_good_blocks(void)
 338 {
 339         int blk;
 340
 341         for (blk = 0; blk < used_good_blocks; blk++)
 342                 mark_zone(good_blocks_table[blk]);
 343 }
 344
 345 static int next(int zone)
 346 {
 347         if (!zone)
 348                 zone = SB_FIRSTZONE - 1;
 349         while (++zone < SB_ZONES)
 350                 if (zone_in_use(zone))
 351                         return zone;
 352         return 0;
 353 }
 354
 355 static void make_bad_inode(void)
 356 {
 357         struct minix1_inode *inode = &INODE_BUF1[MINIX_BAD_INO];
 358         int i, j, zone;
 359         int ind = 0, dind = 0;
 360         unsigned short ind_block[BLOCK_SIZE >> 1];
 361         unsigned short dind_block[BLOCK_SIZE >> 1];
 362
 363 #define NEXT_BAD (zone = next(zone))
 364
 365         if (!badblocks)
 366                 return;
 367         mark_inode(MINIX_BAD_INO);
 368         inode->i_nlinks = 1;
 369         /* BTW, setting this makes all images different */
 370         /* it's harder to check for bugs then - diff isn't helpful :(... */
 371         inode->i_time = CUR_TIME;
 372         inode->i_mode = S_IFREG + 0000;
 373         inode->i_size = badblocks * BLOCK_SIZE;
 374         zone = next(0);
 375         for (i = 0; i < 7; i++) {
 376                 inode->i_zone[i] = zone;
 377                 if (!NEXT_BAD)
 378                         goto end_bad;
 379         }
 380         inode->i_zone[7] = ind = get_free_block();
 381         memset(ind_block, 0, BLOCK_SIZE);
 382         for (i = 0; i < 512; i++) {
 383                 ind_block[i] = zone;
 384                 if (!NEXT_BAD)
 385                         goto end_bad;
 386         }
 387         inode->i_zone[8] = dind = get_free_block();
 388         memset(dind_block, 0, BLOCK_SIZE);
 389         for (i = 0; i < 512; i++) {
 390                 write_block(ind, (char *) ind_block);
 391                 dind_block[i] = ind = get_free_block();
 392                 memset(ind_block, 0, BLOCK_SIZE);
 393                 for (j = 0; j < 512; j++) {
 394                         ind_block[j] = zone;
 395                         if (!NEXT_BAD)
 396                                 goto end_bad;
 397                 }
 398         }
 399         bb_error_msg_and_die("too many bad blocks");
 400  end_bad:
 401         if (ind)
 402                 write_block(ind, (char *) ind_block);
 403         if (dind)
 404                 write_block(dind, (char *) dind_block);
 405 }
 406
 407 #if ENABLE_FEATURE_MINIX2
 408 static void make_bad_inode2(void)
 409 {
 410         struct minix2_inode *inode = &INODE_BUF2[MINIX_BAD_INO];
 411         int i, j, zone;
 412         int ind = 0, dind = 0;
 413         unsigned long ind_block[BLOCK_SIZE >> 2];
 414         unsigned long dind_block[BLOCK_SIZE >> 2];
 415
 416         if (!badblocks)
 417                 return;
 418         mark_inode(MINIX_BAD_INO);
 419         inode->i_nlinks = 1;
 420         inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME;
 421         inode->i_mode = S_IFREG + 0000;
 422         inode->i_size = badblocks * BLOCK_SIZE;
 423         zone = next(0);
 424         for (i = 0; i < 7; i++) {
 425                 inode->i_zone[i] = zone;
 426                 if (!NEXT_BAD)
 427                         goto end_bad;
 428         }
 429         inode->i_zone[7] = ind = get_free_block();
 430         memset(ind_block, 0, BLOCK_SIZE);
 431         for (i = 0; i < 256; i++) {
 432                 ind_block[i] = zone;
 433                 if (!NEXT_BAD)
 434                         goto end_bad;
 435         }
 436         inode->i_zone[8] = dind = get_free_block();
 437         memset(dind_block, 0, BLOCK_SIZE);
 438         for (i = 0; i < 256; i++) {
 439                 write_block(ind, (char *) ind_block);
 440                 dind_block[i] = ind = get_free_block();
 441                 memset(ind_block, 0, BLOCK_SIZE);
 442                 for (j = 0; j < 256; j++) {
 443                         ind_block[j] = zone;
 444                         if (!NEXT_BAD)
 445                                 goto end_bad;
 446                 }
 447         }
 448         /* Could make triple indirect block here */
 449         bb_error_msg_and_die("too many bad blocks");
 450  end_bad:
 451         if (ind)
 452                 write_block(ind, (char *) ind_block);
 453         if (dind)
 454                 write_block(dind, (char *) dind_block);
 455 }
 456 #endif
 457
 458 static void make_root_inode(void)
 459 {
 460         struct minix1_inode *inode = &INODE_BUF1[MINIX_ROOT_INO];
 461
 462         mark_inode(MINIX_ROOT_INO);
 463         inode->i_zone[0] = get_free_block();
 464         inode->i_nlinks = 2;
 465         inode->i_time = CUR_TIME;
 466         if (badblocks)
 467                 inode->i_size = 3 * dirsize;
 468         else {
 469                 root_block[2 * dirsize] = '\0';
 470                 root_block[2 * dirsize + 1] = '\0';
 471                 inode->i_size = 2 * dirsize;
 472         }
 473         inode->i_mode = S_IFDIR + 0755;
 474         inode->i_uid = GETUID;
 475         if (inode->i_uid)
 476                 inode->i_gid = GETGID;
 477         write_block(inode->i_zone[0], root_block);
 478 }
 479
 480 #if ENABLE_FEATURE_MINIX2
 481 static void make_root_inode2(void)
 482 {
 483         struct minix2_inode *inode = &INODE_BUF2[MINIX_ROOT_INO];
 484
 485         mark_inode(MINIX_ROOT_INO);
 486         inode->i_zone[0] = get_free_block();
 487         inode->i_nlinks = 2;
 488         inode->i_atime = inode->i_mtime = inode->i_ctime = CUR_TIME;
 489         if (badblocks)
 490                 inode->i_size = 3 * dirsize;
 491         else {
 492                 root_block[2 * dirsize] = '\0';
 493                 root_block[2 * dirsize + 1] = '\0';
 494                 inode->i_size = 2 * dirsize;
 495         }
 496         inode->i_mode = S_IFDIR + 0755;
 497         inode->i_uid = GETUID;
 498         if (inode->i_uid)
 499                 inode->i_gid = GETGID;
 500         write_block(inode->i_zone[0], root_block);
 501 }
 502 #endif
 503
 504 static void setup_tables(void)
 505 {
 506         unsigned long inodes;
 507         unsigned norm_firstzone;
 508         unsigned sb_zmaps;
 509         unsigned i;
 510
 511         memset(super_block_buffer, 0, BLOCK_SIZE);
 512         memset(boot_block_buffer, 0, 512);
 513         SB_MAGIC = magic;
 514         SB_ZONE_SIZE = 0;
 515         SB_MAXSIZE = version2 ? 0x7fffffff : (7 + 512 + 512 * 512) * 1024;
 516         if (version2)
 517                 SB.s_zones = total_blocks;
 518         else
 519                 SB.s_nzones = total_blocks;
 520
 521         /* some magic nrs: 1 inode / 3 blocks */
 522         if (req_nr_inodes == 0)
 523                 inodes = total_blocks / 3;
 524         else
 525                 inodes = req_nr_inodes;
 526         /* Round up inode count to fill block size */
 527         if (version2)
 528                 inodes = (inodes + MINIX2_INODES_PER_BLOCK - 1) &
 529                                  ~(MINIX2_INODES_PER_BLOCK - 1);
 530         else
 531                 inodes = (inodes + MINIX1_INODES_PER_BLOCK - 1) &
 532                                  ~(MINIX1_INODES_PER_BLOCK - 1);
 533         if (inodes > 65535)
 534                 inodes = 65535;
 535         SB_INODES = inodes;
 536         SB_IMAPS = div_roundup(SB_INODES + 1, BITS_PER_BLOCK);
 537
 538         /* Real bad hack but overwise mkfs.minix can be thrown
 539          * in infinite loop...
 540          * try:
 541          * dd if=/dev/zero of=test.fs count=10 bs=1024
 542          * mkfs.minix -i 200 test.fs
 543          */
 544         /* This code is not insane: NORM_FIRSTZONE is not a constant,
 545          * it is calculated from SB_INODES, SB_IMAPS and SB_ZMAPS */
 546         i = 999;
 547         SB_ZMAPS = 0;
 548         do {
 549                 norm_firstzone = NORM_FIRSTZONE;
 550                 sb_zmaps = div_roundup(total_blocks - norm_firstzone + 1, BITS_PER_BLOCK);
 551                 if (SB_ZMAPS == sb_zmaps) goto got_it;
 552                 SB_ZMAPS = sb_zmaps;
 553                 /* new SB_ZMAPS, need to recalc NORM_FIRSTZONE */
 554         } while (--i);
 555         bb_error_msg_and_die("incompatible size/inode count, try different -i N");
 556  got_it:
 557
 558         SB_FIRSTZONE = norm_firstzone;
 559         inode_map = xmalloc(SB_IMAPS * BLOCK_SIZE);
 560         zone_map = xmalloc(SB_ZMAPS * BLOCK_SIZE);
 561         memset(inode_map, 0xff, SB_IMAPS * BLOCK_SIZE);
 562         memset(zone_map, 0xff, SB_ZMAPS * BLOCK_SIZE);
 563         for (i = SB_FIRSTZONE; i < SB_ZONES; i++)
 564                 unmark_zone(i);
 565         for (i = MINIX_ROOT_INO; i <= SB_INODES; i++)
 566                 unmark_inode(i);
 567         inode_buffer = xzalloc(INODE_BUFFER_SIZE);
 568         printf("%ld inodes\n", (long)SB_INODES);
 569         printf("%ld blocks\n", (long)SB_ZONES);
 570         printf("Firstdatazone=%ld (%ld)\n", (long)SB_FIRSTZONE, (long)norm_firstzone);
 571         printf("Zonesize=%d\n", BLOCK_SIZE << SB_ZONE_SIZE);
 572         printf("Maxsize=%ld\n", (long)SB_MAXSIZE);
 573 }
 574
 575 /*
 576  * Perform a test of a block; return the number of
 577  * blocks readable/writable.
 578  */
 579 static long do_check(char *buffer, int try, unsigned current_block)
 580 {
 581         long got;
 582
 583         /* Seek to the correct loc. */
 584         msg_eol = "seek failed during testing of blocks";
 585         xlseek(dev_fd, current_block * BLOCK_SIZE, SEEK_SET);
 586         msg_eol = "\n";
 587
 588         /* Try the read */
 589         got = read(dev_fd, buffer, try * BLOCK_SIZE);
 590         if (got < 0)
 591                 got = 0;
 592         if (got & (BLOCK_SIZE - 1)) {
 593                 printf("Weird values in do_check: probably bugs\n");
 594         }
 595         got /= BLOCK_SIZE;
 596         return got;
 597 }
 598
 599 static unsigned currently_testing;
 600
 601 static void alarm_intr(int alnum)
 602 {
 603         if (currently_testing >= SB_ZONES)
 604                 return;
 605         signal(SIGALRM, alarm_intr);
 606         alarm(5);
 607         if (!currently_testing)
 608                 return;
 609         printf("%d ...", currently_testing);
 610         fflush(stdout);
 611 }
 612
 613 static void check_blocks(void)
 614 {
 615         int try, got;
 616         /* buffer[] was the biggest static in entire bbox */
 617         char *buffer = xmalloc(BLOCK_SIZE * TEST_BUFFER_BLOCKS);
 618
 619         currently_testing = 0;
 620         signal(SIGALRM, alarm_intr);
 621         alarm(5);
 622         while (currently_testing < SB_ZONES) {
 623                 msg_eol = "seek failed in check_blocks";
 624                 xlseek(dev_fd, currently_testing * BLOCK_SIZE, SEEK_SET);
 625                 msg_eol = "\n";
 626                 try = TEST_BUFFER_BLOCKS;
 627                 if (currently_testing + try > SB_ZONES)
 628                         try = SB_ZONES - currently_testing;
 629                 got = do_check(buffer, try, currently_testing);
 630                 currently_testing += got;
 631                 if (got == try)
 632                         continue;
 633                 if (currently_testing < SB_FIRSTZONE)
 634                         bb_error_msg_and_die("bad blocks before data-area: cannot make fs");
 635                 mark_zone(currently_testing);
 636                 badblocks++;
 637                 currently_testing++;
 638         }
 639         free(buffer);
 640         printf("%d bad block(s)\n", badblocks);
 641 }
 642
 643 static void get_list_blocks(char *filename)
 644 {
 645         FILE *listfile;
 646         unsigned long blockno;
 647
 648         listfile = xfopen(filename, "r");
 649         while (!feof(listfile)) {
 650                 fscanf(listfile, "%ld\n", &blockno);
 651                 mark_zone(blockno);
 652                 badblocks++;
 653         }
 654         printf("%d bad block(s)\n", badblocks);
 655 }
 656
 657 int mkfs_minix_main(int argc, char **argv)
 658 {
 659         struct mntent *mp;
 660         unsigned opt;
 661         char *tmp;
 662         struct stat statbuf;
 663         char *str_i, *str_n;
 664         char *listfile = NULL;
 665
 666         if (INODE_SIZE1 * MINIX1_INODES_PER_BLOCK != BLOCK_SIZE)
 667                 bb_error_msg_and_die("bad inode size");
 668 #if ENABLE_FEATURE_MINIX2
 669         if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
 670                 bb_error_msg_and_die("bad inode size");
 671 #endif
 672
 673         opt = getopt32(argc, argv, "ci:l:n:v", &str_i, &listfile, &str_n);
 674         argv += optind;
 675         //if (opt & 1) -c
 676         if (opt & 2) req_nr_inodes = xatoul(str_i); // -i
 677         //if (opt & 4) -l
 678         if (opt & 8) { // -n
 679                 namelen = xatoi_u(str_n);
 680                 if (namelen == 14) magic = MINIX1_SUPER_MAGIC;
 681                 else if (namelen == 30) magic = MINIX1_SUPER_MAGIC2;
 682                 else bb_show_usage();
 683                 dirsize = namelen + 2;
 684         }
 685         if (opt & 0x10) { // -v
 686 #if ENABLE_FEATURE_MINIX2
 687                 version2 = 1;
 688 #else
 689                 bb_error_msg_and_die("%s: not compiled with minix v2 support",
 690                         device_name);
 691 #endif
 692         }
 693
 694         device_name = *argv++;
 695         if (!device_name)
 696                 bb_show_usage();
 697         if (*argv)
 698                 total_blocks = xatou32(*argv);
 699         else
 700                 total_blocks = get_size(device_name) / 1024;
 701
 702         if (total_blocks < 10)
 703                 bb_error_msg_and_die("must have at least 10 blocks");
 704
 705         if (version2) {
 706                 magic = MINIX2_SUPER_MAGIC2;
 707                 if (namelen == 14)
 708                         magic = MINIX2_SUPER_MAGIC;
 709         } else if (total_blocks > 65535)
 710                 total_blocks = 65535;
 711
 712         /* Check if it is mounted */
 713         mp = find_mount_point(device_name, NULL);
 714         if (mp && strcmp(device_name, mp->mnt_fsname) == 0)
 715                 bb_error_msg_and_die("%s is mounted on %s; "
 716                                 "refusing to make a filesystem",
 717                                 device_name, mp->mnt_dir);
 718
 719         dev_fd = xopen(device_name, O_RDWR);
 720         if (fstat(dev_fd, &statbuf) < 0)
 721                 bb_error_msg_and_die("cannot stat %s", device_name);
 722         if (!S_ISBLK(statbuf.st_mode))
 723                 opt &= ~1; // clear -c (check)
 724
 725 /* I don't know why someone has special code to prevent mkfs.minix
 726  * on IDE devices. Why IDE but not SCSI, etc?... */
 727 #if 0
 728         else if (statbuf.st_rdev == 0x0300 || statbuf.st_rdev == 0x0340)
 729                 /* what is this? */
 730                 bb_error_msg_and_die("will not try "
 731                         "to make filesystem on '%s'", device_name);
 732 #endif
 733
 734         tmp = root_block;
 735         *(short *) tmp = 1;
 736         strcpy(tmp + 2, ".");
 737         tmp += dirsize;
 738         *(short *) tmp = 1;
 739         strcpy(tmp + 2, "..");
 740         tmp += dirsize;
 741         *(short *) tmp = 2;
 742         strcpy(tmp + 2, ".badblocks");
 743
 744         setup_tables();
 745
 746         if (opt & 1) // -c ?
 747                 check_blocks();
 748         else if (listfile)
 749                 get_list_blocks(listfile);
 750
 751         if (version2) {
 752                 make_root_inode2();
 753                 make_bad_inode2();
 754         } else {
 755                 make_root_inode();
 756                 make_bad_inode();
 757         }
 758
 759         mark_good_blocks();
 760         write_tables();
 761         return 0;
 762 }