uspace/app/mkmfs/mkmfs.c

   1 /*
   2  * Copyright (c) 2011 Maurizio Lombardi
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup fs
  30  * @{
  31  */
  32
  33 /**
  34  * @file        mkmfs.c
  35  * @brief       Tool for creating new Minix file systems.
  36  *
  37  */
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <block.h>
  42 #include <errno.h>
  43 #include <sys/typefmt.h>
  44 #include <inttypes.h>
  45 #include <getopt.h>
  46 #include <mem.h>
  47 #include <str.h>
  48 #include <time.h>
  49 #include <minix.h>
  50
  51 #define NAME    "mkmfs"
  52
  53 #define FREE    0
  54 #define USED    1
  55
  56 #define UPPER(n, size)          (((n) / (size)) + (((n) % (size)) != 0))
  57 #define NEXT_DENTRY(p, dirsize) (p += (dirsize))
  58
  59 typedef enum {
  60         HELP_SHORT,
  61         HELP_LONG
  62 } help_level_t;
  63
  64 /* Generic MFS superblock */
  65 struct mfs_sb_info {
  66         uint64_t n_inodes;
  67         uint64_t n_zones;
  68         aoff64_t dev_nblocks;
  69         unsigned long ibmap_blocks;
  70         unsigned long zbmap_blocks;
  71         unsigned long first_data_zone;
  72         unsigned long itable_size;
  73         int log2_zone_size;
  74         int ino_per_block;
  75         int dirsize;
  76         uint32_t max_file_size;
  77         uint16_t magic;
  78         uint32_t block_size;
  79         int fs_version;
  80         bool longnames;
  81 };
  82
  83 static void     help_cmd_mkmfs(help_level_t level);
  84 static bool     is_power_of_two(uint32_t n);
  85 static int      init_superblock(struct mfs_sb_info *sb);
  86 static int      write_superblock(const struct mfs_sb_info *sbi);
  87 static int      write_superblock3(const struct mfs_sb_info *sbi);
  88 static int      init_bitmaps(const struct mfs_sb_info *sb);
  89 static int      init_inode_table(const struct mfs_sb_info *sb);
  90 static int      make_root_ino(const struct mfs_sb_info *sb);
  91 static int      make_root_ino2(const struct mfs_sb_info *sb);
  92 static void     mark_bmap(uint32_t *bmap, int idx, int v);
  93 static int      insert_dentries(const struct mfs_sb_info *sb);
  94
  95 static inline int write_block(aoff64_t off, size_t size, const void *data);
  96
  97 static service_id_t service_id;
  98 static int shift;
  99
 100 static struct option const long_options[] = {
 101                 { "help", no_argument, 0, 'h' },
 102                 { "long-names", no_argument, 0, 'l' },
 103                 { "block-size", required_argument, 0, 'b' },
 104                 { "inodes", required_argument, 0, 'i' },
 105                 { NULL, no_argument, 0, '1' },
 106                 { NULL, no_argument, 0, '2' },
 107                 { 0, 0, 0, 0 }
 108 };
 109
 110 int main (int argc, char **argv)
 111 {
 112         int rc, c, opt_ind;
 113         char *device_name;
 114         size_t devblock_size;
 115
 116         struct mfs_sb_info sb;
 117
 118         /* Default is MinixFS V3 */
 119         sb.magic = MFS_MAGIC_V3;
 120         sb.fs_version = 3;
 121
 122         /* Default block size is 4Kb */
 123         sb.block_size = MFS_MAX_BLOCKSIZE;
 124         sb.dirsize = MFS3_DIRSIZE;
 125         sb.n_inodes = 0;
 126         sb.longnames = false;
 127         sb.ino_per_block = V3_INODES_PER_BLOCK(MFS_MAX_BLOCKSIZE);
 128
 129         if (argc == 1) {
 130                 help_cmd_mkmfs(HELP_SHORT);
 131                 printf("Incorrect number of arguments, try `mkmfs --help'\n");
 132                 exit(0);
 133         }
 134
 135         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
 136                 c = getopt_long(argc, argv, "lh12b:i:",
 137                     long_options, &opt_ind);
 138                 switch (c) {
 139                 case 'h':
 140                         help_cmd_mkmfs(HELP_LONG);
 141                         exit(0);
 142                 case '1':
 143                         sb.magic = MFS_MAGIC_V1;
 144                         sb.block_size = MFS_BLOCKSIZE;
 145                         sb.fs_version = 1;
 146                         sb.ino_per_block = V1_INODES_PER_BLOCK;
 147                         sb.dirsize = MFS_DIRSIZE;
 148                         break;
 149                 case '2':
 150                         sb.magic = MFS_MAGIC_V2;
 151                         sb.block_size = MFS_BLOCKSIZE;
 152                         sb.fs_version = 2;
 153                         sb.ino_per_block = V2_INODES_PER_BLOCK;
 154                         sb.dirsize = MFS_DIRSIZE;
 155                         break;
 156                 case 'b':
 157                         sb.block_size = (uint32_t) strtol(optarg, NULL, 10);
 158                         break;
 159                 case 'i':
 160                         sb.n_inodes = (uint64_t) strtol(optarg, NULL, 10);
 161                         break;
 162                 case 'l':
 163                         sb.longnames = true;
 164                         sb.dirsize = MFSL_DIRSIZE;
 165                         break;
 166                 }
 167         }
 168
 169         if (sb.block_size < MFS_MIN_BLOCKSIZE ||
 170             sb.block_size > MFS_MAX_BLOCKSIZE) {
 171                 printf(NAME ":Error! Invalid block size.\n");
 172                 exit(0);
 173         } else if (!is_power_of_two(sb.block_size)) {
 174                 /* Block size must be a power of 2. */
 175                 printf(NAME ":Error! Invalid block size.\n");
 176                 exit(0);
 177         } else if (sb.block_size > MFS_BLOCKSIZE &&
 178             sb.fs_version != 3) {
 179                 printf(NAME ":Error! Block size > 1024 is "
 180                     "supported by V3 filesystem only.\n");
 181                 exit(0);
 182         } else if (sb.fs_version == 3 && sb.longnames) {
 183                 printf(NAME ":Error! Long filenames are supported "
 184                     "by V1/V2 filesystem only.\n");
 185                 exit(0);
 186         }
 187
 188         if (sb.block_size == MFS_MIN_BLOCKSIZE)
 189                 shift = 1;
 190         else if (sb.block_size == MFS_MAX_BLOCKSIZE)
 191                 shift = 3;
 192         else
 193                 shift = 2;
 194
 195         argv += optind;
 196
 197         device_name = argv[0];
 198
 199         if (!device_name) {
 200                 help_cmd_mkmfs(HELP_LONG);
 201                 exit(0);
 202         }
 203
 204         rc = loc_service_get_id(device_name, &service_id, 0);
 205         if (rc != EOK) {
 206                 printf(NAME ": Error resolving device `%s'.\n", device_name);
 207                 return 2;
 208         }
 209
 210         rc = block_init(service_id, 2048);
 211         if (rc != EOK)  {
 212                 printf(NAME ": Error initializing libblock.\n");
 213                 return 2;
 214         }
 215
 216         rc = block_get_bsize(service_id, &devblock_size);
 217         if (rc != EOK) {
 218                 printf(NAME ": Error determining device block size.\n");
 219                 return 2;
 220         }
 221
 222         rc = block_get_nblocks(service_id, &sb.dev_nblocks);
 223         if (rc != EOK) {
 224                 printf(NAME ": Warning, failed to obtain "
 225                     "block device size.\n");
 226         } else {
 227                 printf(NAME ": Block device has %" PRIuOFF64 " blocks.\n",
 228                     sb.dev_nblocks);
 229         }
 230
 231         if (devblock_size != 512) {
 232                 printf(NAME ": Error. Device block size is not 512 bytes.\n");
 233                 return 2;
 234         }
 235
 236         /* Minimum block size is 1 Kb */
 237         sb.dev_nblocks /= 2;
 238
 239         printf(NAME ": Creating Minix file system on device\n");
 240         printf(NAME ": Writing superblock\n");
 241
 242         /* Initialize superblock */
 243         if (init_superblock(&sb) != EOK) {
 244                 printf(NAME ": Error. Superblock initialization failed\n");
 245                 return 2;
 246         }
 247
 248         printf(NAME ": Initializing bitmaps\n");
 249
 250         /* Initialize bitmaps */
 251         if (init_bitmaps(&sb) != EOK) {
 252                 printf(NAME ": Error. Bitmaps initialization failed\n");
 253                 return 2;
 254         }
 255
 256         printf(NAME ": Initializing the inode table\n");
 257
 258         /* Init inode table */
 259         if (init_inode_table(&sb) != EOK) {
 260                 printf(NAME ": Error. Inode table initialization failed\n");
 261                 return 2;
 262         }
 263
 264         printf(NAME ": Creating the root directory inode\n");
 265
 266         /* Make the root inode */
 267         if (sb.fs_version == 1)
 268                 rc = make_root_ino(&sb);
 269         else
 270                 rc = make_root_ino2(&sb);
 271
 272         if (rc != EOK) {
 273                 printf(NAME ": Error. Root inode initialization failed\n");
 274                 return 2;
 275         }
 276
 277         /* Insert directory entries . and .. */
 278         if (insert_dentries(&sb) != EOK) {
 279                 printf(NAME ": Error. Root directory initialization failed\n");
 280                 return 2;
 281         }
 282
 283         block_fini(service_id);
 284
 285         return 0;
 286 }
 287
 288 /**Inserts the '.' and '..' directory entries in the root directory.
 289  *
 290  * @param sb            Pointer to the superblock structure.
 291  *
 292  * @return              EOK on success or a negative error code.
 293  */
 294 static int insert_dentries(const struct mfs_sb_info *sb)
 295 {
 296         void *root_block;
 297         uint8_t *dentry_ptr;
 298         int rc;
 299         const long root_dblock = sb->first_data_zone;
 300
 301         root_block = malloc(sb->block_size);
 302         memset(root_block, 0x00, sb->block_size);
 303
 304         if (!root_block)
 305                 return ENOMEM;
 306
 307         dentry_ptr = root_block;
 308
 309         if (sb->fs_version != 3) {
 310                 /* Directory entries for V1/V2 filesystem */
 311                 struct mfs_dentry *dentry = root_block;
 312
 313                 dentry->d_inum = MFS_ROOT_INO;
 314                 memcpy(dentry->d_name, ".\0", 2);
 315
 316                 dentry = (struct mfs_dentry *) NEXT_DENTRY(dentry_ptr,
 317                     sb->dirsize);
 318
 319                 dentry->d_inum = MFS_ROOT_INO;
 320                 memcpy(dentry->d_name, "..\0", 3);
 321         } else {
 322                 /* Directory entries for V3 filesystem */
 323                 struct mfs3_dentry *dentry = root_block;
 324
 325                 dentry->d_inum = MFS_ROOT_INO;
 326                 memcpy(dentry->d_name, ".\0", 2);
 327
 328                 dentry = (struct mfs3_dentry *) NEXT_DENTRY(dentry_ptr,
 329                     sb->dirsize);
 330
 331                 dentry->d_inum = MFS_ROOT_INO;
 332                 memcpy(dentry->d_name, "..\0", 3);
 333         }
 334
 335         rc = write_block(root_dblock, 1, root_block);
 336
 337         free(root_block);
 338         return rc;
 339 }
 340
 341 /**Initialize the inode table.
 342  *
 343  * @param sb            Pointer to the superblock structure.
 344  *
 345  * @return              EOK on success or a negative error code.
 346  */
 347 static int init_inode_table(const struct mfs_sb_info *sb)
 348 {
 349         unsigned int i;
 350         uint8_t *itable_buf;
 351         int rc;
 352
 353         long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
 354         unsigned long itable_size = sb->itable_size;
 355
 356         itable_buf = malloc(sb->block_size);
 357
 358         if (!itable_buf)
 359                 return ENOMEM;
 360
 361         memset(itable_buf, 0x00, sb->block_size);
 362
 363         for (i = 0; i < itable_size; ++i, ++itable_off) {
 364                 rc = write_block(itable_off, 1, itable_buf);
 365
 366                 if (rc != EOK)
 367                         break;
 368         }
 369
 370         free(itable_buf);
 371         return rc;
 372 }
 373
 374 /**Initialize a V1 root inode.
 375  *
 376  * @param sb            Ponter to the superblock structure.
 377  *
 378  * @return              EOK on success or a negative error code.
 379  */
 380 static int make_root_ino(const struct mfs_sb_info *sb)
 381 {
 382         struct mfs_inode *ino_buf;
 383         int rc;
 384
 385         const long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
 386
 387         const time_t sec = time(NULL);
 388
 389         ino_buf = malloc(MFS_BLOCKSIZE);
 390
 391         if (!ino_buf)
 392                 return ENOMEM;
 393
 394         memset(ino_buf, 0x00, MFS_BLOCKSIZE);
 395
 396         ino_buf[MFS_ROOT_INO - 1].i_mode = S_IFDIR;
 397         ino_buf[MFS_ROOT_INO - 1].i_uid = 0;
 398         ino_buf[MFS_ROOT_INO - 1].i_gid = 0;
 399         ino_buf[MFS_ROOT_INO - 1].i_size = (sb->longnames ? MFSL_DIRSIZE :
 400             MFS_DIRSIZE) * 2;
 401         ino_buf[MFS_ROOT_INO - 1].i_mtime = sec;
 402         ino_buf[MFS_ROOT_INO - 1].i_nlinks = 2;
 403         ino_buf[MFS_ROOT_INO - 1].i_dzone[0] = sb->first_data_zone;
 404
 405         rc = write_block(itable_off, 1, ino_buf);
 406
 407         free(ino_buf);
 408         return rc;
 409 }
 410
 411 /**Initialize a Minix V2 root inode on disk, also valid for V3 filesystem.
 412  *
 413  * @param sb            Pointer to the superblock structure.
 414  *
 415  * @return              EOK on success or a negative error code.
 416  */
 417 static int make_root_ino2(const struct mfs_sb_info *sb)
 418 {
 419         struct mfs2_inode *ino_buf;
 420         int rc;
 421
 422         /* Compute offset of the first inode table block */
 423         const long itable_off = sb->zbmap_blocks + sb->ibmap_blocks + 2;
 424
 425         const time_t sec = time(NULL);
 426
 427         ino_buf = malloc(sb->block_size);
 428
 429         if (!ino_buf)
 430                 return ENOMEM;
 431
 432         memset(ino_buf, 0x00, sb->block_size);
 433
 434         ino_buf[MFS_ROOT_INO - 1].i_mode = S_IFDIR;
 435         ino_buf[MFS_ROOT_INO - 1].i_uid = 0;
 436         ino_buf[MFS_ROOT_INO - 1].i_gid = 0;
 437         ino_buf[MFS_ROOT_INO - 1].i_size = MFS3_DIRSIZE * 2;
 438         ino_buf[MFS_ROOT_INO - 1].i_mtime = sec;
 439         ino_buf[MFS_ROOT_INO - 1].i_atime = sec;
 440         ino_buf[MFS_ROOT_INO - 1].i_ctime = sec;
 441         ino_buf[MFS_ROOT_INO - 1].i_nlinks = 2;
 442         ino_buf[MFS_ROOT_INO - 1].i_dzone[0] = sb->first_data_zone;
 443
 444         rc = write_block(itable_off, 1, ino_buf);
 445
 446         free(ino_buf);
 447         return rc;
 448 }
 449
 450 /**Initialize the superblock structure on disk.
 451  *
 452  * @param sb            Pointer to the superblock structure.
 453  *
 454  * @return              EOK on success or a negative error code.
 455  */
 456 static int init_superblock(struct mfs_sb_info *sb)
 457 {
 458         aoff64_t inodes;
 459         unsigned long ind;
 460         unsigned long ind2;
 461         unsigned long zones;
 462         int rc;
 463
 464         if (sb->longnames)
 465                 sb->magic = sb->fs_version == 1 ? MFS_MAGIC_V1L :
 466                     MFS_MAGIC_V2L;
 467
 468         /* Compute the number of zones on disk */
 469
 470         if (sb->fs_version == 1) {
 471                 /* Valid only for MFS V1 */
 472                 sb->n_zones = sb->dev_nblocks > UINT16_MAX ?
 473                     UINT16_MAX : sb->dev_nblocks;
 474                 ind = MFS_BLOCKSIZE / sizeof(uint16_t);
 475                 ind2 = ind * ind;
 476                 sb->max_file_size = (V1_NR_DIRECT_ZONES + ind + ind2) *
 477                     MFS_BLOCKSIZE;
 478         } else {
 479                 /*Valid for MFS V2/V3*/
 480                 size_t ptrsize;
 481                 if (sb->fs_version == 2)
 482                         ptrsize = sizeof(uint16_t);
 483                 else
 484                         ptrsize = sizeof(uint32_t);
 485
 486                 ind = sb->block_size / ptrsize;
 487                 ind2 = ind * ind;
 488                 zones = V2_NR_DIRECT_ZONES + ind + ind2;
 489                 sb->max_file_size = zones * sb->block_size;
 490                 sb->n_zones = sb->dev_nblocks > UINT32_MAX ?
 491                     UINT32_MAX : sb->dev_nblocks;
 492
 493                 if (sb->fs_version == 3) {
 494                         if(INT32_MAX / sb->block_size < zones)
 495                                 sb->max_file_size = INT32_MAX;
 496                         sb->ino_per_block = V3_INODES_PER_BLOCK(sb->block_size);
 497                         sb->n_zones /= (sb->block_size / MFS_MIN_BLOCKSIZE);
 498                 }
 499         }
 500
 501         /* Round up the number of inodes to fill block size */
 502         if (sb->n_inodes == 0)
 503                 inodes = sb->dev_nblocks / 3;
 504         else
 505                 inodes = sb->n_inodes;
 506
 507         if (inodes % sb->ino_per_block)
 508                 inodes = ((inodes / sb->ino_per_block) + 1) *
 509                     sb->ino_per_block;
 510
 511         if (sb->fs_version < 3)
 512                 sb->n_inodes = inodes > UINT16_MAX ? UINT16_MAX : inodes;
 513         else
 514                 sb->n_inodes = inodes > UINT32_MAX ? UINT32_MAX : inodes;
 515
 516         /* Compute inode bitmap size in blocks */
 517         sb->ibmap_blocks = UPPER(sb->n_inodes, sb->block_size * 8);
 518
 519         /* Compute inode table size */
 520         sb->itable_size = sb->n_inodes / sb->ino_per_block;
 521
 522         /* Compute zone bitmap size in blocks */
 523         sb->zbmap_blocks = UPPER(sb->n_zones, sb->block_size * 8);
 524
 525         /* Compute first data zone position */
 526         sb->first_data_zone = 2 + sb->itable_size +
 527             sb->zbmap_blocks + sb->ibmap_blocks;
 528
 529         /* Set log2 of zone to block ratio to zero */
 530         sb->log2_zone_size = 0;
 531
 532         /* Check for errors */
 533         if (sb->first_data_zone >= sb->n_zones) {
 534                 printf(NAME ": Error! Insufficient disk space");
 535                 return ENOMEM;
 536         }
 537
 538         /* Superblock is now ready to be written on disk */
 539         printf(NAME ": %d block size\n", sb->block_size);
 540         printf(NAME ": %d inodes\n", (uint32_t) sb->n_inodes);
 541         printf(NAME ": %d zones\n", (uint32_t) sb->n_zones);
 542         printf(NAME ": inode table blocks = %ld\n", sb->itable_size);
 543         printf(NAME ": inode bitmap blocks = %ld\n", sb->ibmap_blocks);
 544         printf(NAME ": zone bitmap blocks = %ld\n", sb->zbmap_blocks);
 545         printf(NAME ": first data zone = %d\n", (uint32_t)sb->first_data_zone);
 546         printf(NAME ": max file size = %u\n", sb->max_file_size);
 547         printf(NAME ": long fnames = %s\n", sb->longnames ? "Yes" : "No");
 548
 549         if (sb->fs_version == 3)
 550                 rc = write_superblock3(sb);
 551         else
 552                 rc = write_superblock(sb);
 553
 554         return rc;
 555 }
 556
 557 /**Write the V1/V2 superblock on disk.
 558  *
 559  * @param sbi           Pointer to the superblock structure to write on disk.
 560  *
 561  * @return              EOK on success or a negative error code.
 562  */
 563 static int write_superblock(const struct mfs_sb_info *sbi)
 564 {
 565         struct mfs_superblock *sb;
 566         int rc;
 567
 568         sb = malloc(MFS_SUPERBLOCK_SIZE);;
 569
 570         if (!sb)
 571                 return ENOMEM;
 572
 573         sb->s_ninodes = (uint16_t) sbi->n_inodes;
 574         sb->s_nzones = (uint16_t) sbi->n_zones;
 575         sb->s_nzones2 = (uint32_t) sbi->n_zones;
 576         sb->s_ibmap_blocks = (uint16_t) sbi->ibmap_blocks;
 577         sb->s_zbmap_blocks = (uint16_t) sbi->zbmap_blocks;
 578         sb->s_first_data_zone = (uint16_t) sbi->first_data_zone;
 579         sb->s_log2_zone_size = sbi->log2_zone_size;
 580         sb->s_max_file_size = sbi->max_file_size;
 581         sb->s_magic = sbi->magic;
 582         sb->s_state = MFS_VALID_FS;
 583
 584         rc = write_block(MFS_SUPERBLOCK, 1, sb);
 585         free(sb);
 586
 587         return rc;
 588 }
 589
 590 /**Write the V3s superblock on disk.
 591  *
 592  * @param sbi           Pointer to the superblock structure to write on disk.
 593  *
 594  * @return              EOK on success or a negative error code.
 595  */
 596 static int write_superblock3(const struct mfs_sb_info *sbi)
 597 {
 598         struct mfs3_superblock *sb;
 599         int rc;
 600
 601         sb = malloc(MFS_SUPERBLOCK_SIZE);
 602
 603         if (!sb)
 604                 return ENOMEM;
 605
 606         sb->s_ninodes = (uint32_t) sbi->n_inodes;
 607         sb->s_nzones = (uint32_t) sbi->n_zones;
 608         sb->s_ibmap_blocks = (uint16_t) sbi->ibmap_blocks;
 609         sb->s_zbmap_blocks = (uint16_t) sbi->zbmap_blocks;
 610         sb->s_first_data_zone = (uint16_t) sbi->first_data_zone;
 611         sb->s_log2_zone_size = sbi->log2_zone_size;
 612         sb->s_max_file_size = sbi->max_file_size;
 613         sb->s_magic = sbi->magic;
 614         sb->s_block_size = sbi->block_size;
 615         sb->s_disk_version = 3;
 616
 617         rc = block_write_direct(service_id, MFS_SUPERBLOCK << 1, 1 << 1, sb);
 618         free(sb);
 619
 620         return rc;
 621 }
 622
 623 /**Initialize the inode and block bitmaps on disk.
 624  *
 625  * @param sb            Pointer to the superblock structure.
 626  *
 627  * @return              EOK on success or a negative error code.
 628  */
 629 static int init_bitmaps(const struct mfs_sb_info *sb)
 630 {
 631         uint32_t *ibmap_buf, *zbmap_buf;
 632         uint8_t *ibmap_buf8, *zbmap_buf8;
 633         const unsigned int ibmap_nblocks = sb->ibmap_blocks;
 634         const unsigned int zbmap_nblocks = sb->zbmap_blocks;
 635         unsigned int i;
 636         int rc;
 637
 638         ibmap_buf = malloc(ibmap_nblocks * sb->block_size);
 639         zbmap_buf = malloc(zbmap_nblocks * sb->block_size);
 640
 641         if (!ibmap_buf || !zbmap_buf) {
 642                 rc = ENOMEM;
 643                 goto exit;
 644         }
 645
 646         memset(ibmap_buf, 0xFF, ibmap_nblocks * sb->block_size);
 647         memset(zbmap_buf, 0xFF, zbmap_nblocks * sb->block_size);
 648
 649         for (i = 2; i < sb->n_inodes + 1; ++i)
 650                 mark_bmap(ibmap_buf, i, FREE);
 651
 652         for (i = 2; i < sb->n_zones - sb->first_data_zone; ++i)
 653                 mark_bmap(zbmap_buf, i, FREE);
 654
 655         ibmap_buf8 = (uint8_t *) ibmap_buf;
 656         zbmap_buf8 = (uint8_t *) zbmap_buf;
 657
 658         int start_block = 2;
 659
 660         for (i = 0; i < ibmap_nblocks; ++i) {
 661                 if ((rc = write_block(start_block + i,
 662                     1, (ibmap_buf8 + i * sb->block_size))) != EOK)
 663                         return rc;
 664         }
 665
 666         start_block = 2 + ibmap_nblocks;
 667
 668         for (i = 0; i < zbmap_nblocks; ++i) {
 669                 if ((rc = write_block(start_block + i,
 670                     1, (zbmap_buf8 + i * sb->block_size))) != EOK)
 671                         return rc;
 672         }
 673
 674 exit:
 675         free(ibmap_buf);
 676         free(zbmap_buf);
 677
 678         return rc;
 679 }
 680
 681 /**Mark a bitmap entry as used or free.
 682  *
 683  * @param bmap          32-bit pointer to the bitmap in memory.
 684  * @param idx           The index in the bitmap of the bit to set at 1 or 0.
 685  * @param v             FREE to clear the bit, USED to set the bit.
 686  */
 687 static void mark_bmap(uint32_t *bmap, int idx, int v)
 688 {
 689         if (v == FREE)
 690                 bmap[idx / 32] &= ~(1 << (idx % 32));
 691         else
 692                 bmap[idx / 32] |= 1 << (idx % 32);
 693 }
 694
 695 /**Write a block on disk.
 696  *
 697  * @param off           64-bit block offset on disk.
 698  * @param size          size of the block.
 699  * @param data          Pointer to the block content.
 700  *
 701  * @return              EOK on success or a negative error number.
 702  */
 703 static inline int write_block(aoff64_t off, size_t size, const void *data)
 704 {
 705         if (shift == 3) {
 706                 int rc;
 707                 aoff64_t tmp_off = off << 1;
 708                 uint8_t *data_ptr = (uint8_t *) data;
 709
 710                 rc = block_write_direct(service_id, tmp_off << 2,
 711                     size << 2, data_ptr);
 712
 713                 if (rc != EOK)
 714                         return rc;
 715
 716                 data_ptr += 2048;
 717                 tmp_off++;
 718
 719                 return block_write_direct(service_id, tmp_off << 2,
 720                     size << 2, data_ptr);
 721         }
 722         return block_write_direct(service_id, off << shift,
 723             size << shift, data);
 724 }
 725
 726 static void help_cmd_mkmfs(help_level_t level)
 727 {
 728         if (level == HELP_SHORT) {
 729                 printf(NAME": tool to create new Minix file systems\n");
 730         } else {
 731                 printf("Usage: [options] device\n"
 732                     "-1         Make a Minix version 1 filesystem\n"
 733                     "-2         Make a Minix version 2 filesystem\n"
 734                     "-b ##      Specify the block size in bytes (V3 only),\n"
 735                     "           valid block size values are 1024, 2048 and"
 736                                 " 4096 bytes per block\n"
 737                     "-i ##      Specify the number of inodes"
 738                                 " for the filesystem\n"
 739                     "-l         Use 30-char long filenames (V1/V2 only)\n");
 740         }
 741 }
 742
 743 /** Check if a given number is a power of two.
 744  *
 745  * @param n     The number to check.
 746  *
 747  * @return      true if it is a power of two, false otherwise.
 748  */
 749 static bool is_power_of_two(uint32_t n)
 750 {
 751         if (n == 0)
 752                 return false;
 753
 754         return (n & (n - 1)) == 0;
 755 }
 756
 757
 758 /**
 759  * @}
 760  */