lwext4/ext4_mkfs.c

   1 /*
   2  * Copyright (c) 2015 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   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 lwext4
  30  * @{
  31  */
  32 /**
  33  * @file  ext4_mkfs.c
  34  * @brief
  35  */
  36
  37 #include "ext4_config.h"
  38 #include "ext4_super.h"
  39 #include "ext4_block_group.h"
  40 #include "ext4_dir.h"
  41 #include "ext4_dir_idx.h"
  42 #include "ext4_fs.h"
  43 #include "ext4_inode.h"
  44 #include "ext4_debug.h"
  45 #include "ext4_ialloc.h"
  46 #include "ext4_mkfs.h"
  47
  48 #include <inttypes.h>
  49 #include <string.h>
  50 #include <stdlib.h>
  51
  52 #define DIV_ROUND_UP(x, y) (((x) + (y) - 1)/(y))
  53 #define EXT4_ALIGN(x, y) ((y) * DIV_ROUND_UP((x), (y)))
  54
  55 struct fs_aux_info {
  56         struct ext4_sblock *sb;
  57         struct ext4_bgroup *bg_desc;
  58         struct xattr_list_element *xattrs;
  59         uint32_t first_data_block;
  60         uint64_t len_blocks;
  61         uint32_t inode_table_blocks;
  62         uint32_t groups;
  63         uint32_t bg_desc_blocks;
  64         uint32_t default_i_flags;
  65         uint32_t blocks_per_ind;
  66         uint32_t blocks_per_dind;
  67         uint32_t blocks_per_tind;
  68 };
  69
  70 static inline int log_2(int j)
  71 {
  72         int i;
  73
  74         for (i = 0; j > 0; i++)
  75                 j >>= 1;
  76
  77         return i - 1;
  78 }
  79
  80 static int sb2info(struct ext4_sblock *sb, struct ext4_mkfs_info *info)
  81 {
  82         if (to_le16(sb->magic) != EXT4_SUPERBLOCK_MAGIC)
  83                 return EINVAL;
  84
  85         info->block_size = 1024 << to_le32(sb->log_block_size);
  86         info->blocks_per_group = to_le32(sb->blocks_per_group);
  87         info->inodes_per_group = to_le32(sb->inodes_per_group);
  88         info->inode_size = to_le16(sb->inode_size);
  89         info->inodes = to_le32(sb->inodes_count);
  90         info->feat_ro_compat = to_le32(sb->features_read_only);
  91         info->feat_compat = to_le32(sb->features_compatible);
  92         info->feat_incompat = to_le32(sb->features_incompatible);
  93         info->bg_desc_reserve_blocks = to_le16(sb->s_reserved_gdt_blocks);
  94         info->label = sb->volume_name;
  95         info->len = (uint64_t)info->block_size * ext4_sb_get_blocks_cnt(sb);
  96
  97         return EOK;
  98 }
  99
 100 static uint32_t compute_blocks_per_group(struct ext4_mkfs_info *info)
 101 {
 102         return info->block_size * 8;
 103 }
 104
 105 static uint32_t compute_inodes(struct ext4_mkfs_info *info)
 106 {
 107         return DIV_ROUND_UP(info->len, info->block_size) / 4;
 108 }
 109
 110 static uint32_t compute_inodes_per_group(struct ext4_mkfs_info *info)
 111 {
 112         uint32_t blocks = DIV_ROUND_UP(info->len, info->block_size);
 113         uint32_t block_groups = DIV_ROUND_UP(blocks, info->blocks_per_group);
 114         uint32_t inodes = DIV_ROUND_UP(info->inodes, block_groups);
 115         inodes = EXT4_ALIGN(inodes, (info->block_size / info->inode_size));
 116
 117         /* After properly rounding up the number of inodes/group,
 118          * make sure to update the total inodes field in the info struct.
 119          */
 120         info->inodes = inodes * block_groups;
 121
 122         return inodes;
 123 }
 124
 125
 126 static uint32_t compute_journal_blocks(struct ext4_mkfs_info *info)
 127 {
 128         uint32_t journal_blocks = DIV_ROUND_UP(info->len, info->block_size) / 64;
 129         if (journal_blocks < 1024)
 130                 journal_blocks = 1024;
 131         if (journal_blocks > 32768)
 132                 journal_blocks = 32768;
 133         return journal_blocks;
 134 }
 135
 136 static bool has_superblock(struct ext4_mkfs_info *info, uint32_t bgid)
 137 {
 138         if (!(info->feat_ro_compat & EXT4_FRO_COM_SPARSE_SUPER))
 139                 return true;
 140
 141         return ext4_sb_sparse(bgid);
 142 }
 143
 144 static int create_fs_aux_info(struct fs_aux_info *aux_info,
 145                               struct ext4_mkfs_info *info)
 146 {
 147         aux_info->first_data_block = (info->block_size > 1024) ? 0 : 1;
 148         aux_info->len_blocks = info->len / info->block_size;
 149         aux_info->inode_table_blocks = DIV_ROUND_UP(info->inodes_per_group *
 150                         info->inode_size, info->block_size);
 151         aux_info->groups = DIV_ROUND_UP(aux_info->len_blocks -
 152                         aux_info->first_data_block, info->blocks_per_group);
 153         aux_info->blocks_per_ind = info->block_size / sizeof(uint32_t);
 154         aux_info->blocks_per_dind =
 155                         aux_info->blocks_per_ind * aux_info->blocks_per_ind;
 156         aux_info->blocks_per_tind =
 157                         aux_info->blocks_per_dind * aux_info->blocks_per_dind;
 158
 159         aux_info->bg_desc_blocks =
 160                 DIV_ROUND_UP(aux_info->groups * sizeof(struct ext4_bgroup),
 161                         info->block_size);
 162
 163         aux_info->default_i_flags = EXT4_INODE_FLAG_NOATIME;
 164
 165         uint32_t last_group_size = aux_info->len_blocks % info->blocks_per_group;
 166         uint32_t last_header_size = 2 + aux_info->inode_table_blocks;
 167         if (has_superblock(info, aux_info->groups - 1))
 168                 last_header_size += 1 + aux_info->bg_desc_blocks +
 169                         info->bg_desc_reserve_blocks;
 170
 171         if (last_group_size > 0 && last_group_size < last_header_size) {
 172                 aux_info->groups--;
 173                 aux_info->len_blocks -= last_group_size;
 174         }
 175
 176         aux_info->sb = calloc(1, EXT4_SUPERBLOCK_SIZE);
 177         if (!aux_info->sb)
 178                 return ENOMEM;
 179
 180         aux_info->bg_desc = calloc(aux_info->groups, sizeof(struct ext4_bgroup));
 181         if (!aux_info->bg_desc)
 182                 return ENOMEM;
 183
 184         aux_info->xattrs = NULL;
 185         return EOK;
 186 }
 187
 188 static void release_fs_aux_info(struct fs_aux_info *aux_info)
 189 {
 190         if (aux_info->sb)
 191                 free(aux_info->sb);
 192         if (aux_info->bg_desc)
 193                 free(aux_info->bg_desc);
 194 }
 195
 196
 197 /* Fill in the superblock memory buffer based on the filesystem parameters */
 198 static void fill_in_sb(struct fs_aux_info *aux_info, struct ext4_mkfs_info *info)
 199 {
 200         struct ext4_sblock *sb = aux_info->sb;
 201
 202         sb->inodes_count = to_le32(info->inodes_per_group * aux_info->groups);
 203
 204         ext4_sb_set_blocks_cnt(sb, aux_info->len_blocks);
 205         ext4_sb_set_free_blocks_cnt(sb, aux_info->len_blocks);
 206         sb->free_inodes_count = to_le32(info->inodes_per_group * aux_info->groups);
 207
 208         sb->reserved_blocks_count_lo = to_le32(0);
 209         sb->first_data_block = to_le32(aux_info->first_data_block);
 210         sb->log_block_size = to_le32(log_2(info->block_size / 1024));
 211         sb->log_cluster_size = to_le32(log_2(info->block_size / 1024));
 212         sb->blocks_per_group = to_le32(info->blocks_per_group);
 213         sb->frags_per_group = to_le32(info->blocks_per_group);
 214         sb->inodes_per_group = to_le32(info->inodes_per_group);
 215         sb->mount_time = to_le32(0);
 216         sb->write_time = to_le32(0);
 217         sb->mount_count = to_le16(0);
 218         sb->max_mount_count = to_le16(0xFFFF);
 219         sb->magic = to_le16(EXT4_SUPERBLOCK_MAGIC);
 220         sb->state = to_le16(EXT4_SUPERBLOCK_STATE_VALID_FS);
 221         sb->errors = to_le16(EXT4_SUPERBLOCK_ERRORS_RO);
 222         sb->minor_rev_level = to_le16(0);
 223         sb->last_check_time = to_le32(0);
 224         sb->check_interval = to_le32(0);
 225         sb->creator_os = to_le32(EXT4_SUPERBLOCK_OS_LINUX);
 226         sb->rev_level = to_le32(1);
 227         sb->def_resuid = to_le16(0);
 228         sb->def_resgid = to_le16(0);
 229
 230         sb->first_inode = to_le32(EXT4_GOOD_OLD_FIRST_INO);
 231         sb->inode_size = to_le16(info->inode_size);
 232         sb->block_group_index = to_le16(0);
 233
 234         sb->features_compatible = to_le32(info->feat_compat);
 235         sb->features_incompatible = to_le32(info->feat_incompat);
 236         sb->features_read_only = to_le32(info->feat_ro_compat);
 237
 238         memset(sb->uuid, 0, sizeof(sb->uuid));
 239
 240         memset(sb->volume_name, 0, sizeof(sb->volume_name));
 241         strncpy(sb->volume_name, info->label, sizeof(sb->volume_name));
 242         memset(sb->last_mounted, 0, sizeof(sb->last_mounted));
 243
 244         sb->algorithm_usage_bitmap = to_le32(0);
 245         sb->s_prealloc_blocks = 0;
 246         sb->s_prealloc_dir_blocks = 0;
 247         sb->s_reserved_gdt_blocks = to_le16(info->bg_desc_reserve_blocks);
 248
 249         if (info->feat_compat & EXT4_FCOM_HAS_JOURNAL)
 250                 sb->journal_inode_number = to_le32(EXT4_JOURNAL_INO);
 251         sb->journal_dev = to_le32(0);
 252         sb->last_orphan = to_le32(0);
 253         memset(sb->hash_seed, 0, sizeof(sb->hash_seed));
 254         sb->default_hash_version = EXT2_HTREE_HALF_MD4;
 255         sb->checksum_type = 1;
 256         sb->desc_size = to_le16(EXT4_MIN_BLOCK_GROUP_DESCRIPTOR_SIZE);
 257         sb->default_mount_opts = to_le32(0);
 258         sb->first_meta_bg = to_le32(0);
 259         sb->mkfs_time = to_le32(0);
 260
 261         sb->reserved_blocks_count_hi = to_le32(0);
 262         sb->min_extra_isize = to_le32(sizeof(struct ext4_inode) -
 263                 EXT4_GOOD_OLD_INODE_SIZE);
 264         sb->want_extra_isize = to_le32(sizeof(struct ext4_inode) -
 265                 EXT4_GOOD_OLD_INODE_SIZE);
 266         sb->flags = to_le32(2);
 267 }
 268
 269 static void fill_bgroups(struct fs_aux_info *aux_info,
 270                          struct ext4_mkfs_info *info)
 271 {
 272         uint32_t i;
 273
 274         uint64_t bg_free_blk = 0;
 275         uint64_t sb_free_blk = 0;
 276
 277         for (i = 0; i < aux_info->groups; i++) {
 278
 279                 uint64_t bg_start_block = aux_info->first_data_block +
 280                         aux_info->first_data_block + i * info->blocks_per_group;
 281                 uint32_t blk_off = 0;
 282
 283                 bg_free_blk = info->blocks_per_group -
 284                         (aux_info->inode_table_blocks + aux_info->bg_desc_blocks);
 285
 286                 bg_free_blk -= 2;
 287                 blk_off += aux_info->bg_desc_blocks;
 288
 289                 if (has_superblock(info, i)) {
 290                         bg_start_block++;
 291                         blk_off += info->bg_desc_reserve_blocks;
 292                         bg_free_blk -= info->bg_desc_reserve_blocks + 1;
 293                 } else {
 294                         bg_free_blk++;
 295                 }
 296
 297                 ext4_bg_set_block_bitmap(&aux_info->bg_desc[i], aux_info->sb,
 298                                 bg_start_block + blk_off + 1);
 299
 300                 ext4_bg_set_inode_bitmap(&aux_info->bg_desc[i], aux_info->sb,
 301                                 bg_start_block + blk_off + 2);
 302
 303                 ext4_bg_set_inode_table_first_block(&aux_info->bg_desc[i],
 304                                 aux_info->sb,
 305                                 bg_start_block + blk_off + 3);
 306
 307                 ext4_bg_set_free_blocks_count(&aux_info->bg_desc[i],
 308                                 aux_info->sb, bg_free_blk);
 309
 310                 ext4_bg_set_free_inodes_count(&aux_info->bg_desc[i],
 311                                 aux_info->sb, aux_info->sb->inodes_per_group);
 312
 313                 ext4_bg_set_used_dirs_count(&aux_info->bg_desc[i], aux_info->sb,
 314                                             0);
 315
 316                 ext4_bg_set_flag(&aux_info->bg_desc[i],
 317                                 EXT4_BLOCK_GROUP_BLOCK_UNINIT |
 318                                 EXT4_BLOCK_GROUP_INODE_UNINIT);
 319
 320                 sb_free_blk += bg_free_blk;
 321         }
 322
 323         ext4_sb_set_free_blocks_cnt(aux_info->sb, sb_free_blk);
 324 }
 325
 326
 327 static int write_bgroups(struct ext4_blockdev *bd, struct fs_aux_info *aux_info,
 328                          struct ext4_mkfs_info *info)
 329 {
 330         int r;
 331         uint32_t i;
 332         struct ext4_block b;
 333         for (i = 0; i < aux_info->groups; i++) {
 334                 uint64_t bg_start_block = aux_info->first_data_block +
 335                         aux_info->first_data_block + i * info->blocks_per_group;
 336                 uint32_t blk_off = 0;
 337
 338                 blk_off += aux_info->bg_desc_blocks;
 339                 if (has_superblock(info, i)) {
 340                         bg_start_block++;
 341                         blk_off += info->bg_desc_reserve_blocks;
 342                 }
 343
 344                 uint32_t block_size = ext4_sb_get_block_size(aux_info->sb);
 345                 uint32_t dsc_pos = 0;
 346                 uint32_t dsc_id = 0;
 347                 uint32_t dsc_size = ext4_sb_get_desc_size(aux_info->sb);
 348                 uint32_t dsc_blk_cnt = aux_info->bg_desc_blocks;
 349                 uint64_t dsc_blk = bg_start_block;
 350
 351                 while (dsc_blk_cnt--) {
 352                         r = ext4_block_get(bd, &b, dsc_blk++);
 353                         if (r != EOK)
 354                                 return r;
 355
 356                         while (dsc_pos + dsc_size < block_size) {
 357                                 memcpy(b.data + dsc_pos,
 358                                        &aux_info->bg_desc[dsc_id],
 359                                        dsc_size);
 360
 361                                 dsc_pos += dsc_size;
 362                                 dsc_id++;
 363                         }
 364
 365                         b.dirty = true;
 366                         r = ext4_block_set(bd, &b);
 367                         if (r != EOK)
 368                                 return r;
 369                 }
 370
 371                 r = ext4_block_get_noread(bd, &b, bg_start_block + blk_off + 1);
 372                 if (r != EOK)
 373                         return r;
 374                 memset(b.data, 0, block_size);
 375                 b.dirty = true;
 376                 r = ext4_block_set(bd, &b);
 377                 if (r != EOK)
 378                         return r;
 379                 r = ext4_block_get_noread(bd, &b, bg_start_block + blk_off + 2);
 380                 if (r != EOK)
 381                         return r;
 382                 memset(b.data, 0, block_size);
 383                 b.dirty = true;
 384                 r = ext4_block_set(bd, &b);
 385                 if (r != EOK)
 386                         return r;
 387         }
 388
 389
 390         return r;
 391 }
 392
 393 static int write_sblocks(struct ext4_blockdev *bd, struct fs_aux_info *aux_info,
 394                           struct ext4_mkfs_info *info)
 395 {
 396         uint64_t offset;
 397         uint32_t i;
 398         int r;
 399
 400         /* write out the backup superblocks */
 401         for (i = 1; i < aux_info->groups; i++) {
 402                 if (has_superblock(info, i)) {
 403                         offset = info->block_size * (aux_info->first_data_block
 404                                 + i * info->blocks_per_group);
 405
 406                         aux_info->sb->block_group_index = i;
 407                         r = ext4_block_writebytes(bd, offset, aux_info->sb,
 408                                                   EXT4_SUPERBLOCK_SIZE);
 409                         if (r != EOK)
 410                                 return r;
 411                 }
 412         }
 413
 414         /* write out the primary superblock */
 415         aux_info->sb->block_group_index = 0;
 416         return ext4_block_writebytes(bd, 1024, aux_info->sb,
 417                         EXT4_SUPERBLOCK_SIZE);
 418 }
 419
 420
 421 int ext4_mkfs_read_info(struct ext4_blockdev *bd, struct ext4_mkfs_info *info)
 422 {
 423         int r;
 424         struct ext4_sblock *sb = NULL;
 425         r = ext4_block_init(bd);
 426         if (r != EOK)
 427                 return r;
 428
 429         sb = malloc(EXT4_SUPERBLOCK_SIZE);
 430         if (!sb)
 431                 goto Finish;
 432
 433
 434         r = ext4_sb_read(bd, sb);
 435         if (r != EOK)
 436                 goto Finish;
 437
 438         r = sb2info(sb, info);
 439
 440 Finish:
 441         if (sb)
 442                 free(sb);
 443         ext4_block_fini(bd);
 444         return r;
 445 }
 446
 447 static int mkfs_initial(struct ext4_blockdev *bd, struct ext4_mkfs_info *info)
 448 {
 449         int r;
 450         struct fs_aux_info aux_info;
 451         memset(&aux_info, 0, sizeof(struct fs_aux_info));
 452
 453         r = create_fs_aux_info(&aux_info, info);
 454         if (r != EOK)
 455                 goto Finish;
 456
 457         fill_in_sb(&aux_info, info);
 458         fill_bgroups(&aux_info, info);
 459
 460
 461         r = write_bgroups(bd, &aux_info, info);
 462         if (r != EOK)
 463                 goto Finish;
 464
 465         r = write_sblocks(bd, &aux_info, info);
 466         if (r != EOK)
 467                 goto Finish;
 468
 469         Finish:
 470         release_fs_aux_info(&aux_info);
 471         return r;
 472 }
 473
 474 static int init_bgs(struct ext4_fs *fs)
 475 {
 476         int r = EOK;
 477         struct ext4_block_group_ref ref;
 478         uint32_t i;
 479         uint32_t bg_count = ext4_block_group_cnt(&fs->sb);
 480         for (i = 0; i < bg_count; ++i) {
 481                 r = ext4_fs_get_block_group_ref(fs, i, &ref);
 482                 if (r != EOK)
 483                         break;
 484
 485                 r = ext4_fs_put_block_group_ref(&ref);
 486                 if (r != EOK)
 487                         break;
 488         }
 489         return r;
 490 }
 491
 492 static int alloc_inodes(struct ext4_fs *fs)
 493 {
 494         int r = EOK;
 495         int i;
 496         struct ext4_inode_ref inode_ref;
 497         for (i = 1; i < 12; ++i) {
 498                 int filetype = EXT4_DIRENTRY_REG_FILE;
 499
 500                 switch (i) {
 501                 case EXT4_ROOT_INO:
 502                 case EXT4_GOOD_OLD_FIRST_INO:
 503                         filetype = EXT4_DIRENTRY_DIR;
 504                         break;
 505                 }
 506
 507                 r = ext4_fs_alloc_inode(fs, &inode_ref, filetype);
 508                 if (r != EOK)
 509                         return r;
 510
 511                 ext4_inode_set_mode(&fs->sb, inode_ref.inode, 0);
 512                 ext4_fs_put_inode_ref(&inode_ref);
 513         }
 514
 515         return r;
 516 }
 517
 518 static int create_dirs(struct ext4_fs *fs)
 519 {
 520         int r = EOK;
 521         struct ext4_inode_ref root;
 522         struct ext4_inode_ref child;
 523
 524         r = ext4_fs_get_inode_ref(fs, EXT4_ROOT_INO, &root);
 525         if (r != EOK)
 526                 return r;
 527
 528         r = ext4_fs_get_inode_ref(fs, EXT4_GOOD_OLD_FIRST_INO, &child);
 529         if (r != EOK)
 530                 return r;
 531
 532         ext4_inode_set_mode(&fs->sb, child.inode,
 533                         EXT4_INODE_MODE_DIRECTORY | 0777);
 534
 535         ext4_inode_set_mode(&fs->sb, root.inode,
 536                         EXT4_INODE_MODE_DIRECTORY | 0777);
 537
 538 #if CONFIG_DIR_INDEX_ENABLE
 539         /* Initialize directory index if supported */
 540         if (ext4_sb_feature_com(&fs->sb, EXT4_FCOM_DIR_INDEX)) {
 541                 r = ext4_dir_dx_init(&root, &root);
 542                 if (r != EOK)
 543                         return r;
 544
 545                 r = ext4_dir_dx_init(&child, &root);
 546                 if (r != EOK)
 547                         return r;
 548
 549                 ext4_inode_set_flag(root.inode, EXT4_INODE_FLAG_INDEX);
 550                 ext4_inode_set_flag(child.inode, EXT4_INODE_FLAG_INDEX);
 551         } else
 552 #endif
 553         {
 554                 r = ext4_dir_add_entry(&root, ".", strlen("."), &root);
 555                 if (r != EOK)
 556                         return r;
 557
 558                 r = ext4_dir_add_entry(&root, "..", strlen(".."), &root);
 559                 if (r != EOK)
 560                         return r;
 561
 562                 r = ext4_dir_add_entry(&child, ".", strlen("."), &child);
 563                 if (r != EOK)
 564                         return r;
 565
 566                 r = ext4_dir_add_entry(&child, "..", strlen(".."), &root);
 567                 if (r != EOK)
 568                         return r;
 569         }
 570
 571         r = ext4_dir_add_entry(&root, "lost+found", strlen("lost+found"), &child);
 572         if (r != EOK)
 573                 return r;
 574
 575         ext4_inode_set_links_count(root.inode, 3);
 576         ext4_inode_set_links_count(child.inode, 2);
 577
 578         child.dirty = true;
 579         root.dirty = true;
 580         ext4_fs_put_inode_ref(&child);
 581         ext4_fs_put_inode_ref(&root);
 582         return r;
 583 }
 584
 585 int ext4_mkfs(struct ext4_fs *fs, struct ext4_blockdev *bd,
 586               struct ext4_mkfs_info *info)
 587 {
 588         int r;
 589
 590         r = ext4_block_init(bd);
 591         if (r != EOK)
 592                 return r;
 593
 594         if (info->len == 0)
 595                 info->len = bd->ph_bcnt * bd->ph_bsize;
 596
 597         if (info->block_size == 0)
 598                 info->block_size = 4096; /*Set block size to default value*/
 599
 600         /* Round down the filesystem length to be a multiple of the block size */
 601         info->len &= ~((uint64_t)info->block_size - 1);
 602
 603         if (info->journal_blocks == 0)
 604                 info->journal_blocks = compute_journal_blocks(info);
 605
 606         if (info->blocks_per_group == 0)
 607                 info->blocks_per_group = compute_blocks_per_group(info);
 608
 609         if (info->inodes == 0)
 610                 info->inodes = compute_inodes(info);
 611
 612         if (info->inode_size == 0)
 613                 info->inode_size = 256;
 614
 615         if (info->label == NULL)
 616                 info->label = "";
 617
 618         info->inodes_per_group = compute_inodes_per_group(info);
 619
 620         info->feat_compat = EXT3_SUPPORTED_FCOM;
 621         info->feat_ro_compat = EXT3_SUPPORTED_FRO_COM;
 622         info->feat_incompat = EXT3_SUPPORTED_FINCOM;
 623
 624         info->feat_incompat &= ~EXT4_FINCOM_META_BG;
 625         info->feat_ro_compat &= ~EXT4_FRO_COM_METADATA_CSUM;
 626
 627         if (info->no_journal == 0)
 628                 info->feat_compat |= 0;
 629
 630         info->bg_desc_reserve_blocks = 0;
 631
 632         ext4_dbg(DEBUG_MKFS, DBG_INFO "Creating filesystem with parameters:\n");
 633         ext4_dbg(DEBUG_MKFS, DBG_NONE "Size: %"PRIu64"\n", info->len);
 634         ext4_dbg(DEBUG_MKFS, DBG_NONE "Block size: %"PRIu32"\n",
 635                         info->block_size);
 636         ext4_dbg(DEBUG_MKFS, DBG_NONE "Blocks per group: %"PRIu32"\n",
 637                         info->blocks_per_group);
 638         ext4_dbg(DEBUG_MKFS, DBG_NONE "Inodes per group: %"PRIu32"\n",
 639                         info->inodes_per_group);
 640         ext4_dbg(DEBUG_MKFS, DBG_NONE "Inode size: %"PRIu32"\n",
 641                         info->inode_size);
 642         ext4_dbg(DEBUG_MKFS, DBG_NONE "Inodes: %"PRIu32"\n", info->inodes);
 643         ext4_dbg(DEBUG_MKFS, DBG_NONE "Journal blocks: %"PRIu32"\n",
 644                         info->journal_blocks);
 645         ext4_dbg(DEBUG_MKFS, DBG_NONE "Features ro_compat: 0x%x\n",
 646                         info->feat_ro_compat);
 647         ext4_dbg(DEBUG_MKFS, DBG_NONE "Features compat: 0x%x\n",
 648                         info->feat_compat);
 649         ext4_dbg(DEBUG_MKFS, DBG_NONE "Features incompat: 0x%x\n",
 650                         info->feat_incompat);
 651         ext4_dbg(DEBUG_MKFS, DBG_NONE "BG desc reserve: %"PRIu32"\n",
 652                         info->bg_desc_reserve_blocks);
 653         ext4_dbg(DEBUG_MKFS, DBG_NONE "journal: %s\n",
 654                         !info->no_journal ? "yes" : "no");
 655         ext4_dbg(DEBUG_MKFS, DBG_NONE "Label: %s\n", info->label);
 656
 657         struct ext4_bcache bc;
 658         memset(&bc, 0, sizeof(struct ext4_bcache));
 659         ext4_block_set_lb_size(bd, info->block_size);
 660         r = ext4_bcache_init_dynamic(&bc, CONFIG_BLOCK_DEV_CACHE_SIZE,
 661                                       info->block_size);
 662         if (r != EOK)
 663                 goto block_fini;
 664
 665         /*Bind block cache to block device*/
 666         r = ext4_block_bind_bcache(bd, &bc);
 667         if (r != EOK)
 668                 goto cache_fini;
 669
 670         r = ext4_block_cache_write_back(bd, 0);
 671         if (r != EOK)
 672                 goto cache_fini;
 673
 674         r = mkfs_initial(bd, info);
 675         if (r != EOK)
 676                 goto cache_fini;
 677
 678         r = ext4_fs_init(fs, bd);
 679         if (r != EOK)
 680                 goto cache_fini;
 681
 682         r = init_bgs(fs);
 683         if (r != EOK)
 684                 goto fs_fini;
 685
 686         r = alloc_inodes(fs);
 687         if (r != EOK)
 688                 goto fs_fini;
 689
 690         r = create_dirs(fs);
 691         if (r != EOK)
 692                 goto fs_fini;
 693
 694         fs_fini:
 695         ext4_fs_fini(fs);
 696
 697         cache_fini:
 698         ext4_bcache_fini_dynamic(&bc);
 699
 700         block_fini:
 701         ext4_block_fini(bd);
 702
 703         return r;
 704 }
 705
 706 /**
 707  * @}
 708  */