lwext4/ext4_balloc.c

   1 /*
   2  * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   3  *
   4  *
   5  * HelenOS:
   6  * Copyright (c) 2012 Martin Sucha
   7  * Copyright (c) 2012 Frantisek Princ
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  *
  14  * - Redistributions of source code must retain the above copyright
  15  *   notice, this list of conditions and the following disclaimer.
  16  * - Redistributions in binary form must reproduce the above copyright
  17  *   notice, this list of conditions and the following disclaimer in the
  18  *   documentation and/or other materials provided with the distribution.
  19  * - The name of the author may not be used to endorse or promote products
  20  *   derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /** @addtogroup lwext4
  35  * @{
  36  */
  37 /**
  38  * @file  ext4_balloc.c
  39  * @brief Physical block allocator.
  40  */
  41
  42 #include <ext4_config.h>
  43 #include <ext4_balloc.h>
  44 #include <ext4_super.h>
  45 #include <ext4_block_group.h>
  46 #include <ext4_fs.h>
  47 #include <ext4_bitmap.h>
  48 #include <ext4_inode.h>
  49
  50
  51 /**@brief Compute number of block group from block address.
  52  * @param sb         Superblock pointer.
  53  * @param baddr Absolute address of block.
  54  * @return Block group index
  55  */
  56 static uint32_t ext4_balloc_get_bgid_of_block(struct ext4_sblock *s,
  57     uint32_t baddr)
  58 {
  59     if(ext4_get32(s, first_data_block))
  60         baddr--;
  61
  62     return baddr / ext4_get32(s, blocks_per_group);
  63 }
  64
  65
  66 uint32_t ext4_balloc_get_first_data_block_in_group(struct ext4_sblock *s,
  67     struct ext4_block_group_ref * bg_ref)
  68 {
  69     uint32_t block_group_count = ext4_block_group_cnt(s);
  70     uint32_t inode_table_first_block =
  71             ext4_bg_get_inode_table_first_block(bg_ref->block_group, s);
  72     uint32_t block_size  = ext4_sb_get_block_size(s);
  73
  74     uint16_t inode_size = ext4_get16(s, inode_size);
  75     uint32_t inodes_per_group = ext4_get32(s, inodes_per_group);
  76
  77     uint32_t inode_table_bytes;
  78
  79
  80     if (bg_ref->index < block_group_count - 1) {
  81         inode_table_bytes = inodes_per_group * inode_size;
  82     } else {
  83         /* Last block group could be smaller */
  84         uint32_t inodes_count_total = ext4_get32(s, inodes_count);
  85         inode_table_bytes =
  86                 (inodes_count_total - ((block_group_count - 1) *
  87                         inodes_per_group)) * inode_size;
  88     }
  89
  90     uint32_t inode_table_blocks = inode_table_bytes / block_size;
  91
  92     if (inode_table_bytes % block_size)
  93         inode_table_blocks++;
  94
  95     return inode_table_first_block + inode_table_blocks;
  96 }
  97
  98 int ext4_balloc_free_block(struct ext4_inode_ref *inode_ref, uint32_t baddr)
  99 {
 100     struct ext4_fs *fs = inode_ref->fs;
 101     struct ext4_sblock *sb = &fs->sb;
 102
 103
 104     uint32_t block_group    = ext4_balloc_get_bgid_of_block(sb, baddr);
 105     uint32_t index_in_group = ext4_fs_baddr2_index_in_group(sb, baddr);
 106
 107     /* Load block group reference */
 108     struct ext4_block_group_ref bg_ref;
 109     int rc = ext4_fs_get_block_group_ref(fs, block_group, &bg_ref);
 110     if (rc != EOK)
 111         return rc;
 112
 113     /* Load block with bitmap */
 114     uint32_t bitmap_block_addr =
 115             ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 116
 117     struct ext4_block bitmap_block;
 118
 119     rc = ext4_block_get(fs->bdev, &bitmap_block, bitmap_block_addr);
 120     if (rc != EOK){
 121         ext4_fs_put_block_group_ref(&bg_ref);
 122         return rc;
 123     }
 124
 125     /* Modify bitmap */
 126     ext4_bmap_bit_clr(bitmap_block.data, index_in_group);
 127     bitmap_block.dirty = true;
 128
 129     /* Release block with bitmap */
 130     rc = ext4_block_set(fs->bdev, &bitmap_block);
 131     if (rc != EOK) {
 132         /* Error in saving bitmap */
 133         ext4_fs_put_block_group_ref(&bg_ref);
 134         return rc;
 135     }
 136
 137     uint32_t block_size = ext4_sb_get_block_size(sb);
 138
 139     /* Update superblock free blocks count */
 140     uint64_t sb_free_blocks =
 141             ext4_sb_get_free_blocks_cnt(sb);
 142     sb_free_blocks++;
 143     ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 144
 145     /* Update inode blocks count */
 146     uint64_t ino_blocks =
 147             ext4_inode_get_blocks_count(sb, inode_ref->inode);
 148     ino_blocks -= block_size / EXT4_INODE_BLOCK_SIZE;
 149     ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 150     inode_ref->dirty = true;
 151
 152     /* Update block group free blocks count */
 153     uint32_t free_blocks =
 154             ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 155     free_blocks++;
 156     ext4_bg_set_free_blocks_count(bg_ref.block_group,
 157         sb, free_blocks);
 158
 159     bg_ref.dirty = true;
 160
 161     /* Release block group reference */
 162     return ext4_fs_put_block_group_ref(&bg_ref);
 163 }
 164
 165 int ext4_balloc_free_blocks(struct ext4_inode_ref *inode_ref, uint32_t first,
 166     uint32_t count)
 167 {
 168     int rc = EOK;
 169     struct ext4_fs *fs = inode_ref->fs;
 170     struct ext4_sblock *sb = &fs->sb;
 171
 172     /* Compute indexes */
 173     uint32_t block_group_first =
 174             ext4_balloc_get_bgid_of_block(sb, first);
 175
 176     /* Compute indexes */
 177     uint32_t block_group_last =
 178             ext4_balloc_get_bgid_of_block(sb, first + count - 1);
 179
 180     if(!ext4_sb_has_feature_incompatible(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)){
 181         /*It is not possible withot flex_bg that blocks are continuous
 182          * and and last block belongs to other bg.*/
 183         ext4_assert(block_group_first ==
 184                 ext4_balloc_get_bgid_of_block(sb, first + count - 1));
 185     }
 186
 187     /* Load block group reference */
 188     struct ext4_block_group_ref bg_ref;
 189     while(block_group_first <= block_group_last){
 190
 191         rc = ext4_fs_get_block_group_ref(fs, block_group_first, &bg_ref);
 192         if (rc != EOK)
 193             return rc;
 194
 195         uint32_t index_in_group_first =
 196                 ext4_fs_baddr2_index_in_group(sb, first);
 197
 198         /* Load block with bitmap */
 199         uint32_t bitmap_block_addr =
 200                 ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 201
 202         struct ext4_block bitmap_block;
 203
 204         rc = ext4_block_get(fs->bdev, &bitmap_block, bitmap_block_addr);
 205         if (rc != EOK){
 206             ext4_fs_put_block_group_ref(&bg_ref);
 207             return rc;
 208         }
 209
 210         uint32_t free_cnt = ext4_sb_get_block_size(sb) * 8 - index_in_group_first;
 211
 212         /*If last block, free only count blocks*/
 213         free_cnt = count > free_cnt ? free_cnt : count;
 214
 215         /* Modify bitmap */
 216         ext4_bmap_bits_free(bitmap_block.data, index_in_group_first, free_cnt);
 217         bitmap_block.dirty = true;
 218
 219         count -= free_cnt;
 220         first += free_cnt;
 221
 222         /* Release block with bitmap */
 223         rc = ext4_block_set(fs->bdev, &bitmap_block);
 224         if (rc != EOK) {
 225             ext4_fs_put_block_group_ref(&bg_ref);
 226             return rc;
 227         }
 228
 229         uint32_t block_size = ext4_sb_get_block_size(sb);
 230
 231         /* Update superblock free blocks count */
 232         uint64_t sb_free_blocks =
 233                 ext4_sb_get_free_blocks_cnt(sb);
 234         sb_free_blocks += free_cnt;
 235         ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 236
 237         /* Update inode blocks count */
 238         uint64_t ino_blocks =
 239                 ext4_inode_get_blocks_count(sb, inode_ref->inode);
 240         ino_blocks -= free_cnt * (block_size / EXT4_INODE_BLOCK_SIZE);
 241         ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 242         inode_ref->dirty = true;
 243
 244         /* Update block group free blocks count */
 245         uint32_t free_blocks =
 246                 ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 247         free_blocks += free_cnt;
 248         ext4_bg_set_free_blocks_count(bg_ref.block_group,
 249                 sb, free_blocks);
 250         bg_ref.dirty = true;
 251
 252         /* Release block group reference */
 253         rc = ext4_fs_put_block_group_ref(&bg_ref);
 254         if(rc != EOK)
 255             break;
 256
 257         block_group_first++;
 258     }
 259
 260     /*All blocks should be released*/
 261     ext4_assert(count == 0);
 262     return rc;
 263 }
 264
 265
 266 /**@brief Compute 'goal' for allocation algorithm.
 267  * @param inode_ref Reference to inode, to allocate block for
 268  * @param goal
 269  * @return error code
 270  */
 271 static int ext4_balloc_find_goal(struct ext4_inode_ref *inode_ref, uint32_t *goal)
 272 {
 273     struct ext4_sblock *sb = &inode_ref->fs->sb;
 274     *goal = 0;
 275
 276     uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
 277     uint32_t block_size = ext4_sb_get_block_size(sb);
 278     uint32_t inode_block_count = inode_size / block_size;
 279
 280     if (inode_size % block_size != 0)
 281         inode_block_count++;
 282
 283     /* If inode has some blocks, get last block address + 1 */
 284     if (inode_block_count > 0) {
 285         int rc = ext4_fs_get_inode_data_block_index(inode_ref,
 286                 inode_block_count - 1, goal);
 287         if (rc != EOK)
 288             return rc;
 289
 290         if (*goal != 0) {
 291             (*goal)++;
 292             return rc;
 293         }
 294
 295         /* If goal == 0, sparse file -> continue */
 296     }
 297
 298     /* Identify block group of inode */
 299
 300     uint32_t inodes_per_group = ext4_get32(sb, inodes_per_group);
 301     uint32_t block_group = (inode_ref->index - 1) / inodes_per_group;
 302     block_size = ext4_sb_get_block_size(sb);
 303
 304     /* Load block group reference */
 305     struct ext4_block_group_ref bg_ref;
 306     int rc = ext4_fs_get_block_group_ref(inode_ref->fs,
 307             block_group, &bg_ref);
 308     if (rc != EOK)
 309         return rc;
 310
 311     /* Compute indexes */
 312     uint32_t block_group_count = ext4_block_group_cnt(sb);
 313     uint32_t inode_table_first_block =
 314             ext4_bg_get_inode_table_first_block(bg_ref.block_group, sb);
 315     uint16_t inode_table_item_size = ext4_get16(sb, inode_size);
 316     uint32_t inode_table_bytes;
 317
 318     /* Check for last block group */
 319     if (block_group < block_group_count - 1) {
 320         inode_table_bytes = inodes_per_group * inode_table_item_size;
 321     } else {
 322         /* Last block group could be smaller */
 323         uint32_t inodes_count_total = ext4_get32(sb, inodes_count);
 324
 325         inode_table_bytes =
 326                 (inodes_count_total - ((block_group_count - 1) *
 327                         inodes_per_group)) * inode_table_item_size;
 328     }
 329
 330     uint32_t inode_table_blocks = inode_table_bytes / block_size;
 331
 332     if (inode_table_bytes % block_size)
 333         inode_table_blocks++;
 334
 335     *goal = inode_table_first_block + inode_table_blocks;
 336
 337     return  ext4_fs_put_block_group_ref(&bg_ref);
 338 }
 339
 340
 341 int ext4_balloc_alloc_block(struct ext4_inode_ref *inode_ref,
 342     uint32_t *fblock)
 343 {
 344     uint32_t allocated_block = 0;
 345     uint32_t bitmap_block_addr;
 346     uint32_t rel_block_idx = 0;
 347     uint32_t free_blocks;
 348     uint32_t goal;
 349     struct ext4_block bitmap_block;
 350
 351     int rc = ext4_balloc_find_goal(inode_ref, &goal);
 352     if (rc != EOK) {
 353         /* no goal found => partition is full */
 354         return rc;
 355     }
 356
 357     struct ext4_sblock *sb = &inode_ref->fs->sb;
 358
 359     /* Load block group number for goal and relative index */
 360     uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal);
 361     uint32_t index_in_group =
 362             ext4_fs_baddr2_index_in_group(sb, goal);
 363
 364     /* Load block group reference */
 365     struct ext4_block_group_ref bg_ref;
 366     rc = ext4_fs_get_block_group_ref(inode_ref->fs,
 367             block_group, &bg_ref);
 368     if (rc != EOK)
 369         return rc;
 370
 371     free_blocks =
 372             ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 373     if (free_blocks == 0) {
 374         /* This group has no free blocks */
 375         goto goal_failed;
 376     }
 377
 378     /* Compute indexes */
 379     uint32_t first_in_group =
 380             ext4_balloc_get_first_data_block_in_group(sb, &bg_ref);
 381
 382     uint32_t first_in_group_index =
 383             ext4_fs_baddr2_index_in_group(sb, first_in_group);
 384
 385     if (index_in_group < first_in_group_index)
 386         index_in_group = first_in_group_index;
 387
 388     /* Load block with bitmap */
 389     bitmap_block_addr =
 390             ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 391
 392     rc = ext4_block_get(inode_ref->fs->bdev, &bitmap_block,
 393             bitmap_block_addr);
 394     if (rc != EOK) {
 395         ext4_fs_put_block_group_ref(&bg_ref);
 396         return rc;
 397     }
 398
 399     /* Check if goal is free */
 400     if (ext4_bmap_is_bit_clr(bitmap_block.data, index_in_group)) {
 401         ext4_bmap_bit_set(bitmap_block.data, index_in_group);
 402         bitmap_block.dirty = true;
 403         rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 404         if (rc != EOK) {
 405             ext4_fs_put_block_group_ref(&bg_ref);
 406             return rc;
 407         }
 408
 409         allocated_block =
 410                 ext4_fs_index_in_group2_baddr(sb, index_in_group,
 411                         block_group);
 412
 413         goto success;
 414     }
 415
 416     uint32_t blocks_in_group =
 417             ext4_blocks_in_group_cnt(sb, block_group);
 418
 419     uint32_t end_idx = (index_in_group + 63) & ~63;
 420     if (end_idx > blocks_in_group)
 421         end_idx = blocks_in_group;
 422
 423     /* Try to find free block near to goal */
 424     uint32_t tmp_idx;
 425     for (tmp_idx = index_in_group + 1; tmp_idx < end_idx;
 426             ++tmp_idx) {
 427         if (ext4_bmap_is_bit_clr(bitmap_block.data, tmp_idx)) {
 428             ext4_bmap_bit_set(bitmap_block.data, tmp_idx);
 429
 430             bitmap_block.dirty = true;
 431             rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 432             if (rc != EOK)
 433                 return rc;
 434
 435             allocated_block =
 436                     ext4_fs_index_in_group2_baddr(sb, tmp_idx,
 437                             block_group);
 438
 439             goto success;
 440         }
 441     }
 442
 443
 444
 445     /* Find free bit in bitmap */
 446     rc = ext4_bmap_bit_find_clr(bitmap_block.data,
 447             index_in_group, blocks_in_group, &rel_block_idx);
 448     if (rc == EOK) {
 449         ext4_bmap_bit_set(bitmap_block.data, rel_block_idx);
 450         bitmap_block.dirty = true;
 451         rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 452         if (rc != EOK)
 453             return rc;
 454
 455         allocated_block =
 456                 ext4_fs_index_in_group2_baddr(sb, rel_block_idx,
 457                         block_group);
 458
 459         goto success;
 460     }
 461
 462     /* No free block found yet */
 463     rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 464     if(rc != EOK){
 465         ext4_fs_put_block_group_ref(&bg_ref);
 466         return rc;
 467     }
 468
 469 goal_failed:
 470
 471     rc = ext4_fs_put_block_group_ref(&bg_ref);
 472     if(rc != EOK)
 473         return rc;
 474
 475
 476     /* Try other block groups */
 477     uint32_t block_group_count = ext4_block_group_cnt(sb);
 478
 479     uint32_t bgid = (block_group + 1) % block_group_count;
 480     uint32_t count = block_group_count;
 481
 482     while (count > 0) {
 483         rc = ext4_fs_get_block_group_ref(inode_ref->fs, bgid,
 484                 &bg_ref);
 485         if (rc != EOK)
 486             return rc;
 487
 488         free_blocks =
 489                 ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 490         if (free_blocks == 0) {
 491             /* This group has no free blocks */
 492             goto next_group;
 493         }
 494
 495         /* Load block with bitmap */
 496         bitmap_block_addr =
 497                 ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 498
 499         rc = ext4_block_get(inode_ref->fs->bdev, &bitmap_block,
 500                 bitmap_block_addr);
 501
 502         if (rc != EOK) {
 503             ext4_fs_put_block_group_ref(&bg_ref);
 504             return rc;
 505         }
 506
 507         /* Compute indexes */
 508         first_in_group =
 509                 ext4_balloc_get_first_data_block_in_group(sb, &bg_ref);
 510         index_in_group =
 511                 ext4_fs_baddr2_index_in_group(sb, first_in_group);
 512         blocks_in_group = ext4_blocks_in_group_cnt(sb, bgid);
 513
 514         first_in_group_index =
 515                 ext4_fs_baddr2_index_in_group(sb, first_in_group);
 516
 517         if (index_in_group < first_in_group_index)
 518             index_in_group = first_in_group_index;
 519
 520
 521         rc = ext4_bmap_bit_find_clr(bitmap_block.data,
 522                 index_in_group, blocks_in_group, &rel_block_idx);
 523
 524         if (rc == EOK) {
 525
 526             ext4_bmap_bit_set(bitmap_block.data, rel_block_idx);
 527
 528             bitmap_block.dirty = true;
 529             rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 530             if (rc != EOK){
 531                 ext4_fs_put_block_group_ref(&bg_ref);
 532                 return rc;
 533             }
 534
 535             allocated_block =
 536                     ext4_fs_index_in_group2_baddr(sb, rel_block_idx,
 537                             bgid);
 538
 539             goto success;
 540         }
 541
 542         rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 543         if(rc != EOK){
 544             ext4_fs_put_block_group_ref(&bg_ref);
 545             return rc;
 546         }
 547
 548 next_group:
 549         rc = ext4_fs_put_block_group_ref(&bg_ref);
 550         if(rc != EOK){
 551             return rc;
 552         }
 553
 554         /* Goto next group */
 555         bgid = (bgid + 1) % block_group_count;
 556         count--;
 557     }
 558
 559     return ENOSPC;
 560
 561     success:
 562     /* Empty command - because of syntax */
 563     ;
 564
 565     uint32_t block_size = ext4_sb_get_block_size(sb);
 566
 567     /* Update superblock free blocks count */
 568     uint64_t sb_free_blocks = ext4_sb_get_free_blocks_cnt(sb);
 569     sb_free_blocks--;
 570     ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 571
 572     /* Update inode blocks (different block size!) count */
 573     uint64_t ino_blocks =
 574             ext4_inode_get_blocks_count(sb, inode_ref->inode);
 575     ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE;
 576     ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 577     inode_ref->dirty = true;
 578
 579     /* Update block group free blocks count */
 580     uint32_t bg_free_blocks =
 581             ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 582     bg_free_blocks--;
 583     ext4_bg_set_free_blocks_count(bg_ref.block_group, sb,
 584         bg_free_blocks);
 585
 586     bg_ref.dirty = true;
 587
 588     rc = ext4_fs_put_block_group_ref(&bg_ref);
 589
 590     *fblock = allocated_block;
 591     return rc;
 592 }
 593
 594 int ext4_balloc_try_alloc_block(struct ext4_inode_ref *inode_ref,
 595     uint32_t baddr, bool *free)
 596 {
 597     int rc;
 598
 599     struct ext4_fs *fs = inode_ref->fs;
 600     struct ext4_sblock *sb = &fs->sb;
 601
 602     /* Compute indexes */
 603     uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, baddr);
 604     uint32_t index_in_group =
 605             ext4_fs_baddr2_index_in_group(sb, baddr);
 606
 607     /* Load block group reference */
 608     struct ext4_block_group_ref bg_ref;
 609     rc = ext4_fs_get_block_group_ref(fs, block_group, &bg_ref);
 610     if (rc != EOK)
 611         return rc;
 612
 613     /* Load block with bitmap */
 614     uint32_t bitmap_block_addr =
 615             ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 616
 617
 618     struct ext4_block bitmap_block;
 619
 620     rc = ext4_block_get(fs->bdev, &bitmap_block, bitmap_block_addr);
 621     if (rc != EOK){
 622         ext4_fs_put_block_group_ref(&bg_ref);
 623         return rc;
 624     }
 625
 626     /* Check if block is free */
 627     *free = ext4_bmap_is_bit_clr(bitmap_block.data, index_in_group);
 628
 629     /* Allocate block if possible */
 630     if (*free) {
 631         ext4_bmap_bit_set(bitmap_block.data, index_in_group);
 632         bitmap_block.dirty = true;
 633     }
 634
 635     /* Release block with bitmap */
 636     rc = ext4_block_set(fs->bdev, &bitmap_block);
 637     if (rc != EOK) {
 638         /* Error in saving bitmap */
 639         ext4_fs_put_block_group_ref(&bg_ref);
 640         return rc;
 641     }
 642
 643     /* If block is not free, return */
 644     if (!(*free))
 645         goto terminate;
 646
 647     uint32_t block_size = ext4_sb_get_block_size(sb);
 648
 649     /* Update superblock free blocks count */
 650     uint64_t sb_free_blocks = ext4_sb_get_free_blocks_cnt(sb);
 651     sb_free_blocks--;
 652     ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 653
 654     /* Update inode blocks count */
 655     uint64_t ino_blocks =
 656             ext4_inode_get_blocks_count(sb, inode_ref->inode);
 657     ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE;
 658     ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 659     inode_ref->dirty = true;
 660
 661     /* Update block group free blocks count */
 662     uint32_t free_blocks =
 663             ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 664     free_blocks--;
 665     ext4_bg_set_free_blocks_count(bg_ref.block_group,
 666         sb, free_blocks);
 667
 668     bg_ref.dirty = true;
 669
 670     terminate:
 671     return ext4_fs_put_block_group_ref(&bg_ref);
 672 }
 673
 674 /**
 675  * @}
 676  */