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