src/ext4_dir.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_dir.h
  39  * @brief Directory handle procedures.
  40  */
  41
  42 #include "ext4_config.h"
  43 #include "ext4_types.h"
  44 #include "ext4_misc.h"
  45 #include "ext4_errno.h"
  46 #include "ext4_debug.h"
  47
  48 #include "ext4_trans.h"
  49 #include "ext4_dir.h"
  50 #include "ext4_dir_idx.h"
  51 #include "ext4_crc32.h"
  52 #include "ext4_inode.h"
  53 #include "ext4_fs.h"
  54
  55 #include <string.h>
  56
  57 /****************************************************************************/
  58
  59 /* Walk through a dirent block to find a checksum "dirent" at the tail */
  60 static struct ext4_dir_entry_tail *
  61 ext4_dir_get_tail(struct ext4_inode_ref *inode_ref,
  62                 struct ext4_dir_en *de)
  63 {
  64         struct ext4_dir_entry_tail *t;
  65         struct ext4_sblock *sb = &inode_ref->fs->sb;
  66
  67         t = EXT4_DIRENT_TAIL(de, ext4_sb_get_block_size(sb));
  68
  69         if (t->reserved_zero1 || t->reserved_zero2)
  70                 return NULL;
  71         if (to_le16(t->rec_len) != sizeof(struct ext4_dir_entry_tail))
  72                 return NULL;
  73         if (t->reserved_ft != EXT4_DIRENTRY_DIR_CSUM)
  74                 return NULL;
  75
  76         return t;
  77 }
  78
  79 #if CONFIG_META_CSUM_ENABLE
  80 static uint32_t ext4_dir_csum(struct ext4_inode_ref *inode_ref,
  81                               struct ext4_dir_en *dirent, int size)
  82 {
  83         uint32_t csum;
  84         struct ext4_sblock *sb = &inode_ref->fs->sb;
  85         uint32_t ino_index = to_le32(inode_ref->index);
  86         uint32_t ino_gen = to_le32(ext4_inode_get_generation(inode_ref->inode));
  87
  88         /* First calculate crc32 checksum against fs uuid */
  89         csum = ext4_crc32c(EXT4_CRC32_INIT, sb->uuid, sizeof(sb->uuid));
  90         /* Then calculate crc32 checksum against inode number
  91          * and inode generation */
  92         csum = ext4_crc32c(csum, &ino_index, sizeof(ino_index));
  93         csum = ext4_crc32c(csum, &ino_gen, sizeof(ino_gen));
  94         /* Finally calculate crc32 checksum against directory entries */
  95         csum = ext4_crc32c(csum, dirent, size);
  96         return csum;
  97 }
  98 #else
  99 #define ext4_dir_csum(...) 0
 100 #endif
 101
 102 bool ext4_dir_csum_verify(struct ext4_inode_ref *inode_ref,
 103                               struct ext4_dir_en *dirent)
 104 {
 105 #ifdef CONFIG_META_CSUM_ENABLE
 106         struct ext4_dir_entry_tail *t;
 107         struct ext4_sblock *sb = &inode_ref->fs->sb;
 108
 109         /* Compute the checksum only if the filesystem supports it */
 110         if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
 111                 t = ext4_dir_get_tail(inode_ref, dirent);
 112                 if (!t) {
 113                         /* There is no space to hold the checksum */
 114                         return false;
 115                 }
 116
 117                 ptrdiff_t __unused diff = (char *)t - (char *)dirent;
 118                 uint32_t csum = ext4_dir_csum(inode_ref, dirent, diff);
 119                 if (t->checksum != to_le32(csum))
 120                         return false;
 121
 122         }
 123 #endif
 124         return true;
 125 }
 126
 127 void ext4_dir_init_entry_tail(struct ext4_dir_entry_tail *t)
 128 {
 129         memset(t, 0, sizeof(struct ext4_dir_entry_tail));
 130         t->rec_len = to_le16(sizeof(struct ext4_dir_entry_tail));
 131         t->reserved_ft = EXT4_DIRENTRY_DIR_CSUM;
 132 }
 133
 134 void ext4_dir_set_csum(struct ext4_inode_ref *inode_ref,
 135                            struct ext4_dir_en *dirent)
 136 {
 137         struct ext4_dir_entry_tail *t;
 138         struct ext4_sblock *sb = &inode_ref->fs->sb;
 139
 140         /* Compute the checksum only if the filesystem supports it */
 141         if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
 142                 t = ext4_dir_get_tail(inode_ref, dirent);
 143                 if (!t) {
 144                         /* There is no space to hold the checksum */
 145                         return;
 146                 }
 147
 148                 ptrdiff_t __unused diff = (char *)t - (char *)dirent;
 149                 uint32_t csum = ext4_dir_csum(inode_ref, dirent, diff);
 150                 t->checksum = to_le32(csum);
 151         }
 152 }
 153
 154 /**@brief Do some checks before returning iterator.
 155  * @param it Iterator to be checked
 156  * @param block_size Size of data block
 157  * @return Error code
 158  */
 159 static int ext4_dir_iterator_set(struct ext4_dir_iter *it,
 160                                  uint32_t block_size)
 161 {
 162         uint32_t off_in_block = it->curr_off % block_size;
 163         struct ext4_sblock *sb = &it->inode_ref->fs->sb;
 164
 165         it->curr = NULL;
 166
 167         /* Ensure proper alignment */
 168         if ((off_in_block % 4) != 0)
 169                 return EIO;
 170
 171         /* Ensure that the core of the entry does not overflow the block */
 172         if (off_in_block > block_size - 8)
 173                 return EIO;
 174
 175         struct ext4_dir_en *en;
 176         en = (void *)(it->curr_blk.data + off_in_block);
 177
 178         /* Ensure that the whole entry does not overflow the block */
 179         uint16_t length = ext4_dir_en_get_entry_len(en);
 180         if (off_in_block + length > block_size)
 181                 return EIO;
 182
 183         /* Ensure the name length is not too large */
 184         if (ext4_dir_en_get_name_len(sb, en) > length - 8)
 185                 return EIO;
 186
 187         /* Everything OK - "publish" the entry */
 188         it->curr = en;
 189         return EOK;
 190 }
 191
 192 /**@brief Seek to next valid directory entry.
 193  *        Here can be jumped to the next data block.
 194  * @param it  Initialized iterator
 195  * @param pos Position of the next entry
 196  * @return Error code
 197  */
 198 static int ext4_dir_iterator_seek(struct ext4_dir_iter *it, uint64_t pos)
 199 {
 200         struct ext4_sblock *sb = &it->inode_ref->fs->sb;
 201         struct ext4_inode *inode = it->inode_ref->inode;
 202         struct ext4_blockdev *bdev = it->inode_ref->fs->bdev;
 203         uint64_t size = ext4_inode_get_size(sb, inode);
 204         int r;
 205
 206         /* The iterator is not valid until we seek to the desired position */
 207         it->curr = NULL;
 208
 209         /* Are we at the end? */
 210         if (pos >= size) {
 211                 if (it->curr_blk.lb_id) {
 212
 213                         r = ext4_block_set(bdev, &it->curr_blk);
 214                         it->curr_blk.lb_id = 0;
 215                         if (r != EOK)
 216                                 return r;
 217                 }
 218
 219                 it->curr_off = pos;
 220                 return EOK;
 221         }
 222
 223         /* Compute next block address */
 224         uint32_t block_size = ext4_sb_get_block_size(sb);
 225         uint64_t current_blk_idx = it->curr_off / block_size;
 226         uint32_t next_blk_idx = (uint32_t)(pos / block_size);
 227
 228         /*
 229          * If we don't have a block or are moving across block boundary,
 230          * we need to get another block
 231          */
 232         if ((it->curr_blk.lb_id == 0) ||
 233             (current_blk_idx != next_blk_idx)) {
 234                 if (it->curr_blk.lb_id) {
 235                         r = ext4_block_set(bdev, &it->curr_blk);
 236                         it->curr_blk.lb_id = 0;
 237
 238                         if (r != EOK)
 239                                 return r;
 240                 }
 241
 242                 ext4_fsblk_t next_blk;
 243                 r = ext4_fs_get_inode_dblk_idx(it->inode_ref, next_blk_idx,
 244                                                &next_blk, false);
 245                 if (r != EOK)
 246                         return r;
 247
 248                 r = ext4_trans_block_get(bdev, &it->curr_blk, next_blk);
 249                 if (r != EOK) {
 250                         it->curr_blk.lb_id = 0;
 251                         return r;
 252                 }
 253         }
 254
 255         it->curr_off = pos;
 256         return ext4_dir_iterator_set(it, block_size);
 257 }
 258
 259 int ext4_dir_iterator_init(struct ext4_dir_iter *it,
 260                            struct ext4_inode_ref *inode_ref, uint64_t pos)
 261 {
 262         it->inode_ref = inode_ref;
 263         it->curr = 0;
 264         it->curr_off = 0;
 265         it->curr_blk.lb_id = 0;
 266
 267         return ext4_dir_iterator_seek(it, pos);
 268 }
 269
 270 int ext4_dir_iterator_next(struct ext4_dir_iter *it)
 271 {
 272         int r = EOK;
 273         uint16_t skip;
 274
 275         while (r == EOK) {
 276                 skip = ext4_dir_en_get_entry_len(it->curr);
 277                 r = ext4_dir_iterator_seek(it, it->curr_off + skip);
 278
 279                 if (!it->curr)
 280                         break;
 281                 /*Skip NULL referenced entry*/
 282                 if (ext4_dir_en_get_inode(it->curr) != 0)
 283                         break;
 284         }
 285
 286         return r;
 287 }
 288
 289 int ext4_dir_iterator_fini(struct ext4_dir_iter *it)
 290 {
 291         it->curr = 0;
 292
 293         if (it->curr_blk.lb_id)
 294                 return ext4_block_set(it->inode_ref->fs->bdev, &it->curr_blk);
 295
 296         return EOK;
 297 }
 298
 299 void ext4_dir_write_entry(struct ext4_sblock *sb, struct ext4_dir_en *en,
 300                           uint16_t entry_len, struct ext4_inode_ref *child,
 301                           const char *name, size_t name_len)
 302 {
 303         /* Check maximum entry length */
 304         ext4_assert(entry_len <= ext4_sb_get_block_size(sb));
 305
 306         /* Set type of entry */
 307         switch (ext4_inode_type(sb, child->inode)) {
 308         case EXT4_INODE_MODE_DIRECTORY:
 309                 ext4_dir_en_set_inode_type(sb, en, EXT4_DE_DIR);
 310                 break;
 311         case EXT4_INODE_MODE_FILE:
 312                 ext4_dir_en_set_inode_type(sb, en, EXT4_DE_REG_FILE);
 313                 break;
 314         case EXT4_INODE_MODE_SOFTLINK:
 315                 ext4_dir_en_set_inode_type(sb, en, EXT4_DE_SYMLINK);
 316                 break;
 317         default:
 318                 /* FIXME: right now we only support 3 inode type. */
 319                 ext4_assert(0);
 320         }
 321
 322         /* Set basic attributes */
 323         ext4_dir_en_set_inode(en, child->index);
 324         ext4_dir_en_set_entry_len(en, entry_len);
 325         ext4_dir_en_set_name_len(sb, en, (uint16_t)name_len);
 326
 327         /* Write name */
 328         memcpy(en->name, name, name_len);
 329 }
 330
 331 int ext4_dir_add_entry(struct ext4_inode_ref *parent, const char *name,
 332                        uint32_t name_len, struct ext4_inode_ref *child)
 333 {
 334         int r;
 335         struct ext4_fs *fs = parent->fs;
 336         struct ext4_sblock *sb = &parent->fs->sb;
 337
 338 #if CONFIG_DIR_INDEX_ENABLE
 339         /* Index adding (if allowed) */
 340         if ((ext4_sb_feature_com(sb, EXT4_FCOM_DIR_INDEX)) &&
 341             (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) {
 342                 r = ext4_dir_dx_add_entry(parent, child, name);
 343
 344                 /* Check if index is not corrupted */
 345                 if (r != EXT4_ERR_BAD_DX_DIR) {
 346                         if (r != EOK)
 347                                 return r;
 348
 349                         return EOK;
 350                 }
 351
 352                 /* Needed to clear dir index flag if corrupted */
 353                 ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX);
 354                 parent->dirty = true;
 355         }
 356 #endif
 357
 358         /* Linear algorithm */
 359         uint32_t iblock = 0;
 360         ext4_fsblk_t fblock = 0;
 361         uint32_t block_size = ext4_sb_get_block_size(sb);
 362         uint64_t inode_size = ext4_inode_get_size(sb, parent->inode);
 363         uint32_t total_blocks = (uint32_t)(inode_size / block_size);
 364
 365         /* Find block, where is space for new entry and try to add */
 366         bool success = false;
 367         for (iblock = 0; iblock < total_blocks; ++iblock) {
 368                 r = ext4_fs_get_inode_dblk_idx(parent, iblock, &fblock, false);
 369                 if (r != EOK)
 370                         return r;
 371
 372                 struct ext4_block block;
 373                 r = ext4_trans_block_get(fs->bdev, &block, fblock);
 374                 if (r != EOK)
 375                         return r;
 376
 377                 if (!ext4_dir_csum_verify(parent, (void *)block.data)) {
 378                         ext4_dbg(DEBUG_DIR,
 379                                  DBG_WARN "Leaf block checksum failed."
 380                                  "Inode: %" PRIu32", "
 381                                  "Block: %" PRIu32"\n",
 382                                  parent->index,
 383                                  iblock);
 384                 }
 385
 386                 /* If adding is successful, function can finish */
 387                 r = ext4_dir_try_insert_entry(sb, parent, &block, child,
 388                                                 name, name_len);
 389                 if (r == EOK)
 390                         success = true;
 391
 392                 r = ext4_block_set(fs->bdev, &block);
 393                 if (r != EOK)
 394                         return r;
 395
 396                 if (success)
 397                         return EOK;
 398         }
 399
 400         /* No free block found - needed to allocate next data block */
 401
 402         iblock = 0;
 403         fblock = 0;
 404         r = ext4_fs_append_inode_dblk(parent, &fblock, &iblock);
 405         if (r != EOK)
 406                 return r;
 407
 408         /* Load new block */
 409         struct ext4_block b;
 410
 411         r = ext4_trans_block_get_noread(fs->bdev, &b, fblock);
 412         if (r != EOK)
 413                 return r;
 414
 415         /* Fill block with zeroes */
 416         memset(b.data, 0, block_size);
 417         struct ext4_dir_en *blk_en = (void *)b.data;
 418
 419         /* Save new block */
 420         if (ext4_sb_feature_ro_com(sb, EXT4_FRO_COM_METADATA_CSUM)) {
 421                 uint16_t el = block_size - sizeof(struct ext4_dir_entry_tail);
 422                 ext4_dir_write_entry(sb, blk_en, el, child, name, name_len);
 423                 ext4_dir_init_entry_tail(EXT4_DIRENT_TAIL(b.data, block_size));
 424         } else {
 425                 ext4_dir_write_entry(sb, blk_en, block_size, child, name,
 426                                 name_len);
 427         }
 428
 429         ext4_dir_set_csum(parent, (void *)b.data);
 430         ext4_trans_set_block_dirty(b.buf);
 431         r = ext4_block_set(fs->bdev, &b);
 432
 433         return r;
 434 }
 435
 436 int ext4_dir_find_entry(struct ext4_dir_search_result *result,
 437                         struct ext4_inode_ref *parent, const char *name,
 438                         uint32_t name_len)
 439 {
 440         int r;
 441         struct ext4_sblock *sb = &parent->fs->sb;
 442
 443         /* Entry clear */
 444         result->block.lb_id = 0;
 445         result->dentry = NULL;
 446
 447 #if CONFIG_DIR_INDEX_ENABLE
 448         /* Index search */
 449         if ((ext4_sb_feature_com(sb, EXT4_FCOM_DIR_INDEX)) &&
 450             (ext4_inode_has_flag(parent->inode, EXT4_INODE_FLAG_INDEX))) {
 451                 r = ext4_dir_dx_find_entry(result, parent, name_len, name);
 452                 /* Check if index is not corrupted */
 453                 if (r != EXT4_ERR_BAD_DX_DIR) {
 454                         if (r != EOK)
 455                                 return r;
 456
 457                         return EOK;
 458                 }
 459
 460                 /* Needed to clear dir index flag if corrupted */
 461                 ext4_inode_clear_flag(parent->inode, EXT4_INODE_FLAG_INDEX);
 462                 parent->dirty = true;
 463         }
 464 #endif
 465
 466         /* Linear algorithm */
 467
 468         uint32_t iblock;
 469         ext4_fsblk_t fblock;
 470         uint32_t block_size = ext4_sb_get_block_size(sb);
 471         uint64_t inode_size = ext4_inode_get_size(sb, parent->inode);
 472         uint32_t total_blocks = (uint32_t)(inode_size / block_size);
 473
 474         /* Walk through all data blocks */
 475         for (iblock = 0; iblock < total_blocks; ++iblock) {
 476                 /* Load block address */
 477                 r = ext4_fs_get_inode_dblk_idx(parent, iblock, &fblock, false);
 478                 if (r != EOK)
 479                         return r;
 480
 481                 /* Load data block */
 482                 struct ext4_block b;
 483                 r = ext4_trans_block_get(parent->fs->bdev, &b, fblock);
 484                 if (r != EOK)
 485                         return r;
 486
 487                 if (!ext4_dir_csum_verify(parent, (void *)b.data)) {
 488                         ext4_dbg(DEBUG_DIR,
 489                                  DBG_WARN "Leaf block checksum failed."
 490                                  "Inode: %" PRIu32", "
 491                                  "Block: %" PRIu32"\n",
 492                                  parent->index,
 493                                  iblock);
 494                 }
 495
 496                 /* Try to find entry in block */
 497                 struct ext4_dir_en *res_entry;
 498                 r = ext4_dir_find_in_block(&b, sb, name_len, name, &res_entry);
 499                 if (r == EOK) {
 500                         result->block = b;
 501                         result->dentry = res_entry;
 502                         return EOK;
 503                 }
 504
 505                 /* Entry not found - put block and continue to the next block */
 506
 507                 r = ext4_block_set(parent->fs->bdev, &b);
 508                 if (r != EOK)
 509                         return r;
 510         }
 511
 512         return ENOENT;
 513 }
 514
 515 int ext4_dir_remove_entry(struct ext4_inode_ref *parent, const char *name,
 516                           uint32_t name_len)
 517 {
 518         struct ext4_sblock *sb = &parent->fs->sb;
 519         /* Check if removing from directory */
 520         if (!ext4_inode_is_type(sb, parent->inode, EXT4_INODE_MODE_DIRECTORY))
 521                 return ENOTDIR;
 522
 523         /* Try to find entry */
 524         struct ext4_dir_search_result result;
 525         int rc = ext4_dir_find_entry(&result, parent, name, name_len);
 526         if (rc != EOK)
 527                 return rc;
 528
 529         /* Invalidate entry */
 530         ext4_dir_en_set_inode(result.dentry, 0);
 531
 532         /* Store entry position in block */
 533         uint32_t pos = (uint8_t *)result.dentry - result.block.data;
 534
 535         /*
 536          * If entry is not the first in block, it must be merged
 537          * with previous entry
 538          */
 539         if (pos != 0) {
 540                 uint32_t offset = 0;
 541
 542                 /* Start from the first entry in block */
 543                 struct ext4_dir_en *tmp_de =(void *)result.block.data;
 544                 uint16_t de_len = ext4_dir_en_get_entry_len(tmp_de);
 545
 546                 /* Find direct predecessor of removed entry */
 547                 while ((offset + de_len) < pos) {
 548                         offset += ext4_dir_en_get_entry_len(tmp_de);
 549                         tmp_de = (void *)(result.block.data + offset);
 550                         de_len = ext4_dir_en_get_entry_len(tmp_de);
 551                 }
 552
 553                 ext4_assert(de_len + offset == pos);
 554
 555                 /* Add to removed entry length to predecessor's length */
 556                 uint16_t del_len;
 557                 del_len = ext4_dir_en_get_entry_len(result.dentry);
 558                 ext4_dir_en_set_entry_len(tmp_de, de_len + del_len);
 559         }
 560
 561         ext4_dir_set_csum(parent,
 562                         (struct ext4_dir_en *)result.block.data);
 563         ext4_trans_set_block_dirty(result.block.buf);
 564
 565         return ext4_dir_destroy_result(parent, &result);
 566 }
 567
 568 int ext4_dir_try_insert_entry(struct ext4_sblock *sb,
 569                               struct ext4_inode_ref *inode_ref,
 570                               struct ext4_block *dst_blk,
 571                               struct ext4_inode_ref *child, const char *name,
 572                               uint32_t name_len)
 573 {
 574         /* Compute required length entry and align it to 4 bytes */
 575         uint32_t block_size = ext4_sb_get_block_size(sb);
 576         uint16_t required_len = sizeof(struct ext4_fake_dir_entry) + name_len;
 577
 578         if ((required_len % 4) != 0)
 579                 required_len += 4 - (required_len % 4);
 580
 581         /* Initialize pointers, stop means to upper bound */
 582         struct ext4_dir_en *start = (void *)dst_blk->data;
 583         struct ext4_dir_en *stop = (void *)(dst_blk->data + block_size);
 584
 585         /*
 586          * Walk through the block and check for invalid entries
 587          * or entries with free space for new entry
 588          */
 589         while (start < stop) {
 590                 uint32_t inode = ext4_dir_en_get_inode(start);
 591                 uint16_t rec_len = ext4_dir_en_get_entry_len(start);
 592                 uint8_t itype = ext4_dir_en_get_inode_type(sb, start);
 593
 594                 /* If invalid and large enough entry, use it */
 595                 if ((inode == 0) && (itype != EXT4_DIRENTRY_DIR_CSUM) &&
 596                     (rec_len >= required_len)) {
 597                         ext4_dir_write_entry(sb, start, rec_len, child, name,
 598                                              name_len);
 599                         ext4_dir_set_csum(inode_ref, (void *)dst_blk->data);
 600                         ext4_trans_set_block_dirty(dst_blk->buf);
 601
 602                         return EOK;
 603                 }
 604
 605                 /* Valid entry, try to split it */
 606                 if (inode != 0) {
 607                         uint16_t used_len;
 608                         used_len = ext4_dir_en_get_name_len(sb, start);
 609
 610                         uint16_t sz;
 611                         sz = sizeof(struct ext4_fake_dir_entry) + used_len;
 612
 613                         if ((used_len % 4) != 0)
 614                                 sz += 4 - (used_len % 4);
 615
 616                         uint16_t free_space = rec_len - sz;
 617
 618                         /* There is free space for new entry */
 619                         if (free_space >= required_len) {
 620                                 /* Cut tail of current entry */
 621                                 struct ext4_dir_en * new_entry;
 622                                 new_entry = (void *)((uint8_t *)start + sz);
 623                                 ext4_dir_en_set_entry_len(start, sz);
 624                                 ext4_dir_write_entry(sb, new_entry, free_space,
 625                                                      child, name, name_len);
 626
 627                                 ext4_dir_set_csum(inode_ref,
 628                                                   (void *)dst_blk->data);
 629                                 ext4_trans_set_block_dirty(dst_blk->buf);
 630                                 return EOK;
 631                         }
 632                 }
 633
 634                 /* Jump to the next entry */
 635                 start = (void *)((uint8_t *)start + rec_len);
 636         }
 637
 638         /* No free space found for new entry */
 639         return ENOSPC;
 640 }
 641
 642 int ext4_dir_find_in_block(struct ext4_block *block, struct ext4_sblock *sb,
 643                            size_t name_len, const char *name,
 644                            struct ext4_dir_en **res_entry)
 645 {
 646         /* Start from the first entry in block */
 647         struct ext4_dir_en *de = (struct ext4_dir_en *)block->data;
 648
 649         /* Set upper bound for cycling */
 650         uint8_t *addr_limit = block->data + ext4_sb_get_block_size(sb);
 651
 652         /* Walk through the block and check entries */
 653         while ((uint8_t *)de < addr_limit) {
 654                 /* Termination condition */
 655                 if ((uint8_t *)de + name_len > addr_limit)
 656                         break;
 657
 658                 /* Valid entry - check it */
 659                 if (ext4_dir_en_get_inode(de) != 0) {
 660                         /* For more efficient compare only lengths firstly*/
 661                         uint16_t el = ext4_dir_en_get_name_len(sb, de);
 662                         if (el == name_len) {
 663                                 /* Compare names */
 664                                 if (memcmp(name, de->name, name_len) == 0) {
 665                                         *res_entry = de;
 666                                         return EOK;
 667                                 }
 668                         }
 669                 }
 670
 671                 uint16_t de_len = ext4_dir_en_get_entry_len(de);
 672
 673                 /* Corrupted entry */
 674                 if (de_len == 0)
 675                         return EINVAL;
 676
 677                 /* Jump to next entry */
 678                 de = (struct ext4_dir_en *)((uint8_t *)de + de_len);
 679         }
 680
 681         /* Entry not found */
 682         return ENOENT;
 683 }
 684
 685 int ext4_dir_destroy_result(struct ext4_inode_ref *parent,
 686                             struct ext4_dir_search_result *result)
 687 {
 688         if (result->block.lb_id)
 689                 return ext4_block_set(parent->fs->bdev, &result->block);
 690
 691         return EOK;
 692 }
 693
 694 /**
 695  * @}
 696  */