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 /**@brief Compute number of block group from block address.
  51  * @param sb         Superblock pointer.
  52  * @param baddr Absolute address of block.
  53  * @return Block group index
  54  */
  55 static uint32_t ext4_balloc_get_bgid_of_block(struct ext4_sblock *s,
  56                                               uint32_t baddr)
  57 {
  58     if (ext4_get32(s, first_data_block))
  59         baddr--;
  60
  61     return baddr / ext4_get32(s, blocks_per_group);
  62 }
  63
  64 uint32_t
  65 ext4_balloc_get_first_data_block_in_group(struct ext4_sblock *s,
  66                                           struct ext4_block_group_ref *bg_ref)
  67 {
  68     uint32_t block_group_count = ext4_block_group_cnt(s);
  69     uint32_t inode_table_first_block =
  70         ext4_bg_get_inode_table_first_block(bg_ref->block_group, s);
  71     uint32_t block_size = ext4_sb_get_block_size(s);
  72
  73     uint16_t inode_size = ext4_get16(s, inode_size);
  74     uint32_t inodes_per_group = ext4_get32(s, inodes_per_group);
  75
  76     uint32_t inode_table_bytes;
  77
  78     if (bg_ref->index < block_group_count - 1) {
  79         inode_table_bytes = inodes_per_group * inode_size;
  80     } else {
  81         /* Last block group could be smaller */
  82         uint32_t inodes_count_total = ext4_get32(s, inodes_count);
  83         inode_table_bytes = (inodes_count_total -
  84                              ((block_group_count - 1) * inodes_per_group)) *
  85                             inode_size;
  86     }
  87
  88     uint32_t inode_table_blocks = inode_table_bytes / block_size;
  89
  90     if (inode_table_bytes % block_size)
  91         inode_table_blocks++;
  92
  93     return inode_table_first_block + inode_table_blocks;
  94 }
  95
  96 int ext4_balloc_free_block(struct ext4_inode_ref *inode_ref, uint32_t baddr)
  97 {
  98     struct ext4_fs *fs = inode_ref->fs;
  99     struct ext4_sblock *sb = &fs->sb;
 100
 101     uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, baddr);
 102     uint32_t index_in_group = ext4_fs_baddr2_index_in_group(sb, baddr);
 103
 104     /* Load block group reference */
 105     struct ext4_block_group_ref bg_ref;
 106     int rc = ext4_fs_get_block_group_ref(fs, block_group, &bg_ref);
 107     if (rc != EOK)
 108         return rc;
 109
 110     /* Load block with bitmap */
 111     uint32_t bitmap_block_addr =
 112         ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 113
 114     struct ext4_block bitmap_block;
 115
 116     rc = ext4_block_get(fs->bdev, &bitmap_block, bitmap_block_addr);
 117     if (rc != EOK) {
 118         ext4_fs_put_block_group_ref(&bg_ref);
 119         return rc;
 120     }
 121
 122     /* Modify bitmap */
 123     ext4_bmap_bit_clr(bitmap_block.data, index_in_group);
 124     bitmap_block.dirty = true;
 125
 126     /* Release block with bitmap */
 127     rc = ext4_block_set(fs->bdev, &bitmap_block);
 128     if (rc != EOK) {
 129         /* Error in saving bitmap */
 130         ext4_fs_put_block_group_ref(&bg_ref);
 131         return rc;
 132     }
 133
 134     uint32_t block_size = ext4_sb_get_block_size(sb);
 135
 136     /* Update superblock free blocks count */
 137     uint64_t sb_free_blocks = ext4_sb_get_free_blocks_cnt(sb);
 138     sb_free_blocks++;
 139     ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 140
 141     /* Update inode blocks count */
 142     uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode);
 143     ino_blocks -= block_size / EXT4_INODE_BLOCK_SIZE;
 144     ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 145     inode_ref->dirty = true;
 146
 147     /* Update block group free blocks count */
 148     uint32_t free_blocks =
 149         ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 150     free_blocks++;
 151     ext4_bg_set_free_blocks_count(bg_ref.block_group, sb, free_blocks);
 152
 153     bg_ref.dirty = true;
 154
 155     /* Release block group reference */
 156     return ext4_fs_put_block_group_ref(&bg_ref);
 157 }
 158
 159 int ext4_balloc_free_blocks(struct ext4_inode_ref *inode_ref, uint32_t first,
 160                             uint32_t count)
 161 {
 162     int rc = EOK;
 163     struct ext4_fs *fs = inode_ref->fs;
 164     struct ext4_sblock *sb = &fs->sb;
 165
 166     /* Compute indexes */
 167     uint32_t block_group_first = ext4_balloc_get_bgid_of_block(sb, first);
 168
 169     /* Compute indexes */
 170     uint32_t block_group_last =
 171         ext4_balloc_get_bgid_of_block(sb, first + count - 1);
 172
 173     if (!ext4_sb_has_feature_incompatible(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
 174         /*It is not possible withot flex_bg that blocks are continuous
 175          * and and last block belongs to other bg.*/
 176         ext4_assert(block_group_first ==
 177                     ext4_balloc_get_bgid_of_block(sb, first + count - 1));
 178     }
 179
 180     /* Load block group reference */
 181     struct ext4_block_group_ref bg_ref;
 182     while (block_group_first <= block_group_last) {
 183
 184         rc = ext4_fs_get_block_group_ref(fs, block_group_first, &bg_ref);
 185         if (rc != EOK)
 186             return rc;
 187
 188         uint32_t index_in_group_first =
 189             ext4_fs_baddr2_index_in_group(sb, first);
 190
 191         /* Load block with bitmap */
 192         uint32_t bitmap_block_addr =
 193             ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 194
 195         struct ext4_block bitmap_block;
 196
 197         rc = ext4_block_get(fs->bdev, &bitmap_block, bitmap_block_addr);
 198         if (rc != EOK) {
 199             ext4_fs_put_block_group_ref(&bg_ref);
 200             return rc;
 201         }
 202
 203         uint32_t free_cnt =
 204             ext4_sb_get_block_size(sb) * 8 - index_in_group_first;
 205
 206         /*If last block, free only count blocks*/
 207         free_cnt = count > free_cnt ? free_cnt : count;
 208
 209         /* Modify bitmap */
 210         ext4_bmap_bits_free(bitmap_block.data, index_in_group_first, free_cnt);
 211         bitmap_block.dirty = true;
 212
 213         count -= free_cnt;
 214         first += free_cnt;
 215
 216         /* Release block with bitmap */
 217         rc = ext4_block_set(fs->bdev, &bitmap_block);
 218         if (rc != EOK) {
 219             ext4_fs_put_block_group_ref(&bg_ref);
 220             return rc;
 221         }
 222
 223         uint32_t block_size = ext4_sb_get_block_size(sb);
 224
 225         /* Update superblock free blocks count */
 226         uint64_t sb_free_blocks = ext4_sb_get_free_blocks_cnt(sb);
 227         sb_free_blocks += free_cnt;
 228         ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 229
 230         /* Update inode blocks count */
 231         uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode);
 232         ino_blocks -= free_cnt * (block_size / EXT4_INODE_BLOCK_SIZE);
 233         ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 234         inode_ref->dirty = true;
 235
 236         /* Update block group free blocks count */
 237         uint32_t free_blocks =
 238             ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 239         free_blocks += free_cnt;
 240         ext4_bg_set_free_blocks_count(bg_ref.block_group, sb, free_blocks);
 241         bg_ref.dirty = true;
 242
 243         /* Release block group reference */
 244         rc = ext4_fs_put_block_group_ref(&bg_ref);
 245         if (rc != EOK)
 246             break;
 247
 248         block_group_first++;
 249     }
 250
 251     /*All blocks should be released*/
 252     ext4_assert(count == 0);
 253     return rc;
 254 }
 255
 256 /**@brief Compute 'goal' for allocation algorithm.
 257  * @param inode_ref Reference to inode, to allocate block for
 258  * @param goal
 259  * @return error code
 260  */
 261 static int ext4_balloc_find_goal(struct ext4_inode_ref *inode_ref,
 262                                  uint32_t *goal)
 263 {
 264     struct ext4_sblock *sb = &inode_ref->fs->sb;
 265     *goal = 0;
 266
 267     uint64_t inode_size = ext4_inode_get_size(sb, inode_ref->inode);
 268     uint32_t block_size = ext4_sb_get_block_size(sb);
 269     uint32_t inode_block_count = inode_size / block_size;
 270
 271     if (inode_size % block_size != 0)
 272         inode_block_count++;
 273
 274     /* If inode has some blocks, get last block address + 1 */
 275     if (inode_block_count > 0) {
 276         int rc = ext4_fs_get_inode_data_block_index(
 277             inode_ref, inode_block_count - 1, goal);
 278         if (rc != EOK)
 279             return rc;
 280
 281         if (*goal != 0) {
 282             (*goal)++;
 283             return rc;
 284         }
 285
 286         /* If goal == 0, sparse file -> continue */
 287     }
 288
 289     /* Identify block group of inode */
 290
 291     uint32_t inodes_per_group = ext4_get32(sb, inodes_per_group);
 292     uint32_t block_group = (inode_ref->index - 1) / inodes_per_group;
 293     block_size = ext4_sb_get_block_size(sb);
 294
 295     /* Load block group reference */
 296     struct ext4_block_group_ref bg_ref;
 297     int rc = ext4_fs_get_block_group_ref(inode_ref->fs, block_group, &bg_ref);
 298     if (rc != EOK)
 299         return rc;
 300
 301     /* Compute indexes */
 302     uint32_t block_group_count = ext4_block_group_cnt(sb);
 303     uint32_t inode_table_first_block =
 304         ext4_bg_get_inode_table_first_block(bg_ref.block_group, sb);
 305     uint16_t inode_table_item_size = ext4_get16(sb, inode_size);
 306     uint32_t inode_table_bytes;
 307
 308     /* Check for last block group */
 309     if (block_group < block_group_count - 1) {
 310         inode_table_bytes = inodes_per_group * inode_table_item_size;
 311     } else {
 312         /* Last block group could be smaller */
 313         uint32_t inodes_count_total = ext4_get32(sb, inodes_count);
 314
 315         inode_table_bytes = (inodes_count_total -
 316                              ((block_group_count - 1) * inodes_per_group)) *
 317                             inode_table_item_size;
 318     }
 319
 320     uint32_t inode_table_blocks = inode_table_bytes / block_size;
 321
 322     if (inode_table_bytes % block_size)
 323         inode_table_blocks++;
 324
 325     *goal = inode_table_first_block + inode_table_blocks;
 326
 327     return ext4_fs_put_block_group_ref(&bg_ref);
 328 }
 329
 330 int ext4_balloc_alloc_block(struct ext4_inode_ref *inode_ref, uint32_t *fblock)
 331 {
 332     uint32_t allocated_block = 0;
 333     uint32_t bitmap_block_addr;
 334     uint32_t rel_block_idx = 0;
 335     uint32_t free_blocks;
 336     uint32_t goal;
 337     struct ext4_block bitmap_block;
 338
 339     int rc = ext4_balloc_find_goal(inode_ref, &goal);
 340     if (rc != EOK) {
 341         /* no goal found => partition is full */
 342         return rc;
 343     }
 344
 345     struct ext4_sblock *sb = &inode_ref->fs->sb;
 346
 347     /* Load block group number for goal and relative index */
 348     uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, goal);
 349     uint32_t index_in_group = ext4_fs_baddr2_index_in_group(sb, goal);
 350
 351     /* Load block group reference */
 352     struct ext4_block_group_ref bg_ref;
 353     rc = ext4_fs_get_block_group_ref(inode_ref->fs, block_group, &bg_ref);
 354     if (rc != EOK)
 355         return rc;
 356
 357     free_blocks = ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 358     if (free_blocks == 0) {
 359         /* This group has no free blocks */
 360         goto goal_failed;
 361     }
 362
 363     /* Compute indexes */
 364     uint32_t first_in_group =
 365         ext4_balloc_get_first_data_block_in_group(sb, &bg_ref);
 366
 367     uint32_t first_in_group_index =
 368         ext4_fs_baddr2_index_in_group(sb, first_in_group);
 369
 370     if (index_in_group < first_in_group_index)
 371         index_in_group = first_in_group_index;
 372
 373     /* Load block with bitmap */
 374     bitmap_block_addr = ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 375
 376     rc = ext4_block_get(inode_ref->fs->bdev, &bitmap_block, bitmap_block_addr);
 377     if (rc != EOK) {
 378         ext4_fs_put_block_group_ref(&bg_ref);
 379         return rc;
 380     }
 381
 382     /* Check if goal is free */
 383     if (ext4_bmap_is_bit_clr(bitmap_block.data, index_in_group)) {
 384         ext4_bmap_bit_set(bitmap_block.data, index_in_group);
 385         bitmap_block.dirty = true;
 386         rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 387         if (rc != EOK) {
 388             ext4_fs_put_block_group_ref(&bg_ref);
 389             return rc;
 390         }
 391
 392         allocated_block =
 393             ext4_fs_index_in_group2_baddr(sb, index_in_group, block_group);
 394
 395         goto success;
 396     }
 397
 398     uint32_t blocks_in_group = ext4_blocks_in_group_cnt(sb, block_group);
 399
 400     uint32_t end_idx = (index_in_group + 63) & ~63;
 401     if (end_idx > blocks_in_group)
 402         end_idx = blocks_in_group;
 403
 404     /* Try to find free block near to goal */
 405     uint32_t tmp_idx;
 406     for (tmp_idx = index_in_group + 1; tmp_idx < end_idx; ++tmp_idx) {
 407         if (ext4_bmap_is_bit_clr(bitmap_block.data, tmp_idx)) {
 408             ext4_bmap_bit_set(bitmap_block.data, tmp_idx);
 409
 410             bitmap_block.dirty = true;
 411             rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 412             if (rc != EOK)
 413                 return rc;
 414
 415             allocated_block =
 416                 ext4_fs_index_in_group2_baddr(sb, tmp_idx, block_group);
 417
 418             goto success;
 419         }
 420     }
 421
 422     /* Find free bit in bitmap */
 423     rc = ext4_bmap_bit_find_clr(bitmap_block.data, index_in_group,
 424                                 blocks_in_group, &rel_block_idx);
 425     if (rc == EOK) {
 426         ext4_bmap_bit_set(bitmap_block.data, rel_block_idx);
 427         bitmap_block.dirty = true;
 428         rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 429         if (rc != EOK)
 430             return rc;
 431
 432         allocated_block =
 433             ext4_fs_index_in_group2_baddr(sb, rel_block_idx, block_group);
 434
 435         goto success;
 436     }
 437
 438     /* No free block found yet */
 439     rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 440     if (rc != EOK) {
 441         ext4_fs_put_block_group_ref(&bg_ref);
 442         return rc;
 443     }
 444
 445 goal_failed:
 446
 447     rc = ext4_fs_put_block_group_ref(&bg_ref);
 448     if (rc != EOK)
 449         return rc;
 450
 451     /* Try other block groups */
 452     uint32_t block_group_count = ext4_block_group_cnt(sb);
 453
 454     uint32_t bgid = (block_group + 1) % block_group_count;
 455     uint32_t count = block_group_count;
 456
 457     while (count > 0) {
 458         rc = ext4_fs_get_block_group_ref(inode_ref->fs, bgid, &bg_ref);
 459         if (rc != EOK)
 460             return rc;
 461
 462         free_blocks = ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 463         if (free_blocks == 0) {
 464             /* This group has no free blocks */
 465             goto next_group;
 466         }
 467
 468         /* Load block with bitmap */
 469         bitmap_block_addr = ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 470
 471         rc = ext4_block_get(inode_ref->fs->bdev, &bitmap_block,
 472                             bitmap_block_addr);
 473
 474         if (rc != EOK) {
 475             ext4_fs_put_block_group_ref(&bg_ref);
 476             return rc;
 477         }
 478
 479         /* Compute indexes */
 480         first_in_group = ext4_balloc_get_first_data_block_in_group(sb, &bg_ref);
 481         index_in_group = ext4_fs_baddr2_index_in_group(sb, first_in_group);
 482         blocks_in_group = ext4_blocks_in_group_cnt(sb, bgid);
 483
 484         first_in_group_index =
 485             ext4_fs_baddr2_index_in_group(sb, first_in_group);
 486
 487         if (index_in_group < first_in_group_index)
 488             index_in_group = first_in_group_index;
 489
 490         rc = ext4_bmap_bit_find_clr(bitmap_block.data, index_in_group,
 491                                     blocks_in_group, &rel_block_idx);
 492
 493         if (rc == EOK) {
 494
 495             ext4_bmap_bit_set(bitmap_block.data, rel_block_idx);
 496
 497             bitmap_block.dirty = true;
 498             rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 499             if (rc != EOK) {
 500                 ext4_fs_put_block_group_ref(&bg_ref);
 501                 return rc;
 502             }
 503
 504             allocated_block =
 505                 ext4_fs_index_in_group2_baddr(sb, rel_block_idx, bgid);
 506
 507             goto success;
 508         }
 509
 510         rc = ext4_block_set(inode_ref->fs->bdev, &bitmap_block);
 511         if (rc != EOK) {
 512             ext4_fs_put_block_group_ref(&bg_ref);
 513             return rc;
 514         }
 515
 516     next_group:
 517         rc = ext4_fs_put_block_group_ref(&bg_ref);
 518         if (rc != EOK) {
 519             return rc;
 520         }
 521
 522         /* Goto next group */
 523         bgid = (bgid + 1) % block_group_count;
 524         count--;
 525     }
 526
 527     return ENOSPC;
 528
 529 success:
 530     /* Empty command - because of syntax */
 531     ;
 532
 533     uint32_t block_size = ext4_sb_get_block_size(sb);
 534
 535     /* Update superblock free blocks count */
 536     uint64_t sb_free_blocks = ext4_sb_get_free_blocks_cnt(sb);
 537     sb_free_blocks--;
 538     ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 539
 540     /* Update inode blocks (different block size!) count */
 541     uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode);
 542     ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE;
 543     ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 544     inode_ref->dirty = true;
 545
 546     /* Update block group free blocks count */
 547     uint32_t bg_free_blocks =
 548         ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 549     bg_free_blocks--;
 550     ext4_bg_set_free_blocks_count(bg_ref.block_group, sb, bg_free_blocks);
 551
 552     bg_ref.dirty = true;
 553
 554     rc = ext4_fs_put_block_group_ref(&bg_ref);
 555
 556     *fblock = allocated_block;
 557     return rc;
 558 }
 559
 560 int ext4_balloc_try_alloc_block(struct ext4_inode_ref *inode_ref,
 561                                 uint32_t baddr, bool *free)
 562 {
 563     int rc;
 564
 565     struct ext4_fs *fs = inode_ref->fs;
 566     struct ext4_sblock *sb = &fs->sb;
 567
 568     /* Compute indexes */
 569     uint32_t block_group = ext4_balloc_get_bgid_of_block(sb, baddr);
 570     uint32_t index_in_group = ext4_fs_baddr2_index_in_group(sb, baddr);
 571
 572     /* Load block group reference */
 573     struct ext4_block_group_ref bg_ref;
 574     rc = ext4_fs_get_block_group_ref(fs, block_group, &bg_ref);
 575     if (rc != EOK)
 576         return rc;
 577
 578     /* Load block with bitmap */
 579     uint32_t bitmap_block_addr =
 580         ext4_bg_get_block_bitmap(bg_ref.block_group, sb);
 581
 582     struct ext4_block bitmap_block;
 583
 584     rc = ext4_block_get(fs->bdev, &bitmap_block, bitmap_block_addr);
 585     if (rc != EOK) {
 586         ext4_fs_put_block_group_ref(&bg_ref);
 587         return rc;
 588     }
 589
 590     /* Check if block is free */
 591     *free = ext4_bmap_is_bit_clr(bitmap_block.data, index_in_group);
 592
 593     /* Allocate block if possible */
 594     if (*free) {
 595         ext4_bmap_bit_set(bitmap_block.data, index_in_group);
 596         bitmap_block.dirty = true;
 597     }
 598
 599     /* Release block with bitmap */
 600     rc = ext4_block_set(fs->bdev, &bitmap_block);
 601     if (rc != EOK) {
 602         /* Error in saving bitmap */
 603         ext4_fs_put_block_group_ref(&bg_ref);
 604         return rc;
 605     }
 606
 607     /* If block is not free, return */
 608     if (!(*free))
 609         goto terminate;
 610
 611     uint32_t block_size = ext4_sb_get_block_size(sb);
 612
 613     /* Update superblock free blocks count */
 614     uint64_t sb_free_blocks = ext4_sb_get_free_blocks_cnt(sb);
 615     sb_free_blocks--;
 616     ext4_sb_set_free_blocks_cnt(sb, sb_free_blocks);
 617
 618     /* Update inode blocks count */
 619     uint64_t ino_blocks = ext4_inode_get_blocks_count(sb, inode_ref->inode);
 620     ino_blocks += block_size / EXT4_INODE_BLOCK_SIZE;
 621     ext4_inode_set_blocks_count(sb, inode_ref->inode, ino_blocks);
 622     inode_ref->dirty = true;
 623
 624     /* Update block group free blocks count */
 625     uint32_t free_blocks =
 626         ext4_bg_get_free_blocks_count(bg_ref.block_group, sb);
 627     free_blocks--;
 628     ext4_bg_set_free_blocks_count(bg_ref.block_group, sb, free_blocks);
 629
 630     bg_ref.dirty = true;
 631
 632 terminate:
 633     return ext4_fs_put_block_group_ref(&bg_ref);
 634 }
 635
 636 /**
 637  * @}
 638  */