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