src/ext4.c

   1 /*
   2  * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup lwext4
  30  * @{
  31  */
  32 /**
  33  * @file  ext4.h
  34  * @brief Ext4 high level operations (file, directory, mountpoints...)
  35  */
  36
  37 #include "ext4_config.h"
  38 #include "ext4_types.h"
  39 #include "ext4_misc.h"
  40 #include "ext4_errno.h"
  41 #include "ext4_oflags.h"
  42 #include "ext4_debug.h"
  43
  44 #include "ext4.h"
  45 #include "ext4_trans.h"
  46 #include "ext4_blockdev.h"
  47 #include "ext4_fs.h"
  48 #include "ext4_dir.h"
  49 #include "ext4_inode.h"
  50 #include "ext4_super.h"
  51 #include "ext4_block_group.h"
  52 #include "ext4_dir_idx.h"
  53 #include "ext4_xattr.h"
  54 #include "ext4_journal.h"
  55
  56
  57 #include <stdlib.h>
  58 #include <string.h>
  59
  60 /**@brief   Mount point OS dependent lock*/
  61 #define EXT4_MP_LOCK(_m)                                                       \
  62         do {                                                                   \
  63                 if ((_m)->os_locks)                                            \
  64                         (_m)->os_locks->lock();                                \
  65         } while (0)
  66
  67 /**@brief   Mount point OS dependent unlock*/
  68 #define EXT4_MP_UNLOCK(_m)                                                     \
  69         do {                                                                   \
  70                 if ((_m)->os_locks)                                            \
  71                         (_m)->os_locks->unlock();                              \
  72         } while (0)
  73
  74 /**@brief   Mount point descriptor.*/
  75 struct ext4_mountpoint {
  76
  77         /**@brief   Mount done flag.*/
  78         bool mounted;
  79
  80         /**@brief   Mount point name (@ref ext4_mount)*/
  81         char name[CONFIG_EXT4_MAX_MP_NAME + 1];
  82
  83         /**@brief   OS dependent lock/unlock functions.*/
  84         const struct ext4_lock *os_locks;
  85
  86         /**@brief   Ext4 filesystem internals.*/
  87         struct ext4_fs fs;
  88
  89         /**@brief   JBD fs.*/
  90         struct jbd_fs jbd_fs;
  91
  92         /**@brief   Journal.*/
  93         struct jbd_journal jbd_journal;
  94
  95         /**@brief   Block cache.*/
  96         struct ext4_bcache bc;
  97 };
  98
  99 /**@brief   Block devices descriptor.*/
 100 struct ext4_block_devices {
 101
 102         /**@brief   Block device name.*/
 103         char name[CONFIG_EXT4_MAX_BLOCKDEV_NAME + 1];
 104
 105         /**@brief   Block device handle.*/
 106         struct ext4_blockdev *bd;
 107 };
 108
 109 /**@brief   Block devices.*/
 110 static struct ext4_block_devices s_bdevices[CONFIG_EXT4_BLOCKDEVS_COUNT];
 111
 112 /**@brief   Mountpoints.*/
 113 static struct ext4_mountpoint s_mp[CONFIG_EXT4_MOUNTPOINTS_COUNT];
 114
 115 int ext4_device_register(struct ext4_blockdev *bd,
 116                          const char *dev_name)
 117 {
 118         ext4_assert(bd && dev_name);
 119
 120         if (strlen(dev_name) > CONFIG_EXT4_MAX_BLOCKDEV_NAME)
 121                 return EINVAL;
 122
 123         for (size_t i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {
 124                 if (!strcmp(s_bdevices[i].name, dev_name))
 125                         return EEXIST;
 126         }
 127
 128         for (size_t i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {
 129                 if (!s_bdevices[i].bd) {
 130                         strcpy(s_bdevices[i].name, dev_name);
 131                         s_bdevices[i].bd = bd;
 132                         return EOK;
 133                 }
 134         }
 135
 136         return ENOSPC;
 137 }
 138
 139 int ext4_device_unregister(const char *dev_name)
 140 {
 141         ext4_assert(dev_name);
 142
 143         for (size_t i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {
 144                 if (strcmp(s_bdevices[i].name, dev_name))
 145                         continue;
 146
 147                 memset(&s_bdevices[i], 0, sizeof(s_bdevices[i]));
 148         }
 149
 150         return ENOENT;
 151 }
 152
 153 int ext4_device_unregister_all(void)
 154 {
 155         memset(s_bdevices, 0, sizeof(s_bdevices));
 156
 157         return EOK;
 158 }
 159
 160 /****************************************************************************/
 161
 162 static bool ext4_is_dots(const uint8_t *name, size_t name_size)
 163 {
 164         if ((name_size == 1) && (name[0] == '.'))
 165                 return true;
 166
 167         if ((name_size == 2) && (name[0] == '.') && (name[1] == '.'))
 168                 return true;
 169
 170         return false;
 171 }
 172
 173 static int ext4_has_children(bool *has_children, struct ext4_inode_ref *enode)
 174 {
 175         struct ext4_sblock *sb = &enode->fs->sb;
 176
 177         /* Check if node is directory */
 178         if (!ext4_inode_is_type(sb, enode->inode, EXT4_INODE_MODE_DIRECTORY)) {
 179                 *has_children = false;
 180                 return EOK;
 181         }
 182
 183         struct ext4_dir_iter it;
 184         int rc = ext4_dir_iterator_init(&it, enode, 0);
 185         if (rc != EOK)
 186                 return rc;
 187
 188         /* Find a non-empty directory entry */
 189         bool found = false;
 190         while (it.curr != NULL) {
 191                 if (ext4_dir_en_get_inode(it.curr) != 0) {
 192                         uint16_t nsize;
 193                         nsize = ext4_dir_en_get_name_len(sb, it.curr);
 194                         if (!ext4_is_dots(it.curr->name, nsize)) {
 195                                 found = true;
 196                                 break;
 197                         }
 198                 }
 199
 200                 rc = ext4_dir_iterator_next(&it);
 201                 if (rc != EOK) {
 202                         ext4_dir_iterator_fini(&it);
 203                         return rc;
 204                 }
 205         }
 206
 207         rc = ext4_dir_iterator_fini(&it);
 208         if (rc != EOK)
 209                 return rc;
 210
 211         *has_children = found;
 212
 213         return EOK;
 214 }
 215
 216 static int ext4_link(struct ext4_mountpoint *mp, struct ext4_inode_ref *parent,
 217                      struct ext4_inode_ref *ch, const char *n,
 218                      uint32_t len, bool rename)
 219 {
 220         /* Check maximum name length */
 221         if (len > EXT4_DIRECTORY_FILENAME_LEN)
 222                 return EINVAL;
 223
 224         /* Add entry to parent directory */
 225         int r = ext4_dir_add_entry(parent, n, len, ch);
 226         if (r != EOK)
 227                 return r;
 228
 229         /* Fill new dir -> add '.' and '..' entries.
 230          * Also newly allocated inode should have 0 link count.
 231          */
 232
 233         bool is_dir = ext4_inode_is_type(&mp->fs.sb, ch->inode,
 234                                EXT4_INODE_MODE_DIRECTORY);
 235         if (is_dir && !rename) {
 236
 237 #if CONFIG_DIR_INDEX_ENABLE
 238                 /* Initialize directory index if supported */
 239                 if (ext4_sb_feature_com(&mp->fs.sb, EXT4_FCOM_DIR_INDEX)) {
 240                         r = ext4_dir_dx_init(ch, parent);
 241                         if (r != EOK)
 242                                 return r;
 243
 244                         ext4_inode_set_flag(ch->inode, EXT4_INODE_FLAG_INDEX);
 245                         ch->dirty = true;
 246                 } else
 247 #endif
 248                 {
 249                         r = ext4_dir_add_entry(ch, ".", strlen("."), ch);
 250                         if (r != EOK) {
 251                                 ext4_dir_remove_entry(parent, n, strlen(n));
 252                                 return r;
 253                         }
 254
 255                         r = ext4_dir_add_entry(ch, "..", strlen(".."), parent);
 256                         if (r != EOK) {
 257                                 ext4_dir_remove_entry(parent, n, strlen(n));
 258                                 ext4_dir_remove_entry(ch, ".", strlen("."));
 259                                 return r;
 260                         }
 261                 }
 262
 263                 /*New empty directory. Two links (. and ..) */
 264                 ext4_inode_set_links_cnt(ch->inode, 2);
 265                 ext4_fs_inode_links_count_inc(parent);
 266                 ch->dirty = true;
 267                 parent->dirty = true;
 268                 return r;
 269         }
 270         /*
 271          * In case we want to rename a directory,
 272          * we reset the original '..' pointer.
 273          */
 274         if (is_dir) {
 275                 bool idx;
 276                 idx = ext4_inode_has_flag(ch->inode, EXT4_INODE_FLAG_INDEX);
 277                 struct ext4_dir_search_result res;
 278                 if (!idx) {
 279                         r = ext4_dir_find_entry(&res, ch, "..", strlen(".."));
 280                         if (r != EOK)
 281                                 return EIO;
 282
 283                         ext4_dir_en_set_inode(res.dentry, parent->index);
 284                         ext4_trans_set_block_dirty(res.block.buf);
 285                         r = ext4_dir_destroy_result(ch, &res);
 286                         if (r != EOK)
 287                                 return r;
 288
 289                 } else {
 290 #if CONFIG_DIR_INDEX_ENABLE
 291                         r = ext4_dir_dx_reset_parent_inode(ch, parent->index);
 292                         if (r != EOK)
 293                                 return r;
 294
 295 #endif
 296                 }
 297
 298                 ext4_fs_inode_links_count_inc(parent);
 299                 parent->dirty = true;
 300         }
 301         if (!rename) {
 302                 ext4_fs_inode_links_count_inc(ch);
 303                 ch->dirty = true;
 304         }
 305
 306         return r;
 307 }
 308
 309 static int ext4_unlink(struct ext4_mountpoint *mp,
 310                        struct ext4_inode_ref *parent,
 311                        struct ext4_inode_ref *child, const char *name,
 312                        uint32_t name_len)
 313 {
 314         bool has_children;
 315         int rc = ext4_has_children(&has_children, child);
 316         if (rc != EOK)
 317                 return rc;
 318
 319         /* Cannot unlink non-empty node */
 320         if (has_children)
 321                 return ENOTEMPTY;
 322
 323         /* Remove entry from parent directory */
 324         rc = ext4_dir_remove_entry(parent, name, name_len);
 325         if (rc != EOK)
 326                 return rc;
 327
 328         bool is_dir = ext4_inode_is_type(&mp->fs.sb, child->inode,
 329                                          EXT4_INODE_MODE_DIRECTORY);
 330
 331         /* If directory - handle links from parent */
 332         if (is_dir) {
 333                 ext4_fs_inode_links_count_dec(parent);
 334                 parent->dirty = true;
 335         }
 336
 337         /*
 338          * TODO: Update timestamps of the parent
 339          * (when we have wall-clock time).
 340          *
 341          * ext4_inode_set_change_inode_time(parent->inode, (uint32_t) now);
 342          * ext4_inode_set_modification_time(parent->inode, (uint32_t) now);
 343          * parent->dirty = true;
 344          */
 345
 346         /*
 347          * TODO: Update timestamp for inode.
 348          *
 349          * ext4_inode_set_change_inode_time(child->inode,
 350          *     (uint32_t) now);
 351          */
 352         if (ext4_inode_get_links_cnt(child->inode)) {
 353                 ext4_fs_inode_links_count_dec(child);
 354                 child->dirty = true;
 355         }
 356
 357         return EOK;
 358 }
 359
 360 /****************************************************************************/
 361
 362 int ext4_mount(const char *dev_name, const char *mount_point,
 363                bool read_only)
 364 {
 365         int r;
 366         uint32_t bsize;
 367         struct ext4_bcache *bc;
 368         struct ext4_blockdev *bd = 0;
 369         struct ext4_mountpoint *mp = 0;
 370
 371         ext4_assert(mount_point && dev_name);
 372
 373         size_t mp_len = strlen(mount_point);
 374
 375         if (mp_len > CONFIG_EXT4_MAX_MP_NAME)
 376                 return EINVAL;
 377
 378         if (mount_point[mp_len - 1] != '/')
 379                 return ENOTSUP;
 380
 381         for (size_t i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {
 382                 if (s_bdevices[i].name) {
 383                         if (!strcmp(dev_name, s_bdevices[i].name)) {
 384                                 bd = s_bdevices[i].bd;
 385                                 break;
 386                         }
 387                 }
 388         }
 389
 390         if (!bd)
 391                 return ENODEV;
 392
 393         for (size_t i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
 394                 if (!s_mp[i].mounted) {
 395                         strcpy(s_mp[i].name, mount_point);
 396                         s_mp[i].mounted = 1;
 397                         mp = &s_mp[i];
 398                         break;
 399                 }
 400
 401                 if (!strcmp(s_mp[i].name, mount_point))
 402                         return EOK;
 403         }
 404
 405         if (!mp)
 406                 return ENOMEM;
 407
 408         r = ext4_block_init(bd);
 409         if (r != EOK)
 410                 return r;
 411
 412         r = ext4_fs_init(&mp->fs, bd, read_only);
 413         if (r != EOK) {
 414                 ext4_block_fini(bd);
 415                 return r;
 416         }
 417
 418         bsize = ext4_sb_get_block_size(&mp->fs.sb);
 419         ext4_block_set_lb_size(bd, bsize);
 420         bc = &mp->bc;
 421
 422         r = ext4_bcache_init_dynamic(bc, CONFIG_BLOCK_DEV_CACHE_SIZE, bsize);
 423         if (r != EOK) {
 424                 ext4_block_fini(bd);
 425                 return r;
 426         }
 427
 428         if (bsize != bc->itemsize)
 429                 return ENOTSUP;
 430
 431         /*Bind block cache to block device*/
 432         r = ext4_block_bind_bcache(bd, bc);
 433         if (r != EOK) {
 434                 ext4_bcache_cleanup(bc);
 435                 ext4_block_fini(bd);
 436                 ext4_bcache_fini_dynamic(bc);
 437                 return r;
 438         }
 439
 440         bd->fs = &mp->fs;
 441         return r;
 442 }
 443
 444
 445 int ext4_umount(const char *mount_point)
 446 {
 447         int i;
 448         int r;
 449         struct ext4_mountpoint *mp = 0;
 450
 451         for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
 452                 if (!strcmp(s_mp[i].name, mount_point)) {
 453                         mp = &s_mp[i];
 454                         break;
 455                 }
 456         }
 457
 458         if (!mp)
 459                 return ENODEV;
 460
 461         r = ext4_fs_fini(&mp->fs);
 462         if (r != EOK)
 463                 goto Finish;
 464
 465         mp->mounted = 0;
 466
 467         ext4_bcache_cleanup(mp->fs.bdev->bc);
 468         ext4_bcache_fini_dynamic(mp->fs.bdev->bc);
 469
 470         r = ext4_block_fini(mp->fs.bdev);
 471 Finish:
 472         mp->fs.bdev->fs = NULL;
 473         return r;
 474 }
 475
 476 static struct ext4_mountpoint *ext4_get_mount(const char *path)
 477 {
 478         for (size_t i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
 479
 480                 if (!s_mp[i].mounted)
 481                         continue;
 482
 483                 if (!strncmp(s_mp[i].name, path, strlen(s_mp[i].name)))
 484                         return &s_mp[i];
 485         }
 486
 487         return NULL;
 488 }
 489
 490 __unused
 491 static int __ext4_journal_start(const char *mount_point)
 492 {
 493         int r = EOK;
 494         struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
 495
 496         if (!mp)
 497                 return ENOENT;
 498
 499         if (mp->fs.read_only)
 500                 return EOK;
 501
 502         if (ext4_sb_feature_com(&mp->fs.sb,
 503                                 EXT4_FCOM_HAS_JOURNAL)) {
 504                 r = jbd_get_fs(&mp->fs, &mp->jbd_fs);
 505                 if (r != EOK)
 506                         goto Finish;
 507
 508                 r = jbd_journal_start(&mp->jbd_fs, &mp->jbd_journal);
 509                 if (r != EOK) {
 510                         mp->jbd_fs.dirty = false;
 511                         jbd_put_fs(&mp->jbd_fs);
 512                         goto Finish;
 513                 }
 514                 mp->fs.jbd_fs = &mp->jbd_fs;
 515                 mp->fs.jbd_journal = &mp->jbd_journal;
 516         }
 517 Finish:
 518         return r;
 519 }
 520
 521 __unused
 522 static int __ext4_journal_stop(const char *mount_point)
 523 {
 524         int r = EOK;
 525         struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
 526
 527         if (!mp)
 528                 return ENOENT;
 529
 530         if (mp->fs.read_only)
 531                 return EOK;
 532
 533         if (ext4_sb_feature_com(&mp->fs.sb,
 534                                 EXT4_FCOM_HAS_JOURNAL)) {
 535                 r = jbd_journal_stop(&mp->jbd_journal);
 536                 if (r != EOK) {
 537                         mp->jbd_fs.dirty = false;
 538                         jbd_put_fs(&mp->jbd_fs);
 539                         mp->fs.jbd_journal = NULL;
 540                         mp->fs.jbd_fs = NULL;
 541                         goto Finish;
 542                 }
 543
 544                 r = jbd_put_fs(&mp->jbd_fs);
 545                 if (r != EOK) {
 546                         mp->fs.jbd_journal = NULL;
 547                         mp->fs.jbd_fs = NULL;
 548                         goto Finish;
 549                 }
 550
 551                 mp->fs.jbd_journal = NULL;
 552                 mp->fs.jbd_fs = NULL;
 553         }
 554 Finish:
 555         return r;
 556 }
 557
 558 __unused
 559 static int __ext4_recover(const char *mount_point)
 560 {
 561         struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
 562         int r = ENOTSUP;
 563
 564         if (!mp)
 565                 return ENOENT;
 566
 567         EXT4_MP_LOCK(mp);
 568         if (ext4_sb_feature_com(&mp->fs.sb, EXT4_FCOM_HAS_JOURNAL)) {
 569                 struct jbd_fs *jbd_fs = ext4_calloc(1, sizeof(struct jbd_fs));
 570                 if (!jbd_fs) {
 571                          r = ENOMEM;
 572                          goto Finish;
 573                 }
 574
 575                 r = jbd_get_fs(&mp->fs, jbd_fs);
 576                 if (r != EOK) {
 577                         ext4_free(jbd_fs);
 578                         goto Finish;
 579                 }
 580
 581                 r = jbd_recover(jbd_fs);
 582                 jbd_put_fs(jbd_fs);
 583                 ext4_free(jbd_fs);
 584         }
 585         if (r == EOK && !mp->fs.read_only) {
 586                 uint32_t bgid;
 587                 uint64_t free_blocks_count = 0;
 588                 uint32_t free_inodes_count = 0;
 589                 struct ext4_block_group_ref bg_ref;
 590
 591                 /* Update superblock's stats */
 592                 for (bgid = 0;bgid < ext4_block_group_cnt(&mp->fs.sb);bgid++) {
 593                         r = ext4_fs_get_block_group_ref(&mp->fs, bgid, &bg_ref);
 594                         if (r != EOK)
 595                                 goto Finish;
 596
 597                         free_blocks_count +=
 598                                 ext4_bg_get_free_blocks_count(bg_ref.block_group,
 599                                                 &mp->fs.sb);
 600                         free_inodes_count +=
 601                                 ext4_bg_get_free_inodes_count(bg_ref.block_group,
 602                                                 &mp->fs.sb);
 603
 604                         ext4_fs_put_block_group_ref(&bg_ref);
 605                 }
 606                 ext4_sb_set_free_blocks_cnt(&mp->fs.sb, free_blocks_count);
 607                 ext4_set32(&mp->fs.sb, free_inodes_count, free_inodes_count);
 608                 /* We don't need to save the superblock stats immediately. */
 609         }
 610
 611 Finish:
 612         EXT4_MP_UNLOCK(mp);
 613         return r;
 614 }
 615
 616 __unused
 617 static int __ext4_trans_start(struct ext4_mountpoint *mp)
 618 {
 619         int r = EOK;
 620
 621         if (mp->fs.jbd_journal && !mp->fs.curr_trans) {
 622                 struct jbd_journal *journal = mp->fs.jbd_journal;
 623                 struct jbd_trans *trans;
 624                 trans = jbd_journal_new_trans(journal);
 625                 if (!trans) {
 626                         r = ENOMEM;
 627                         goto Finish;
 628                 }
 629                 mp->fs.curr_trans = trans;
 630         }
 631 Finish:
 632         return r;
 633 }
 634
 635 __unused
 636 static int __ext4_trans_stop(struct ext4_mountpoint *mp)
 637 {
 638         int r = EOK;
 639
 640         if (mp->fs.jbd_journal && mp->fs.curr_trans) {
 641                 struct jbd_journal *journal = mp->fs.jbd_journal;
 642                 struct jbd_trans *trans = mp->fs.curr_trans;
 643                 r = jbd_journal_commit_trans(journal, trans);
 644                 mp->fs.curr_trans = NULL;
 645         }
 646         return r;
 647 }
 648
 649 __unused
 650 static void __ext4_trans_abort(struct ext4_mountpoint *mp)
 651 {
 652         if (mp->fs.jbd_journal && mp->fs.curr_trans) {
 653                 struct jbd_journal *journal = mp->fs.jbd_journal;
 654                 struct jbd_trans *trans = mp->fs.curr_trans;
 655                 jbd_journal_free_trans(journal, trans, true);
 656                 mp->fs.curr_trans = NULL;
 657         }
 658 }
 659
 660 int ext4_journal_start(const char *mount_point __unused)
 661 {
 662         int r = EOK;
 663 #if CONFIG_JOURNALING_ENABLE
 664         r = __ext4_journal_start(mount_point);
 665 #endif
 666         return r;
 667 }
 668
 669 int ext4_journal_stop(const char *mount_point __unused)
 670 {
 671         int r = EOK;
 672 #if CONFIG_JOURNALING_ENABLE
 673         r = __ext4_journal_stop(mount_point);
 674 #endif
 675         return r;
 676 }
 677
 678 int ext4_recover(const char *mount_point __unused)
 679 {
 680         int r = EOK;
 681 #if CONFIG_JOURNALING_ENABLE
 682         r = __ext4_recover(mount_point);
 683 #endif
 684         return r;
 685 }
 686
 687 static int ext4_trans_start(struct ext4_mountpoint *mp __unused)
 688 {
 689         int r = EOK;
 690 #if CONFIG_JOURNALING_ENABLE
 691         r = __ext4_trans_start(mp);
 692 #endif
 693         return r;
 694 }
 695
 696 static int ext4_trans_stop(struct ext4_mountpoint *mp __unused)
 697 {
 698         int r = EOK;
 699 #if CONFIG_JOURNALING_ENABLE
 700         r = __ext4_trans_stop(mp);
 701 #endif
 702         return r;
 703 }
 704
 705 static void ext4_trans_abort(struct ext4_mountpoint *mp __unused)
 706 {
 707 #if CONFIG_JOURNALING_ENABLE
 708         __ext4_trans_abort(mp);
 709 #endif
 710 }
 711
 712
 713 int ext4_mount_point_stats(const char *mount_point,
 714                            struct ext4_mount_stats *stats)
 715 {
 716         struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
 717
 718         if (!mp)
 719                 return ENOENT;
 720
 721         EXT4_MP_LOCK(mp);
 722         stats->inodes_count = ext4_get32(&mp->fs.sb, inodes_count);
 723         stats->free_inodes_count = ext4_get32(&mp->fs.sb, free_inodes_count);
 724         stats->blocks_count = ext4_sb_get_blocks_cnt(&mp->fs.sb);
 725         stats->free_blocks_count = ext4_sb_get_free_blocks_cnt(&mp->fs.sb);
 726         stats->block_size = ext4_sb_get_block_size(&mp->fs.sb);
 727
 728         stats->block_group_count = ext4_block_group_cnt(&mp->fs.sb);
 729         stats->blocks_per_group = ext4_get32(&mp->fs.sb, blocks_per_group);
 730         stats->inodes_per_group = ext4_get32(&mp->fs.sb, inodes_per_group);
 731
 732         memcpy(stats->volume_name, mp->fs.sb.volume_name, 16);
 733         EXT4_MP_UNLOCK(mp);
 734
 735         return EOK;
 736 }
 737
 738 int ext4_mount_setup_locks(const char *mount_point,
 739                            const struct ext4_lock *locks)
 740 {
 741         uint32_t i;
 742         struct ext4_mountpoint *mp = 0;
 743
 744         for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
 745                 if (!strcmp(s_mp[i].name, mount_point)) {
 746                         mp = &s_mp[i];
 747                         break;
 748                 }
 749         }
 750         if (!mp)
 751                 return ENOENT;
 752
 753         mp->os_locks = locks;
 754         return EOK;
 755 }
 756
 757 /********************************FILE OPERATIONS*****************************/
 758
 759 static int ext4_path_check(const char *path, bool *is_goal)
 760 {
 761         int i;
 762
 763         for (i = 0; i < EXT4_DIRECTORY_FILENAME_LEN; ++i) {
 764
 765                 if (path[i] == '/') {
 766                         *is_goal = false;
 767                         return i;
 768                 }
 769
 770                 if (path[i] == 0) {
 771                         *is_goal = true;
 772                         return i;
 773                 }
 774         }
 775
 776         return 0;
 777 }
 778
 779 static bool ext4_parse_flags(const char *flags, uint32_t *file_flags)
 780 {
 781         if (!flags)
 782                 return false;
 783
 784         if (!strcmp(flags, "r") || !strcmp(flags, "rb")) {
 785                 *file_flags = O_RDONLY;
 786                 return true;
 787         }
 788
 789         if (!strcmp(flags, "w") || !strcmp(flags, "wb")) {
 790                 *file_flags = O_WRONLY | O_CREAT | O_TRUNC;
 791                 return true;
 792         }
 793
 794         if (!strcmp(flags, "a") || !strcmp(flags, "ab")) {
 795                 *file_flags = O_WRONLY | O_CREAT | O_APPEND;
 796                 return true;
 797         }
 798
 799         if (!strcmp(flags, "r+") || !strcmp(flags, "rb+") ||
 800             !strcmp(flags, "r+b")) {
 801                 *file_flags = O_RDWR;
 802                 return true;
 803         }
 804
 805         if (!strcmp(flags, "w+") || !strcmp(flags, "wb+") ||
 806             !strcmp(flags, "w+b")) {
 807                 *file_flags = O_RDWR | O_CREAT | O_TRUNC;
 808                 return true;
 809         }
 810
 811         if (!strcmp(flags, "a+") || !strcmp(flags, "ab+") ||
 812             !strcmp(flags, "a+b")) {
 813                 *file_flags = O_RDWR | O_CREAT | O_APPEND;
 814                 return true;
 815         }
 816
 817         return false;
 818 }
 819
 820 static int ext4_trunc_inode(struct ext4_mountpoint *mp,
 821                             uint32_t index, uint64_t new_size)
 822 {
 823         int r = EOK;
 824         struct ext4_fs *const fs = &mp->fs;
 825         struct ext4_inode_ref inode_ref;
 826         uint64_t inode_size;
 827         bool has_trans = mp->fs.jbd_journal && mp->fs.curr_trans;
 828         r = ext4_fs_get_inode_ref(fs, index, &inode_ref);
 829         if (r != EOK)
 830                 return r;
 831
 832         inode_size = ext4_inode_get_size(&fs->sb, inode_ref.inode);
 833         ext4_fs_put_inode_ref(&inode_ref);
 834         if (has_trans)
 835                 ext4_trans_stop(mp);
 836
 837         while (inode_size > new_size + CONFIG_MAX_TRUNCATE_SIZE) {
 838
 839                 inode_size -= CONFIG_MAX_TRUNCATE_SIZE;
 840
 841                 ext4_trans_start(mp);
 842                 r = ext4_fs_get_inode_ref(fs, index, &inode_ref);
 843                 if (r != EOK) {
 844                         ext4_trans_abort(mp);
 845                         break;
 846                 }
 847                 r = ext4_fs_truncate_inode(&inode_ref, inode_size);
 848                 if (r != EOK)
 849                         ext4_fs_put_inode_ref(&inode_ref);
 850                 else
 851                         r = ext4_fs_put_inode_ref(&inode_ref);
 852
 853                 if (r != EOK) {
 854                         ext4_trans_abort(mp);
 855                         goto Finish;
 856                 } else
 857                         ext4_trans_stop(mp);
 858         }
 859
 860         if (inode_size > new_size) {
 861
 862                 inode_size = new_size;
 863
 864                 ext4_trans_start(mp);
 865                 r = ext4_fs_get_inode_ref(fs, index, &inode_ref);
 866                 if (r != EOK) {
 867                         ext4_trans_abort(mp);
 868                         goto Finish;
 869                 }
 870                 r = ext4_fs_truncate_inode(&inode_ref, inode_size);
 871                 if (r != EOK)
 872                         ext4_fs_put_inode_ref(&inode_ref);
 873                 else
 874                         r = ext4_fs_put_inode_ref(&inode_ref);
 875
 876                 if (r != EOK)
 877                         ext4_trans_abort(mp);
 878                 else
 879                         ext4_trans_stop(mp);
 880
 881         }
 882
 883 Finish:
 884
 885         if (has_trans)
 886                 ext4_trans_start(mp);
 887
 888         return r;
 889 }
 890
 891 static int ext4_trunc_dir(struct ext4_mountpoint *mp,
 892                           struct ext4_inode_ref *parent,
 893                           struct ext4_inode_ref *dir)
 894 {
 895         int r = EOK;
 896         bool is_dir = ext4_inode_is_type(&mp->fs.sb, dir->inode,
 897                         EXT4_INODE_MODE_DIRECTORY);
 898         uint32_t block_size = ext4_sb_get_block_size(&mp->fs.sb);
 899         if (!is_dir)
 900                 return EINVAL;
 901
 902 #if CONFIG_DIR_INDEX_ENABLE
 903         /* Initialize directory index if supported */
 904         if (ext4_sb_feature_com(&mp->fs.sb, EXT4_FCOM_DIR_INDEX)) {
 905                 r = ext4_dir_dx_init(dir, parent);
 906                 if (r != EOK)
 907                         return r;
 908
 909                 r = ext4_trunc_inode(mp, dir->index,
 910                                      EXT4_DIR_DX_INIT_BCNT * block_size);
 911                 if (r != EOK)
 912                         return r;
 913         } else
 914 #endif
 915         {
 916                 r = ext4_trunc_inode(mp, dir->index, block_size);
 917                 if (r != EOK)
 918                         return r;
 919         }
 920
 921         return ext4_fs_truncate_inode(dir, 0);
 922 }
 923
 924 /*
 925  * NOTICE: if filetype is equal to EXT4_DIRENTRY_UNKNOWN,
 926  * any filetype of the target dir entry will be accepted.
 927  */
 928 static int ext4_generic_open2(ext4_file *f, const char *path, int flags,
 929                               int ftype, uint32_t *parent_inode,
 930                               uint32_t *name_off)
 931 {
 932         bool is_goal = false;
 933         uint32_t imode = EXT4_INODE_MODE_DIRECTORY;
 934         uint32_t next_inode;
 935
 936         int r;
 937         int len;
 938         struct ext4_mountpoint *mp = ext4_get_mount(path);
 939         struct ext4_dir_search_result result;
 940         struct ext4_inode_ref ref;
 941
 942         f->mp = 0;
 943
 944         if (!mp)
 945                 return ENOENT;
 946
 947         struct ext4_fs *const fs = &mp->fs;
 948         struct ext4_sblock *const sb = &mp->fs.sb;
 949
 950         if (fs->read_only && flags & O_CREAT)
 951                 return EROFS;
 952
 953         f->flags = flags;
 954
 955         /*Skip mount point*/
 956         path += strlen(mp->name);
 957
 958         if (name_off)
 959                 *name_off = strlen(mp->name);
 960
 961         /*Load root*/
 962         r = ext4_fs_get_inode_ref(fs, EXT4_INODE_ROOT_INDEX, &ref);
 963         if (r != EOK)
 964                 return r;
 965
 966         if (parent_inode)
 967                 *parent_inode = ref.index;
 968
 969         if (flags & O_CREAT)
 970                 ext4_trans_start(mp);
 971
 972         len = ext4_path_check(path, &is_goal);
 973         while (1) {
 974
 975                 len = ext4_path_check(path, &is_goal);
 976                 if (!len) {
 977                         /*If root open was request.*/
 978                         if (ftype == EXT4_DE_DIR || ftype == EXT4_DE_UNKNOWN)
 979                                 if (is_goal)
 980                                         break;
 981
 982                         r = ENOENT;
 983                         break;
 984                 }
 985
 986                 r = ext4_dir_find_entry(&result, &ref, path, len);
 987                 if (r != EOK) {
 988
 989                         /*Destroy last result*/
 990                         ext4_dir_destroy_result(&ref, &result);
 991                         if (r != ENOENT)
 992                                 break;
 993
 994                         if (!(f->flags & O_CREAT))
 995                                 break;
 996
 997                         /*O_CREAT allows create new entry*/
 998                         struct ext4_inode_ref child_ref;
 999                         r = ext4_fs_alloc_inode(fs, &child_ref,
1000                                         is_goal ? ftype : EXT4_DE_DIR);
1001                         if (r != EOK)
1002                                 break;
1003
1004
1005                         /*Link with root dir.*/
1006                         r = ext4_link(mp, &ref, &child_ref, path, len, false);
1007                         if (r != EOK) {
1008                                 /*Fail. Free new inode.*/
1009                                 ext4_fs_free_inode(&child_ref);
1010                                 /*We do not want to write new inode.
1011                                   But block has to be released.*/
1012                                 child_ref.dirty = false;
1013                                 ext4_fs_put_inode_ref(&child_ref);
1014                                 break;
1015                         }
1016
1017                         ext4_fs_put_inode_ref(&child_ref);
1018                         continue;
1019                 }
1020
1021                 if (parent_inode)
1022                         *parent_inode = ref.index;
1023
1024                 next_inode = ext4_dir_en_get_inode(result.dentry);
1025                 if (ext4_sb_feature_incom(sb, EXT4_FINCOM_FILETYPE)) {
1026                         uint8_t t;
1027                         t = ext4_dir_en_get_inode_type(sb, result.dentry);
1028                         imode = ext4_fs_correspond_inode_mode(t);
1029                 } else {
1030                         struct ext4_inode_ref child_ref;
1031                         r = ext4_fs_get_inode_ref(fs, next_inode, &child_ref);
1032                         if (r != EOK)
1033                                 break;
1034
1035                         imode = ext4_inode_type(sb, child_ref.inode);
1036                         ext4_fs_put_inode_ref(&child_ref);
1037                 }
1038
1039                 r = ext4_dir_destroy_result(&ref, &result);
1040                 if (r != EOK)
1041                         break;
1042
1043                 /*If expected file error*/
1044                 if (imode != EXT4_INODE_MODE_DIRECTORY && !is_goal) {
1045                         r = ENOENT;
1046                         break;
1047                 }
1048                 if (ftype != EXT4_DE_UNKNOWN) {
1049                         bool df = imode != ext4_fs_correspond_inode_mode(ftype);
1050                         if (df && is_goal) {
1051                                 r = ENOENT;
1052                                 break;
1053                         }
1054                 }
1055
1056                 r = ext4_fs_put_inode_ref(&ref);
1057                 if (r != EOK)
1058                         break;
1059
1060                 r = ext4_fs_get_inode_ref(fs, next_inode, &ref);
1061                 if (r != EOK)
1062                         break;
1063
1064                 if (is_goal)
1065                         break;
1066
1067                 path += len + 1;
1068
1069                 if (name_off)
1070                         *name_off += len + 1;
1071         };
1072
1073         if (r != EOK) {
1074                 ext4_fs_put_inode_ref(&ref);
1075                 return r;
1076         }
1077
1078         if (is_goal) {
1079
1080                 if ((f->flags & O_TRUNC) && (imode == EXT4_INODE_MODE_FILE)) {
1081                         r = ext4_trunc_inode(mp, ref.index, 0);
1082                         if (r != EOK) {
1083                                 ext4_fs_put_inode_ref(&ref);
1084                                 return r;
1085                         }
1086                 }
1087
1088                 f->mp = mp;
1089                 f->fsize = ext4_inode_get_size(sb, ref.inode);
1090                 f->inode = ref.index;
1091                 f->fpos = 0;
1092
1093                 if (f->flags & O_APPEND)
1094                         f->fpos = f->fsize;
1095
1096         }
1097
1098         r = ext4_fs_put_inode_ref(&ref);
1099         if (flags & O_CREAT) {
1100                 if (r == EOK)
1101                         ext4_trans_stop(mp);
1102                 else
1103                         ext4_trans_abort(mp);
1104
1105         }
1106
1107         return r;
1108 }
1109
1110 /****************************************************************************/
1111
1112 static int ext4_generic_open(ext4_file *f, const char *path, const char *flags,
1113                              bool file_expect, uint32_t *parent_inode,
1114                              uint32_t *name_off)
1115 {
1116         uint32_t iflags;
1117         int filetype;
1118         if (ext4_parse_flags(flags, &iflags) == false)
1119                 return EINVAL;
1120
1121         if (file_expect == true)
1122                 filetype = EXT4_DE_REG_FILE;
1123         else
1124                 filetype = EXT4_DE_DIR;
1125
1126         return ext4_generic_open2(f, path, iflags, filetype, parent_inode,
1127                                   name_off);
1128 }
1129
1130 static int ext4_create_hardlink(const char *path,
1131                 struct ext4_inode_ref *child_ref, bool rename)
1132 {
1133         bool is_goal = false;
1134         uint32_t inode_mode = EXT4_INODE_MODE_DIRECTORY;
1135         uint32_t next_inode;
1136
1137         int r;
1138         int len;
1139         struct ext4_mountpoint *mp = ext4_get_mount(path);
1140         struct ext4_dir_search_result result;
1141         struct ext4_inode_ref ref;
1142
1143         if (!mp)
1144                 return ENOENT;
1145
1146         struct ext4_fs *const fs = &mp->fs;
1147         struct ext4_sblock *const sb = &mp->fs.sb;
1148
1149         /*Skip mount point*/
1150         path += strlen(mp->name);
1151
1152         /*Load root*/
1153         r = ext4_fs_get_inode_ref(fs, EXT4_INODE_ROOT_INDEX, &ref);
1154         if (r != EOK)
1155                 return r;
1156
1157         len = ext4_path_check(path, &is_goal);
1158         while (1) {
1159
1160                 len = ext4_path_check(path, &is_goal);
1161                 if (!len) {
1162                         /*If root open was request.*/
1163                         r = is_goal ? EINVAL : ENOENT;
1164                         break;
1165                 }
1166
1167                 r = ext4_dir_find_entry(&result, &ref, path, len);
1168                 if (r != EOK) {
1169
1170                         /*Destroy last result*/
1171                         ext4_dir_destroy_result(&ref, &result);
1172
1173                         if (r != ENOENT || !is_goal)
1174                                 break;
1175
1176                         /*Link with root dir.*/
1177                         r = ext4_link(mp, &ref, child_ref, path, len, rename);
1178                         break;
1179                 } else if (r == EOK && is_goal) {
1180                         /*Destroy last result*/
1181                         ext4_dir_destroy_result(&ref, &result);
1182                         r = EEXIST;
1183                         break;
1184                 }
1185
1186                 next_inode = result.dentry->inode;
1187                 if (ext4_sb_feature_incom(sb, EXT4_FINCOM_FILETYPE)) {
1188                         uint8_t t;
1189                         t = ext4_dir_en_get_inode_type(sb, result.dentry);
1190                         inode_mode = ext4_fs_correspond_inode_mode(t);
1191                 } else {
1192                         struct ext4_inode_ref child_ref;
1193                         r = ext4_fs_get_inode_ref(fs, next_inode, &child_ref);
1194                         if (r != EOK)
1195                                 break;
1196
1197                         inode_mode = ext4_inode_type(sb, child_ref.inode);
1198                         ext4_fs_put_inode_ref(&child_ref);
1199                 }
1200
1201                 r = ext4_dir_destroy_result(&ref, &result);
1202                 if (r != EOK)
1203                         break;
1204
1205                 if (inode_mode != EXT4_INODE_MODE_DIRECTORY) {
1206                         r = is_goal ? EEXIST : ENOENT;
1207                         break;
1208                 }
1209
1210                 r = ext4_fs_put_inode_ref(&ref);
1211                 if (r != EOK)
1212                         break;
1213
1214                 r = ext4_fs_get_inode_ref(fs, next_inode, &ref);
1215                 if (r != EOK)
1216                         break;
1217
1218                 if (is_goal)
1219                         break;
1220
1221                 path += len + 1;
1222         };
1223
1224         if (r != EOK) {
1225                 ext4_fs_put_inode_ref(&ref);
1226                 return r;
1227         }
1228
1229         r = ext4_fs_put_inode_ref(&ref);
1230         return r;
1231 }
1232
1233 static int ext4_remove_orig_reference(const char *path, uint32_t name_off,
1234                                       struct ext4_inode_ref *parent_ref,
1235                                       struct ext4_inode_ref *child_ref)
1236 {
1237         bool is_goal;
1238         int r;
1239         int len;
1240         struct ext4_mountpoint *mp = ext4_get_mount(path);
1241
1242         if (!mp)
1243                 return ENOENT;
1244
1245         /*Set path*/
1246         path += name_off;
1247
1248         len = ext4_path_check(path, &is_goal);
1249
1250         /* Remove entry from parent directory */
1251         r = ext4_dir_remove_entry(parent_ref, path, len);
1252         if (r != EOK)
1253                 goto Finish;
1254
1255         if (ext4_inode_is_type(&mp->fs.sb, child_ref->inode,
1256                                EXT4_INODE_MODE_DIRECTORY)) {
1257                 ext4_fs_inode_links_count_dec(parent_ref);
1258                 parent_ref->dirty = true;
1259         }
1260 Finish:
1261         return r;
1262 }
1263
1264 int ext4_flink(const char *path, const char *hardlink_path)
1265 {
1266         int r;
1267         ext4_file f;
1268         uint32_t name_off;
1269         bool child_loaded = false;
1270         uint32_t parent_inode, child_inode;
1271         struct ext4_mountpoint *mp = ext4_get_mount(path);
1272         struct ext4_mountpoint *target_mp = ext4_get_mount(hardlink_path);
1273         struct ext4_inode_ref child_ref;
1274
1275         if (!mp)
1276                 return ENOENT;
1277
1278         if (mp->fs.read_only)
1279                 return EROFS;
1280
1281         /* Will that happen? Anyway return EINVAL for such case. */
1282         if (mp != target_mp)
1283                 return EINVAL;
1284
1285         EXT4_MP_LOCK(mp);
1286         ext4_trans_start(mp);
1287
1288         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN,
1289                                &parent_inode, &name_off);
1290         if (r != EOK)
1291                 goto Finish;
1292
1293         child_inode = f.inode;
1294         ext4_fclose(&f);
1295
1296         /*We have file to unlink. Load it.*/
1297         r = ext4_fs_get_inode_ref(&mp->fs, child_inode, &child_ref);
1298         if (r != EOK)
1299                 goto Finish;
1300
1301         child_loaded = true;
1302
1303         /* Creating hardlink for directory is not allowed. */
1304         if (ext4_inode_is_type(&mp->fs.sb, child_ref.inode,
1305                                EXT4_INODE_MODE_DIRECTORY)) {
1306                 r = EINVAL;
1307                 goto Finish;
1308         }
1309
1310         r = ext4_create_hardlink(hardlink_path, &child_ref, false);
1311
1312 Finish:
1313         if (child_loaded)
1314                 ext4_fs_put_inode_ref(&child_ref);
1315
1316         if (r != EOK)
1317                 ext4_trans_abort(mp);
1318         else
1319                 ext4_trans_stop(mp);
1320
1321         EXT4_MP_UNLOCK(mp);
1322         return r;
1323
1324 }
1325
1326 int ext4_frename(const char *path, const char *new_path)
1327 {
1328         int r;
1329         ext4_file f;
1330         uint32_t name_off;
1331         bool parent_loaded = false, child_loaded = false;
1332         uint32_t parent_inode, child_inode;
1333         struct ext4_mountpoint *mp = ext4_get_mount(path);
1334         struct ext4_inode_ref child_ref, parent_ref;
1335
1336         if (!mp)
1337                 return ENOENT;
1338
1339         if (mp->fs.read_only)
1340                 return EROFS;
1341
1342         EXT4_MP_LOCK(mp);
1343         ext4_trans_start(mp);
1344
1345         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN,
1346                                 &parent_inode, &name_off);
1347         if (r != EOK)
1348                 goto Finish;
1349
1350         child_inode = f.inode;
1351         ext4_fclose(&f);
1352
1353         /*Load parent*/
1354         r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent_ref);
1355         if (r != EOK)
1356                 goto Finish;
1357
1358         parent_loaded = true;
1359
1360         /*We have file to unlink. Load it.*/
1361         r = ext4_fs_get_inode_ref(&mp->fs, child_inode, &child_ref);
1362         if (r != EOK)
1363                 goto Finish;
1364
1365         child_loaded = true;
1366
1367         r = ext4_create_hardlink(new_path, &child_ref, true);
1368         if (r != EOK)
1369                 goto Finish;
1370
1371         r = ext4_remove_orig_reference(path, name_off, &parent_ref, &child_ref);
1372         if (r != EOK)
1373                 goto Finish;
1374
1375 Finish:
1376         if (parent_loaded)
1377                 ext4_fs_put_inode_ref(&parent_ref);
1378
1379         if (child_loaded)
1380                 ext4_fs_put_inode_ref(&child_ref);
1381
1382         if (r != EOK)
1383                 ext4_trans_abort(mp);
1384         else
1385                 ext4_trans_stop(mp);
1386
1387         EXT4_MP_UNLOCK(mp);
1388         return r;
1389
1390 }
1391
1392 /****************************************************************************/
1393
1394 int ext4_get_sblock(const char *mount_point, struct ext4_sblock **sb)
1395 {
1396         struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
1397
1398         if (!mp)
1399                 return ENOENT;
1400
1401         *sb = &mp->fs.sb;
1402         return EOK;
1403 }
1404
1405 int ext4_cache_write_back(const char *path, bool on)
1406 {
1407         struct ext4_mountpoint *mp = ext4_get_mount(path);
1408         int ret;
1409
1410         if (!mp)
1411                 return ENOENT;
1412
1413         EXT4_MP_LOCK(mp);
1414         ret = ext4_block_cache_write_back(mp->fs.bdev, on);
1415         EXT4_MP_UNLOCK(mp);
1416         return ret;
1417 }
1418
1419 int ext4_cache_flush(const char *path)
1420 {
1421         struct ext4_mountpoint *mp = ext4_get_mount(path);
1422         int ret;
1423
1424         if (!mp)
1425                 return ENOENT;
1426
1427         EXT4_MP_LOCK(mp);
1428         ret = ext4_block_cache_flush(mp->fs.bdev);
1429         EXT4_MP_UNLOCK(mp);
1430         return ret;
1431 }
1432
1433 int ext4_fremove(const char *path)
1434 {
1435         ext4_file f;
1436         uint32_t parent_inode;
1437         uint32_t name_off;
1438         bool is_goal;
1439         int r;
1440         int len;
1441         struct ext4_inode_ref child;
1442         struct ext4_inode_ref parent;
1443         struct ext4_mountpoint *mp = ext4_get_mount(path);
1444
1445         if (!mp)
1446                 return ENOENT;
1447
1448         if (mp->fs.read_only)
1449                 return EROFS;
1450
1451         EXT4_MP_LOCK(mp);
1452         ext4_trans_start(mp);
1453
1454         r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN,
1455                                &parent_inode, &name_off);
1456         if (r != EOK) {
1457                 ext4_trans_abort(mp);
1458                 EXT4_MP_UNLOCK(mp);
1459                 return r;
1460         }
1461
1462         /*Load parent*/
1463         r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);
1464         if (r != EOK) {
1465                 ext4_trans_abort(mp);
1466                 EXT4_MP_UNLOCK(mp);
1467                 return r;
1468         }
1469
1470         /*We have file to delete. Load it.*/
1471         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &child);
1472         if (r != EOK) {
1473                 ext4_fs_put_inode_ref(&parent);
1474                 ext4_trans_abort(mp);
1475                 EXT4_MP_UNLOCK(mp);
1476                 return r;
1477         }
1478         /* We do not allow opening files here. */
1479         if (ext4_inode_type(&mp->fs.sb, child.inode) ==
1480             EXT4_INODE_MODE_DIRECTORY) {
1481                 ext4_fs_put_inode_ref(&parent);
1482                 ext4_fs_put_inode_ref(&child);
1483                 ext4_trans_abort(mp);
1484                 EXT4_MP_UNLOCK(mp);
1485                 return r;
1486         }
1487
1488         /*Link count will be zero, the inode should be freed. */
1489         if (ext4_inode_get_links_cnt(child.inode) == 1) {
1490                 ext4_block_cache_write_back(mp->fs.bdev, 1);
1491                 r = ext4_trunc_inode(mp, child.index, 0);
1492                 if (r != EOK) {
1493                         ext4_fs_put_inode_ref(&parent);
1494                         ext4_fs_put_inode_ref(&child);
1495                         ext4_trans_abort(mp);
1496                         EXT4_MP_UNLOCK(mp);
1497                         return r;
1498                 }
1499                 ext4_block_cache_write_back(mp->fs.bdev, 0);
1500         }
1501
1502         /*Set path*/
1503         path += name_off;
1504
1505         len = ext4_path_check(path, &is_goal);
1506
1507         /*Unlink from parent*/
1508         r = ext4_unlink(mp, &parent, &child, path, len);
1509         if (r != EOK)
1510                 goto Finish;
1511
1512         /*Link count is zero, the inode should be freed. */
1513         if (!ext4_inode_get_links_cnt(child.inode)) {
1514                 ext4_inode_set_del_time(child.inode, -1L);
1515
1516                 r = ext4_fs_free_inode(&child);
1517                 if (r != EOK)
1518                         goto Finish;
1519         }
1520
1521 Finish:
1522         ext4_fs_put_inode_ref(&child);
1523         ext4_fs_put_inode_ref(&parent);
1524
1525         if (r != EOK)
1526                 ext4_trans_abort(mp);
1527         else
1528                 ext4_trans_stop(mp);
1529
1530         EXT4_MP_UNLOCK(mp);
1531         return r;
1532 }
1533
1534 int ext4_fill_raw_inode(const char *path, uint32_t *ret_ino,
1535                         struct ext4_inode *inode)
1536 {
1537         int r;
1538         ext4_file f;
1539         struct ext4_inode_ref inode_ref;
1540         struct ext4_mountpoint *mp = ext4_get_mount(path);
1541         uint32_t ino;
1542
1543         if (!mp)
1544                 return ENOENT;
1545
1546         EXT4_MP_LOCK(mp);
1547
1548         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN, NULL, NULL);
1549         if (r != EOK) {
1550                 EXT4_MP_UNLOCK(mp);
1551                 return r;
1552         }
1553
1554         ino = f.inode;
1555         ext4_fclose(&f);
1556
1557         /*Load parent*/
1558         r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
1559         if (r != EOK) {
1560                 EXT4_MP_UNLOCK(mp);
1561                 return r;
1562         }
1563
1564         memcpy(inode, inode_ref.inode, sizeof(struct ext4_inode));
1565         ext4_fs_put_inode_ref(&inode_ref);
1566         EXT4_MP_UNLOCK(mp);
1567
1568         if (ret_ino)
1569                 *ret_ino = ino;
1570
1571         return r;
1572 }
1573
1574 int ext4_fopen(ext4_file *f, const char *path, const char *flags)
1575 {
1576         struct ext4_mountpoint *mp = ext4_get_mount(path);
1577         int r;
1578
1579         if (!mp)
1580                 return ENOENT;
1581
1582         EXT4_MP_LOCK(mp);
1583
1584         ext4_block_cache_write_back(mp->fs.bdev, 1);
1585         r = ext4_generic_open(f, path, flags, true, 0, 0);
1586         ext4_block_cache_write_back(mp->fs.bdev, 0);
1587
1588         EXT4_MP_UNLOCK(mp);
1589         return r;
1590 }
1591
1592 int ext4_fopen2(ext4_file *f, const char *path, int flags)
1593 {
1594         struct ext4_mountpoint *mp = ext4_get_mount(path);
1595         int r;
1596         int filetype;
1597
1598         if (!mp)
1599                 return ENOENT;
1600
1601         filetype = EXT4_DE_REG_FILE;
1602
1603         EXT4_MP_LOCK(mp);
1604
1605         ext4_block_cache_write_back(mp->fs.bdev, 1);
1606         r = ext4_generic_open2(f, path, flags, filetype, NULL, NULL);
1607         ext4_block_cache_write_back(mp->fs.bdev, 0);
1608
1609         EXT4_MP_UNLOCK(mp);
1610         return r;
1611 }
1612
1613 int ext4_fclose(ext4_file *f)
1614 {
1615         ext4_assert(f && f->mp);
1616
1617         f->mp = 0;
1618         f->flags = 0;
1619         f->inode = 0;
1620         f->fpos = f->fsize = 0;
1621
1622         return EOK;
1623 }
1624
1625 static int ext4_ftruncate_no_lock(ext4_file *f, uint64_t size)
1626 {
1627         struct ext4_inode_ref ref;
1628         int r;
1629
1630
1631         r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
1632         if (r != EOK) {
1633                 EXT4_MP_UNLOCK(f->mp);
1634                 return r;
1635         }
1636
1637         /*Sync file size*/
1638         f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);
1639         if (f->fsize <= size) {
1640                 r = EOK;
1641                 goto Finish;
1642         }
1643
1644         /*Start write back cache mode.*/
1645         r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);
1646         if (r != EOK)
1647                 goto Finish;
1648
1649         r = ext4_trunc_inode(f->mp, ref.index, size);
1650         if (r != EOK)
1651                 goto Finish;
1652
1653         f->fsize = size;
1654         if (f->fpos > size)
1655                 f->fpos = size;
1656
1657         /*Stop write back cache mode*/
1658         ext4_block_cache_write_back(f->mp->fs.bdev, 0);
1659
1660         if (r != EOK)
1661                 goto Finish;
1662
1663 Finish:
1664         ext4_fs_put_inode_ref(&ref);
1665         return r;
1666
1667 }
1668
1669 int ext4_ftruncate(ext4_file *f, uint64_t size)
1670 {
1671         int r;
1672         ext4_assert(f && f->mp);
1673
1674         if (f->mp->fs.read_only)
1675                 return EROFS;
1676
1677         if (f->flags & O_RDONLY)
1678                 return EPERM;
1679
1680         EXT4_MP_LOCK(f->mp);
1681
1682         ext4_trans_start(f->mp);
1683         r = ext4_ftruncate_no_lock(f, size);
1684         if (r != EOK)
1685                 ext4_trans_abort(f->mp);
1686         else
1687                 ext4_trans_stop(f->mp);
1688
1689         EXT4_MP_UNLOCK(f->mp);
1690         return r;
1691 }
1692
1693 int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
1694 {
1695         uint32_t unalg;
1696         uint32_t iblock_idx;
1697         uint32_t iblock_last;
1698         uint32_t block_size;
1699
1700         ext4_fsblk_t fblock;
1701         ext4_fsblk_t fblock_start;
1702         uint32_t fblock_count;
1703
1704         uint8_t *u8_buf = buf;
1705         int r;
1706         struct ext4_inode_ref ref;
1707
1708         ext4_assert(f && f->mp);
1709
1710         if (f->flags & O_WRONLY)
1711                 return EPERM;
1712
1713         if (!size)
1714                 return EOK;
1715
1716         EXT4_MP_LOCK(f->mp);
1717
1718         struct ext4_fs *const fs = &f->mp->fs;
1719         struct ext4_sblock *const sb = &f->mp->fs.sb;
1720
1721         if (rcnt)
1722                 *rcnt = 0;
1723
1724         r = ext4_fs_get_inode_ref(fs, f->inode, &ref);
1725         if (r != EOK) {
1726                 EXT4_MP_UNLOCK(f->mp);
1727                 return r;
1728         }
1729
1730         /*Sync file size*/
1731         f->fsize = ext4_inode_get_size(sb, ref.inode);
1732
1733         block_size = ext4_sb_get_block_size(sb);
1734         size = ((uint64_t)size > (f->fsize - f->fpos))
1735                 ? ((size_t)(f->fsize - f->fpos)) : size;
1736
1737         iblock_idx = (uint32_t)((f->fpos) / block_size);
1738         iblock_last = (uint32_t)((f->fpos + size) / block_size);
1739         unalg = (f->fpos) % block_size;
1740
1741         /*If the size of symlink is smaller than 60 bytes*/
1742         bool softlink;
1743         softlink = ext4_inode_is_type(sb, ref.inode, EXT4_INODE_MODE_SOFTLINK);
1744         if (softlink && f->fsize < sizeof(ref.inode->blocks)
1745                      && !ext4_inode_get_blocks_count(sb, ref.inode)) {
1746
1747                 char *content = (char *)ref.inode->blocks;
1748                 if (f->fpos < f->fsize) {
1749                         size_t len = size;
1750                         if (unalg + size > (uint32_t)f->fsize)
1751                                 len = (uint32_t)f->fsize - unalg;
1752                         memcpy(buf, content + unalg, len);
1753                         if (rcnt)
1754                                 *rcnt = len;
1755
1756                 }
1757
1758                 r = EOK;
1759                 goto Finish;
1760         }
1761
1762         if (unalg) {
1763                 size_t len =  size;
1764                 if (size > (block_size - unalg))
1765                         len = block_size - unalg;
1766
1767                 r = ext4_fs_get_inode_dblk_idx(&ref, iblock_idx, &fblock, true);
1768                 if (r != EOK)
1769                         goto Finish;
1770
1771                 /* Do we get an unwritten range? */
1772                 if (fblock != 0) {
1773                         uint64_t off = fblock * block_size + unalg;
1774                         r = ext4_block_readbytes(f->mp->fs.bdev, off, u8_buf, len);
1775                         if (r != EOK)
1776                                 goto Finish;
1777
1778                 } else {
1779                         /* Yes, we do. */
1780                         memset(u8_buf, 0, len);
1781                 }
1782
1783                 u8_buf += len;
1784                 size -= len;
1785                 f->fpos += len;
1786
1787                 if (rcnt)
1788                         *rcnt += len;
1789
1790                 iblock_idx++;
1791         }
1792
1793         fblock_start = 0;
1794         fblock_count = 0;
1795         while (size >= block_size) {
1796                 while (iblock_idx < iblock_last) {
1797                         r = ext4_fs_get_inode_dblk_idx(&ref, iblock_idx,
1798                                                        &fblock, true);
1799                         if (r != EOK)
1800                                 goto Finish;
1801
1802                         iblock_idx++;
1803
1804                         if (!fblock_start)
1805                                 fblock_start = fblock;
1806
1807                         if ((fblock_start + fblock_count) != fblock)
1808                                 break;
1809
1810                         fblock_count++;
1811                 }
1812
1813                 r = ext4_blocks_get_direct(f->mp->fs.bdev, u8_buf, fblock_start,
1814                                            fblock_count);
1815                 if (r != EOK)
1816                         goto Finish;
1817
1818                 size -= block_size * fblock_count;
1819                 u8_buf += block_size * fblock_count;
1820                 f->fpos += block_size * fblock_count;
1821
1822                 if (rcnt)
1823                         *rcnt += block_size * fblock_count;
1824
1825                 fblock_start = fblock;
1826                 fblock_count = 1;
1827         }
1828
1829         if (size) {
1830                 uint64_t off;
1831                 r = ext4_fs_get_inode_dblk_idx(&ref, iblock_idx, &fblock, true);
1832                 if (r != EOK)
1833                         goto Finish;
1834
1835                 off = fblock * block_size;
1836                 r = ext4_block_readbytes(f->mp->fs.bdev, off, u8_buf, size);
1837                 if (r != EOK)
1838                         goto Finish;
1839
1840                 f->fpos += size;
1841
1842                 if (rcnt)
1843                         *rcnt += size;
1844         }
1845
1846 Finish:
1847         ext4_fs_put_inode_ref(&ref);
1848         EXT4_MP_UNLOCK(f->mp);
1849         return r;
1850 }
1851
1852 int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
1853 {
1854         uint32_t unalg;
1855         uint32_t iblk_idx;
1856         uint32_t iblock_last;
1857         uint32_t ifile_blocks;
1858         uint32_t block_size;
1859
1860         uint32_t fblock_count;
1861         ext4_fsblk_t fblk;
1862         ext4_fsblk_t fblock_start;
1863
1864         struct ext4_inode_ref ref;
1865         const uint8_t *u8_buf = buf;
1866         int r, rr = EOK;
1867
1868         ext4_assert(f && f->mp);
1869
1870         if (f->mp->fs.read_only)
1871                 return EROFS;
1872
1873         if (f->flags & O_RDONLY)
1874                 return EPERM;
1875
1876         if (!size)
1877                 return EOK;
1878
1879         EXT4_MP_LOCK(f->mp);
1880         ext4_trans_start(f->mp);
1881
1882         struct ext4_fs *const fs = &f->mp->fs;
1883         struct ext4_sblock *const sb = &f->mp->fs.sb;
1884
1885         if (wcnt)
1886                 *wcnt = 0;
1887
1888         r = ext4_fs_get_inode_ref(fs, f->inode, &ref);
1889         if (r != EOK) {
1890                 ext4_trans_abort(f->mp);
1891                 EXT4_MP_UNLOCK(f->mp);
1892                 return r;
1893         }
1894
1895         /*Sync file size*/
1896         f->fsize = ext4_inode_get_size(sb, ref.inode);
1897         block_size = ext4_sb_get_block_size(sb);
1898
1899         iblock_last = (uint32_t)((f->fpos + size) / block_size);
1900         iblk_idx = (uint32_t)(f->fpos / block_size);
1901         ifile_blocks = (uint32_t)((f->fsize + block_size - 1) / block_size);
1902
1903         unalg = (f->fpos) % block_size;
1904
1905         if (unalg) {
1906                 size_t len =  size;
1907                 uint64_t off;
1908                 if (size > (block_size - unalg))
1909                         len = block_size - unalg;
1910
1911                 r = ext4_fs_init_inode_dblk_idx(&ref, iblk_idx, &fblk);
1912                 if (r != EOK)
1913                         goto Finish;
1914
1915                 off = fblk * block_size + unalg;
1916                 r = ext4_block_writebytes(f->mp->fs.bdev, off, u8_buf, len);
1917                 if (r != EOK)
1918                         goto Finish;
1919
1920                 u8_buf += len;
1921                 size -= len;
1922                 f->fpos += len;
1923
1924                 if (wcnt)
1925                         *wcnt += len;
1926
1927                 iblk_idx++;
1928         }
1929
1930         /*Start write back cache mode.*/
1931         r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);
1932         if (r != EOK)
1933                 goto Finish;
1934
1935         fblock_start = 0;
1936         fblock_count = 0;
1937         while (size >= block_size) {
1938
1939                 while (iblk_idx < iblock_last) {
1940                         if (iblk_idx < ifile_blocks) {
1941                                 r = ext4_fs_init_inode_dblk_idx(&ref, iblk_idx,
1942                                                                 &fblk);
1943                                 if (r != EOK)
1944                                         goto Finish;
1945                         } else {
1946                                 rr = ext4_fs_append_inode_dblk(&ref, &fblk,
1947                                                                &iblk_idx);
1948                                 if (rr != EOK) {
1949                                         /* Unable to append more blocks. But
1950                                          * some block might be allocated already
1951                                          * */
1952                                         break;
1953                                 }
1954                         }
1955
1956                         iblk_idx++;
1957
1958                         if (!fblock_start) {
1959                                 fblock_start = fblk;
1960                         }
1961
1962                         if ((fblock_start + fblock_count) != fblk)
1963                                 break;
1964
1965                         fblock_count++;
1966                 }
1967
1968                 r = ext4_blocks_set_direct(f->mp->fs.bdev, u8_buf, fblock_start,
1969                                            fblock_count);
1970                 if (r != EOK)
1971                         break;
1972
1973                 size -= block_size * fblock_count;
1974                 u8_buf += block_size * fblock_count;
1975                 f->fpos += block_size * fblock_count;
1976
1977                 if (wcnt)
1978                         *wcnt += block_size * fblock_count;
1979
1980                 fblock_start = fblk;
1981                 fblock_count = 1;
1982
1983                 if (rr != EOK) {
1984                         /*ext4_fs_append_inode_block has failed and no
1985                          * more blocks might be written. But node size
1986                          * should be updated.*/
1987                         r = rr;
1988                         goto out_fsize;
1989                 }
1990         }
1991
1992         /*Stop write back cache mode*/
1993         ext4_block_cache_write_back(f->mp->fs.bdev, 0);
1994
1995         if (r != EOK)
1996                 goto Finish;
1997
1998         if (size) {
1999                 uint64_t off;
2000                 if (iblk_idx < ifile_blocks) {
2001                         r = ext4_fs_init_inode_dblk_idx(&ref, iblk_idx, &fblk);
2002                         if (r != EOK)
2003                                 goto Finish;
2004                 } else {
2005                         r = ext4_fs_append_inode_dblk(&ref, &fblk, &iblk_idx);
2006                         if (r != EOK)
2007                                 /*Node size sholud be updated.*/
2008                                 goto out_fsize;
2009                 }
2010
2011                 off = fblk * block_size;
2012                 r = ext4_block_writebytes(f->mp->fs.bdev, off, u8_buf, size);
2013                 if (r != EOK)
2014                         goto Finish;
2015
2016                 f->fpos += size;
2017
2018                 if (wcnt)
2019                         *wcnt += size;
2020         }
2021
2022 out_fsize:
2023         if (f->fpos > f->fsize) {
2024                 f->fsize = f->fpos;
2025                 ext4_inode_set_size(ref.inode, f->fsize);
2026                 ref.dirty = true;
2027         }
2028
2029 Finish:
2030         r = ext4_fs_put_inode_ref(&ref);
2031
2032         if (r != EOK)
2033                 ext4_trans_abort(f->mp);
2034         else
2035                 ext4_trans_stop(f->mp);
2036
2037         EXT4_MP_UNLOCK(f->mp);
2038         return r;
2039 }
2040
2041 int ext4_fseek(ext4_file *f, uint64_t offset, uint32_t origin)
2042 {
2043         switch (origin) {
2044         case SEEK_SET:
2045                 if (offset > f->fsize)
2046                         return EINVAL;
2047
2048                 f->fpos = offset;
2049                 return EOK;
2050         case SEEK_CUR:
2051                 if ((offset + f->fpos) > f->fsize)
2052                         return EINVAL;
2053
2054                 f->fpos += offset;
2055                 return EOK;
2056         case SEEK_END:
2057                 if (offset > f->fsize)
2058                         return EINVAL;
2059
2060                 f->fpos = f->fsize - offset;
2061                 return EOK;
2062         }
2063         return EINVAL;
2064 }
2065
2066 uint64_t ext4_ftell(ext4_file *f)
2067 {
2068         return f->fpos;
2069 }
2070
2071 uint64_t ext4_fsize(ext4_file *f)
2072 {
2073         return f->fsize;
2074 }
2075
2076
2077 static int ext4_trans_get_inode_ref(const char *path,
2078                                     struct ext4_mountpoint *mp,
2079                                     struct ext4_inode_ref *inode_ref)
2080 {
2081         int r;
2082         ext4_file f;
2083
2084         ext4_trans_start(mp);
2085         r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
2086         if (r != EOK) {
2087                 ext4_trans_abort(mp);
2088                 return r;
2089         }
2090
2091         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, inode_ref);
2092         if (r != EOK) {
2093                 ext4_trans_abort(mp);
2094                 return r;
2095         }
2096
2097         return r;
2098 }
2099
2100 static int ext4_trans_put_inode_ref(struct ext4_mountpoint *mp,
2101                                     struct ext4_inode_ref *inode_ref)
2102 {
2103         int r;
2104
2105         r = ext4_fs_put_inode_ref(inode_ref);
2106         if (r != EOK)
2107                 ext4_trans_abort(mp);
2108         else
2109                 ext4_trans_stop(mp);
2110
2111         return r;
2112 }
2113
2114 int ext4_mode_set(const char *path, uint32_t mode)
2115 {
2116         int r;
2117         uint32_t orig_mode;
2118         struct ext4_inode_ref inode_ref;
2119         struct ext4_mountpoint *mp = ext4_get_mount(path);
2120
2121         if (!mp)
2122                 return ENOENT;
2123
2124         if (mp->fs.read_only)
2125                 return EROFS;
2126
2127         EXT4_MP_LOCK(mp);
2128
2129         r = ext4_trans_get_inode_ref(path, mp, &inode_ref);
2130         if (r != EOK)
2131                 goto Finish;
2132
2133         orig_mode = ext4_inode_get_mode(&mp->fs.sb, inode_ref.inode);
2134         orig_mode &= ~0xFFF;
2135         orig_mode |= mode & 0xFFF;
2136         ext4_inode_set_mode(&mp->fs.sb, inode_ref.inode, orig_mode);
2137
2138         inode_ref.dirty = true;
2139         r = ext4_trans_put_inode_ref(mp, &inode_ref);
2140
2141         Finish:
2142         EXT4_MP_UNLOCK(mp);
2143
2144         return r;
2145 }
2146
2147 int ext4_owner_set(const char *path, uint32_t uid, uint32_t gid)
2148 {
2149         int r;
2150         struct ext4_inode_ref inode_ref;
2151         struct ext4_mountpoint *mp = ext4_get_mount(path);
2152
2153         if (!mp)
2154                 return ENOENT;
2155
2156         if (mp->fs.read_only)
2157                 return EROFS;
2158
2159         EXT4_MP_LOCK(mp);
2160
2161         r = ext4_trans_get_inode_ref(path, mp, &inode_ref);
2162         if (r != EOK)
2163                 goto Finish;
2164
2165         ext4_inode_set_uid(inode_ref.inode, uid);
2166         ext4_inode_set_gid(inode_ref.inode, gid);
2167
2168         inode_ref.dirty = true;
2169         r = ext4_trans_put_inode_ref(mp, &inode_ref);
2170
2171         Finish:
2172         EXT4_MP_UNLOCK(mp);
2173
2174         return r;
2175 }
2176
2177 int ext4_mode_get(const char *path, uint32_t *mode)
2178 {
2179         struct ext4_inode_ref inode_ref;
2180         struct ext4_mountpoint *mp = ext4_get_mount(path);
2181         ext4_file f;
2182         int r;
2183
2184         if (!mp)
2185                 return ENOENT;
2186
2187         EXT4_MP_LOCK(mp);
2188
2189         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN, NULL, NULL);
2190         if (r != EOK)
2191                 goto Finish;
2192
2193         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &inode_ref);
2194         if (r != EOK)
2195                 goto Finish;
2196
2197         *mode = ext4_inode_get_mode(&mp->fs.sb, inode_ref.inode);
2198         r = ext4_fs_put_inode_ref(&inode_ref);
2199
2200         Finish:
2201         EXT4_MP_UNLOCK(mp);
2202
2203         return r;
2204 }
2205
2206 int ext4_owner_get(const char *path, uint32_t *uid, uint32_t *gid)
2207 {
2208         struct ext4_inode_ref inode_ref;
2209         struct ext4_mountpoint *mp = ext4_get_mount(path);
2210         ext4_file f;
2211         int r;
2212
2213         if (!mp)
2214                 return ENOENT;
2215
2216         EXT4_MP_LOCK(mp);
2217
2218         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN, NULL, NULL);
2219         if (r != EOK)
2220                 goto Finish;
2221
2222         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &inode_ref);
2223         if (r != EOK)
2224                 goto Finish;
2225
2226         *uid = ext4_inode_get_uid(inode_ref.inode);
2227         *gid = ext4_inode_get_gid(inode_ref.inode);
2228         r = ext4_fs_put_inode_ref(&inode_ref);
2229
2230         Finish:
2231         EXT4_MP_UNLOCK(mp);
2232
2233         return r;
2234 }
2235
2236 int ext4_atime_set(const char *path, uint32_t atime)
2237 {
2238         struct ext4_inode_ref inode_ref;
2239         struct ext4_mountpoint *mp = ext4_get_mount(path);
2240         int r;
2241
2242         if (!mp)
2243                 return ENOENT;
2244
2245         if (mp->fs.read_only)
2246                 return EROFS;
2247
2248         EXT4_MP_LOCK(mp);
2249
2250         r = ext4_trans_get_inode_ref(path, mp, &inode_ref);
2251         if (r != EOK)
2252                 goto Finish;
2253
2254         ext4_inode_set_access_time(inode_ref.inode, atime);
2255         inode_ref.dirty = true;
2256         r = ext4_trans_put_inode_ref(mp, &inode_ref);
2257
2258         Finish:
2259         EXT4_MP_UNLOCK(mp);
2260
2261         return r;
2262 }
2263
2264 int ext4_mtime_set(const char *path, uint32_t mtime)
2265 {
2266         struct ext4_inode_ref inode_ref;
2267         struct ext4_mountpoint *mp = ext4_get_mount(path);
2268         int r;
2269
2270         if (!mp)
2271                 return ENOENT;
2272
2273         if (mp->fs.read_only)
2274                 return EROFS;
2275
2276         EXT4_MP_LOCK(mp);
2277
2278         r = ext4_trans_get_inode_ref(path, mp, &inode_ref);
2279         if (r != EOK)
2280                 goto Finish;
2281
2282         ext4_inode_set_modif_time(inode_ref.inode, mtime);
2283         inode_ref.dirty = true;
2284         r = ext4_trans_put_inode_ref(mp, &inode_ref);
2285
2286         Finish:
2287         EXT4_MP_UNLOCK(mp);
2288
2289         return r;
2290 }
2291
2292 int ext4_ctime_set(const char *path, uint32_t ctime)
2293 {
2294         struct ext4_inode_ref inode_ref;
2295         struct ext4_mountpoint *mp = ext4_get_mount(path);
2296         int r;
2297
2298         if (!mp)
2299                 return ENOENT;
2300
2301         if (mp->fs.read_only)
2302                 return EROFS;
2303
2304         EXT4_MP_LOCK(mp);
2305
2306         r = ext4_trans_get_inode_ref(path, mp, &inode_ref);
2307         if (r != EOK)
2308                 goto Finish;
2309
2310         ext4_inode_set_change_inode_time(inode_ref.inode, ctime);
2311         inode_ref.dirty = true;
2312         r = ext4_trans_put_inode_ref(mp, &inode_ref);
2313
2314         Finish:
2315         EXT4_MP_UNLOCK(mp);
2316
2317         return r;
2318 }
2319
2320 int ext4_atime_get(const char *path, uint32_t *atime)
2321 {
2322         struct ext4_inode_ref inode_ref;
2323         struct ext4_mountpoint *mp = ext4_get_mount(path);
2324         ext4_file f;
2325         int r;
2326
2327         if (!mp)
2328                 return ENOENT;
2329
2330         EXT4_MP_LOCK(mp);
2331
2332         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN, NULL, NULL);
2333         if (r != EOK)
2334                 goto Finish;
2335
2336         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &inode_ref);
2337         if (r != EOK)
2338                 goto Finish;
2339
2340         *atime = ext4_inode_get_access_time(inode_ref.inode);
2341         r = ext4_fs_put_inode_ref(&inode_ref);
2342
2343         Finish:
2344         EXT4_MP_UNLOCK(mp);
2345
2346         return r;
2347 }
2348
2349 int ext4_mtime_get(const char *path, uint32_t *mtime)
2350 {
2351         struct ext4_inode_ref inode_ref;
2352         struct ext4_mountpoint *mp = ext4_get_mount(path);
2353         ext4_file f;
2354         int r;
2355
2356         if (!mp)
2357                 return ENOENT;
2358
2359         EXT4_MP_LOCK(mp);
2360
2361         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN, NULL, NULL);
2362         if (r != EOK)
2363                 goto Finish;
2364
2365         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &inode_ref);
2366         if (r != EOK)
2367                 goto Finish;
2368
2369         *mtime = ext4_inode_get_modif_time(inode_ref.inode);
2370         r = ext4_fs_put_inode_ref(&inode_ref);
2371
2372         Finish:
2373         EXT4_MP_UNLOCK(mp);
2374
2375         return r;
2376 }
2377
2378 int ext4_ctime_get(const char *path, uint32_t *ctime)
2379 {
2380         struct ext4_inode_ref inode_ref;
2381         struct ext4_mountpoint *mp = ext4_get_mount(path);
2382         ext4_file f;
2383         int r;
2384
2385         if (!mp)
2386                 return ENOENT;
2387
2388         EXT4_MP_LOCK(mp);
2389
2390         r = ext4_generic_open2(&f, path, O_RDONLY, EXT4_DE_UNKNOWN, NULL, NULL);
2391         if (r != EOK)
2392                 goto Finish;
2393
2394         r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &inode_ref);
2395         if (r != EOK)
2396                 goto Finish;
2397
2398         *ctime = ext4_inode_get_change_inode_time(inode_ref.inode);
2399         r = ext4_fs_put_inode_ref(&inode_ref);
2400
2401         Finish:
2402         EXT4_MP_UNLOCK(mp);
2403
2404         return r;
2405 }
2406
2407 static int ext4_fsymlink_set(ext4_file *f, const void *buf, uint32_t size)
2408 {
2409         struct ext4_inode_ref ref;
2410         uint32_t sblock;
2411         ext4_fsblk_t fblock;
2412         uint32_t block_size;
2413         int r;
2414
2415         ext4_assert(f && f->mp);
2416
2417         if (!size)
2418                 return EOK;
2419
2420         r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
2421         if (r != EOK)
2422                 return r;
2423
2424         /*Sync file size*/
2425         block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
2426         if (size > block_size) {
2427                 r = EINVAL;
2428                 goto Finish;
2429         }
2430         r = ext4_ftruncate_no_lock(f, 0);
2431         if (r != EOK)
2432                 goto Finish;
2433
2434         /*Start write back cache mode.*/
2435         r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);
2436         if (r != EOK)
2437                 goto Finish;
2438
2439         /*If the size of symlink is smaller than 60 bytes*/
2440         if (size < sizeof(ref.inode->blocks)) {
2441                 memset(ref.inode->blocks, 0, sizeof(ref.inode->blocks));
2442                 memcpy(ref.inode->blocks, buf, size);
2443                 ext4_inode_clear_flag(ref.inode, EXT4_INODE_FLAG_EXTENTS);
2444         } else {
2445                 ext4_fs_inode_blocks_init(&f->mp->fs, &ref);
2446                 r = ext4_fs_append_inode_dblk(&ref, &fblock, &sblock);
2447                 if (r != EOK)
2448                         goto Finish;
2449
2450                 r = ext4_block_writebytes(f->mp->fs.bdev, 0, buf, size);
2451                 if (r != EOK)
2452                         goto Finish;
2453
2454         }
2455
2456         /*Stop write back cache mode*/
2457         ext4_block_cache_write_back(f->mp->fs.bdev, 0);
2458
2459         if (r != EOK)
2460                 goto Finish;
2461
2462         ext4_inode_set_size(ref.inode, size);
2463         ref.dirty = true;
2464
2465         f->fsize = size;
2466         if (f->fpos > size)
2467                 f->fpos = size;
2468
2469 Finish:
2470         ext4_fs_put_inode_ref(&ref);
2471         return r;
2472 }
2473
2474 int ext4_fsymlink(const char *target, const char *path)
2475 {
2476         struct ext4_mountpoint *mp = ext4_get_mount(path);
2477         int r;
2478         ext4_file f;
2479         int filetype;
2480
2481         if (!mp)
2482                 return ENOENT;
2483
2484         if (mp->fs.read_only)
2485                 return EROFS;
2486
2487         filetype = EXT4_DE_SYMLINK;
2488
2489         EXT4_MP_LOCK(mp);
2490         ext4_trans_start(mp);
2491
2492         ext4_block_cache_write_back(mp->fs.bdev, 1);
2493         r = ext4_generic_open2(&f, path, O_RDWR|O_CREAT, filetype, NULL, NULL);
2494         if (r == EOK)
2495                 r = ext4_fsymlink_set(&f, target, strlen(target));
2496         else
2497                 goto Finish;
2498
2499         ext4_fclose(&f);
2500
2501 Finish:
2502         ext4_block_cache_write_back(mp->fs.bdev, 0);
2503
2504         if (r != EOK)
2505                 ext4_trans_abort(mp);
2506         else
2507                 ext4_trans_stop(mp);
2508
2509         EXT4_MP_UNLOCK(mp);
2510         return r;
2511 }
2512
2513 int ext4_readlink(const char *path, char *buf, size_t bufsize, size_t *rcnt)
2514 {
2515         struct ext4_mountpoint *mp = ext4_get_mount(path);
2516         int r;
2517         ext4_file f;
2518         int filetype;
2519
2520         if (!mp)
2521                 return ENOENT;
2522
2523         if (!buf)
2524                 return EINVAL;
2525
2526         filetype = EXT4_DE_SYMLINK;
2527
2528         EXT4_MP_LOCK(mp);
2529         ext4_block_cache_write_back(mp->fs.bdev, 1);
2530         r = ext4_generic_open2(&f, path, O_RDONLY, filetype, NULL, NULL);
2531         if (r == EOK)
2532                 r = ext4_fread(&f, buf, bufsize, rcnt);
2533         else
2534                 goto Finish;
2535
2536         ext4_fclose(&f);
2537
2538 Finish:
2539         ext4_block_cache_write_back(mp->fs.bdev, 0);
2540         if (r != EOK)
2541                 ext4_trans_abort(mp);
2542         else
2543                 ext4_trans_stop(mp);
2544
2545         EXT4_MP_UNLOCK(mp);
2546         return r;
2547 }
2548
2549 static int ext4_mknod_set(ext4_file *f, uint32_t dev)
2550 {
2551         struct ext4_inode_ref ref;
2552         int r;
2553
2554         ext4_assert(f && f->mp);
2555
2556         r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
2557         if (r != EOK)
2558                 return r;
2559
2560         ext4_inode_set_dev(ref.inode, dev);
2561
2562         ext4_inode_set_size(ref.inode, 0);
2563         ref.dirty = true;
2564
2565         f->fsize = 0;
2566         f->fpos = 0;
2567
2568         r = ext4_fs_put_inode_ref(&ref);
2569         return r;
2570 }
2571
2572 int ext4_mknod(const char *path, int filetype, uint32_t dev)
2573 {
2574         struct ext4_mountpoint *mp = ext4_get_mount(path);
2575         int r;
2576         ext4_file f;
2577
2578         if (!mp)
2579                 return ENOENT;
2580
2581         if (mp->fs.read_only)
2582                 return EROFS;
2583
2584         /*
2585          * The filetype shouldn't be normal file, directory or
2586          * unknown.
2587          */
2588         if (filetype == EXT4_DE_UNKNOWN ||
2589             filetype == EXT4_DE_REG_FILE ||
2590             filetype == EXT4_DE_DIR ||
2591             filetype == EXT4_DE_SYMLINK)
2592                 return EINVAL;
2593
2594         /*
2595          * Nor should it be any bogus value.
2596          */
2597         if (filetype != EXT4_DE_CHRDEV &&
2598             filetype != EXT4_DE_BLKDEV &&
2599             filetype != EXT4_DE_FIFO &&
2600             filetype != EXT4_DE_SOCK)
2601                 return EINVAL;
2602
2603         EXT4_MP_LOCK(mp);
2604         ext4_trans_start(mp);
2605
2606         ext4_block_cache_write_back(mp->fs.bdev, 1);
2607         r = ext4_generic_open2(&f, path, O_RDWR|O_CREAT, filetype, NULL, NULL);
2608         if (r == EOK) {
2609                 if (filetype == EXT4_DE_CHRDEV ||
2610                     filetype == EXT4_DE_BLKDEV)
2611                         r = ext4_mknod_set(&f, dev);
2612         } else
2613                 goto Finish;
2614
2615         ext4_fclose(&f);
2616
2617 Finish:
2618         ext4_block_cache_write_back(mp->fs.bdev, 0);
2619
2620         if (r != EOK)
2621                 ext4_trans_abort(mp);
2622         else
2623                 ext4_trans_stop(mp);
2624
2625         EXT4_MP_UNLOCK(mp);
2626         return r;
2627 }
2628
2629 int ext4_setxattr(const char *path, const char *name, size_t name_len,
2630                   const void *data, size_t data_size, bool replace __unused)
2631 {
2632         bool found;
2633         int r = EOK;
2634         ext4_file f;
2635         uint32_t inode;
2636         uint8_t name_index;
2637         const char *dissected_name = NULL;
2638         size_t dissected_len = 0;
2639         struct ext4_inode_ref inode_ref;
2640         struct ext4_mountpoint *mp = ext4_get_mount(path);
2641         if (!mp)
2642                 return ENOENT;
2643
2644         if (mp->fs.read_only)
2645                 return EROFS;
2646
2647         dissected_name = ext4_extract_xattr_name(name, name_len,
2648                                 &name_index, &dissected_len,
2649                                 &found);
2650         if (!found)
2651                 return EINVAL;
2652
2653         EXT4_MP_LOCK(mp);
2654         ext4_trans_start(mp);
2655
2656         r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
2657         if (r != EOK)
2658                 goto Finish;
2659         inode = f.inode;
2660         ext4_fclose(&f);
2661
2662         r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
2663         if (r != EOK)
2664                 goto Finish;
2665
2666         r = ext4_xattr_set(&inode_ref, name_index, dissected_name,
2667                         dissected_len, data, data_size);
2668
2669         ext4_fs_put_inode_ref(&inode_ref);
2670 Finish:
2671         if (r != EOK)
2672                 ext4_trans_abort(mp);
2673         else
2674                 ext4_trans_stop(mp);
2675
2676         EXT4_MP_UNLOCK(mp);
2677         return r;
2678 }
2679
2680 int ext4_getxattr(const char *path, const char *name, size_t name_len,
2681                   void *buf, size_t buf_size, size_t *data_size)
2682 {
2683         bool found;
2684         int r = EOK;
2685         ext4_file f;
2686         uint32_t inode;
2687         uint8_t name_index;
2688         const char *dissected_name = NULL;
2689         size_t dissected_len = 0;
2690         struct ext4_inode_ref inode_ref;
2691         struct ext4_mountpoint *mp = ext4_get_mount(path);
2692         if (!mp)
2693                 return ENOENT;
2694
2695         dissected_name = ext4_extract_xattr_name(name, name_len,
2696                                 &name_index, &dissected_len,
2697                                 &found);
2698         if (!found)
2699                 return EINVAL;
2700
2701         EXT4_MP_LOCK(mp);
2702         r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
2703         if (r != EOK)
2704                 goto Finish;
2705         inode = f.inode;
2706         ext4_fclose(&f);
2707
2708         r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
2709         if (r != EOK)
2710                 goto Finish;
2711
2712         r = ext4_xattr_get(&inode_ref, name_index, dissected_name,
2713                                 dissected_len, buf, buf_size, data_size);
2714
2715         ext4_fs_put_inode_ref(&inode_ref);
2716 Finish:
2717         EXT4_MP_UNLOCK(mp);
2718         return r;
2719 }
2720
2721 int ext4_listxattr(const char *path, char *list, size_t size, size_t *ret_size)
2722 {
2723         int r = EOK;
2724         ext4_file f;
2725         uint32_t inode;
2726         size_t list_len, list_size = 0;
2727         struct ext4_inode_ref inode_ref;
2728         struct ext4_xattr_list_entry *xattr_list = NULL,
2729                                      *entry = NULL;
2730         struct ext4_mountpoint *mp = ext4_get_mount(path);
2731         if (!mp)
2732                 return ENOENT;
2733
2734         EXT4_MP_LOCK(mp);
2735         r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
2736         if (r != EOK)
2737                 goto Finish;
2738         inode = f.inode;
2739         ext4_fclose(&f);
2740
2741         r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
2742         if (r != EOK)
2743                 goto Finish;
2744
2745         r = ext4_xattr_list(&inode_ref, NULL, &list_len);
2746         if (r == EOK && list_len) {
2747                 xattr_list = ext4_malloc(list_len);
2748                 if (!xattr_list) {
2749                         ext4_fs_put_inode_ref(&inode_ref);
2750                         r = ENOMEM;
2751                         goto Finish;
2752                 }
2753                 entry = xattr_list;
2754                 r = ext4_xattr_list(&inode_ref, entry, &list_len);
2755                 if (r != EOK) {
2756                         ext4_fs_put_inode_ref(&inode_ref);
2757                         goto Finish;
2758                 }
2759
2760                 for (;entry;entry = entry->next) {
2761                         size_t prefix_len;
2762                         const char *prefix =
2763                                 ext4_get_xattr_name_prefix(entry->name_index,
2764                                                            &prefix_len);
2765                         if (size) {
2766                                 if (prefix_len + entry->name_len + 1 > size) {
2767                                         ext4_fs_put_inode_ref(&inode_ref);
2768                                         r = ERANGE;
2769                                         goto Finish;
2770                                 }
2771                         }
2772
2773                         if (list && size) {
2774                                 memcpy(list, prefix, prefix_len);
2775                                 list += prefix_len;
2776                                 memcpy(list, entry->name,
2777                                         entry->name_len);
2778                                 list[entry->name_len] = 0;
2779                                 list += entry->name_len + 1;
2780
2781                                 size -= prefix_len + entry->name_len + 1;
2782                         }
2783
2784                         list_size += prefix_len + entry->name_len + 1;
2785                 }
2786                 if (ret_size)
2787                         *ret_size = list_size;
2788
2789         }
2790         ext4_fs_put_inode_ref(&inode_ref);
2791 Finish:
2792         EXT4_MP_UNLOCK(mp);
2793         if (xattr_list)
2794                 ext4_free(xattr_list);
2795
2796         return r;
2797
2798 }
2799
2800 int ext4_removexattr(const char *path, const char *name, size_t name_len)
2801 {
2802         bool found;
2803         int r = EOK;
2804         ext4_file f;
2805         uint32_t inode;
2806         uint8_t name_index;
2807         const char *dissected_name = NULL;
2808         size_t dissected_len = 0;
2809         struct ext4_inode_ref inode_ref;
2810         struct ext4_mountpoint *mp = ext4_get_mount(path);
2811         if (!mp)
2812                 return ENOENT;
2813
2814         if (mp->fs.read_only)
2815                 return EROFS;
2816
2817         dissected_name = ext4_extract_xattr_name(name, name_len,
2818                                                 &name_index, &dissected_len,
2819                                                 &found);
2820         if (!found)
2821                 return EINVAL;
2822
2823         EXT4_MP_LOCK(mp);
2824         ext4_trans_start(mp);
2825
2826         r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DE_UNKNOWN, NULL, NULL);
2827         if (r != EOK)
2828                 goto Finish;
2829         inode = f.inode;
2830         ext4_fclose(&f);
2831
2832         r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
2833         if (r != EOK)
2834                 goto Finish;
2835
2836         r = ext4_xattr_remove(&inode_ref, name_index, dissected_name,
2837                               dissected_len);
2838
2839         ext4_fs_put_inode_ref(&inode_ref);
2840 Finish:
2841         if (r != EOK)
2842                 ext4_trans_abort(mp);
2843         else
2844                 ext4_trans_stop(mp);
2845
2846         EXT4_MP_UNLOCK(mp);
2847         return r;
2848
2849 }
2850
2851 /*********************************DIRECTORY OPERATION************************/
2852
2853 int ext4_dir_rm(const char *path)
2854 {
2855         int r;
2856         int len;
2857         ext4_file f;
2858
2859         struct ext4_mountpoint *mp = ext4_get_mount(path);
2860         struct ext4_inode_ref act;
2861         struct ext4_inode_ref child;
2862         struct ext4_dir_iter it;
2863
2864         uint32_t name_off;
2865         uint32_t inode_up;
2866         uint32_t inode_current;
2867         uint32_t depth = 1;
2868
2869         bool has_children;
2870         bool is_goal;
2871         bool dir_end;
2872
2873         if (!mp)
2874                 return ENOENT;
2875
2876         if (mp->fs.read_only)
2877                 return EROFS;
2878
2879         EXT4_MP_LOCK(mp);
2880
2881         struct ext4_fs *const fs = &mp->fs;
2882
2883         /*Check if exist.*/
2884         r = ext4_generic_open(&f, path, "r", false, &inode_up, &name_off);
2885         if (r != EOK) {
2886                 ext4_trans_abort(mp);
2887                 EXT4_MP_UNLOCK(mp);
2888                 return r;
2889         }
2890
2891         path += name_off;
2892         len = ext4_path_check(path, &is_goal);
2893
2894         inode_current = f.inode;
2895
2896         ext4_block_cache_write_back(mp->fs.bdev, 1);
2897
2898         do {
2899
2900                 uint64_t act_curr_pos = 0;
2901                 has_children = false;
2902                 dir_end = false;
2903
2904                 while (r == EOK && !has_children && !dir_end) {
2905
2906                         /*Load directory node.*/
2907                         r = ext4_fs_get_inode_ref(fs, inode_current, &act);
2908                         if (r != EOK) {
2909                                 break;
2910                         }
2911
2912                         /*Initialize iterator.*/
2913                         r = ext4_dir_iterator_init(&it, &act, act_curr_pos);
2914                         if (r != EOK) {
2915                                 ext4_fs_put_inode_ref(&act);
2916                                 break;
2917                         }
2918
2919                         if (!it.curr) {
2920                                 dir_end = true;
2921                                 goto End;
2922                         }
2923
2924                         ext4_trans_start(mp);
2925
2926                         /*Get up directory inode when ".." entry*/
2927                         if ((it.curr->name_len == 2) &&
2928                             ext4_is_dots(it.curr->name, it.curr->name_len)) {
2929                                 inode_up = ext4_dir_en_get_inode(it.curr);
2930                         }
2931
2932                         /*If directory or file entry,  but not "." ".." entry*/
2933                         if (!ext4_is_dots(it.curr->name, it.curr->name_len)) {
2934
2935                                 /*Get child inode reference do unlink
2936                                  * directory/file.*/
2937                                 uint32_t cinode;
2938                                 uint32_t inode_type;
2939                                 cinode = ext4_dir_en_get_inode(it.curr);
2940                                 r = ext4_fs_get_inode_ref(fs, cinode, &child);
2941                                 if (r != EOK)
2942                                         goto End;
2943
2944                                 /*If directory with no leaf children*/
2945                                 r = ext4_has_children(&has_children, &child);
2946                                 if (r != EOK) {
2947                                         ext4_fs_put_inode_ref(&child);
2948                                         goto End;
2949                                 }
2950
2951                                 if (has_children) {
2952                                         /*Has directory children. Go into this
2953                                          * directory.*/
2954                                         inode_up = inode_current;
2955                                         inode_current = cinode;
2956                                         depth++;
2957                                         ext4_fs_put_inode_ref(&child);
2958                                         goto End;
2959                                 }
2960                                 inode_type = ext4_inode_type(&mp->fs.sb,
2961                                                 child.inode);
2962
2963                                 /* Truncate */
2964                                 if (inode_type != EXT4_INODE_MODE_DIRECTORY)
2965                                         r = ext4_trunc_inode(mp, child.index, 0);
2966                                 else
2967                                         r = ext4_trunc_dir(mp, &act, &child);
2968
2969                                 if (r != EOK) {
2970                                         ext4_fs_put_inode_ref(&child);
2971                                         goto End;
2972                                 }
2973
2974                                 /*No children in child directory or file. Just
2975                                  * unlink.*/
2976                                 r = ext4_unlink(f.mp, &act, &child,
2977                                                 (char *)it.curr->name,
2978                                                 it.curr->name_len);
2979                                 if (r != EOK) {
2980                                         ext4_fs_put_inode_ref(&child);
2981                                         goto End;
2982                                 }
2983
2984                                 ext4_inode_set_del_time(child.inode, -1L);
2985                                 ext4_inode_set_links_cnt(child.inode, 0);
2986                                 child.dirty = true;
2987
2988                                 r = ext4_fs_free_inode(&child);
2989                                 if (r != EOK) {
2990                                         ext4_fs_put_inode_ref(&child);
2991                                         goto End;
2992                                 }
2993
2994                                 r = ext4_fs_put_inode_ref(&child);
2995                                 if (r != EOK)
2996                                         goto End;
2997
2998                         }
2999
3000                         r = ext4_dir_iterator_next(&it);
3001                         if (r != EOK)
3002                                 goto End;
3003
3004                         act_curr_pos = it.curr_off;
3005 End:
3006                         ext4_dir_iterator_fini(&it);
3007                         if (r == EOK)
3008                                 r = ext4_fs_put_inode_ref(&act);
3009                         else
3010                                 ext4_fs_put_inode_ref(&act);
3011
3012                         if (r != EOK)
3013                                 ext4_trans_abort(mp);
3014                         else
3015                                 ext4_trans_stop(mp);
3016                 }
3017
3018                 if (dir_end) {
3019                         /*Directory iterator reached last entry*/
3020                         depth--;
3021                         if (depth)
3022                                 inode_current = inode_up;
3023
3024                 }
3025
3026                 if (r != EOK)
3027                         break;
3028
3029         } while (depth);
3030
3031         /*Last unlink*/
3032         if (r == EOK && !depth) {
3033                 /*Load parent.*/
3034                 struct ext4_inode_ref parent;
3035                 r = ext4_fs_get_inode_ref(&f.mp->fs, inode_up,
3036                                 &parent);
3037                 if (r != EOK)
3038                         goto Finish;
3039                 r = ext4_fs_get_inode_ref(&f.mp->fs, inode_current,
3040                                 &act);
3041                 if (r != EOK) {
3042                         ext4_fs_put_inode_ref(&act);
3043                         goto Finish;
3044                 }
3045
3046                 ext4_trans_start(mp);
3047
3048                 /* In this place all directories should be
3049                  * unlinked.
3050                  * Last unlink from root of current directory*/
3051                 r = ext4_unlink(f.mp, &parent, &act,
3052                                 (char *)path, len);
3053                 if (r != EOK) {
3054                         ext4_fs_put_inode_ref(&parent);
3055                         ext4_fs_put_inode_ref(&act);
3056                         goto Finish;
3057                 }
3058
3059                 if (ext4_inode_get_links_cnt(act.inode) == 2) {
3060                         ext4_inode_set_del_time(act.inode, -1L);
3061                         ext4_inode_set_links_cnt(act.inode, 0);
3062                         act.dirty = true;
3063                         /*Truncate*/
3064                         r = ext4_trunc_dir(mp, &parent, &act);
3065                         if (r != EOK) {
3066                                 ext4_fs_put_inode_ref(&parent);
3067                                 ext4_fs_put_inode_ref(&act);
3068                                 goto Finish;
3069                         }
3070
3071                         r = ext4_fs_free_inode(&act);
3072                         if (r != EOK) {
3073                                 ext4_fs_put_inode_ref(&parent);
3074                                 ext4_fs_put_inode_ref(&act);
3075                                 goto Finish;
3076                         }
3077                 }
3078
3079                 r = ext4_fs_put_inode_ref(&parent);
3080                 if (r != EOK)
3081                         goto Finish;
3082
3083                 r = ext4_fs_put_inode_ref(&act);
3084         Finish:
3085                 if (r != EOK)
3086                         ext4_trans_abort(mp);
3087                 else
3088                         ext4_trans_stop(mp);
3089         }
3090
3091         ext4_block_cache_write_back(mp->fs.bdev, 0);
3092         EXT4_MP_UNLOCK(mp);
3093
3094         return r;
3095 }
3096
3097 int ext4_dir_mv(const char *path, const char *new_path)
3098 {
3099         return ext4_frename(path, new_path);
3100 }
3101
3102 int ext4_dir_mk(const char *path)
3103 {
3104         int r;
3105         ext4_file f;
3106
3107         struct ext4_mountpoint *mp = ext4_get_mount(path);
3108
3109         if (!mp)
3110                 return ENOENT;
3111
3112         if (mp->fs.read_only)
3113                 return EROFS;
3114
3115         EXT4_MP_LOCK(mp);
3116         ext4_trans_start(mp);
3117
3118         /*Check if exist.*/
3119         r = ext4_generic_open(&f, path, "r", false, 0, 0);
3120         if (r == EOK) {
3121                 /*Directory already created*/
3122                 ext4_trans_stop(mp);
3123                 EXT4_MP_UNLOCK(mp);
3124                 return r;
3125         }
3126
3127         /*Create new dir*/
3128         r = ext4_generic_open(&f, path, "w", false, 0, 0);
3129         if (r != EOK) {
3130                 ext4_trans_abort(mp);
3131                 EXT4_MP_UNLOCK(mp);
3132                 return r;
3133         }
3134
3135         ext4_trans_stop(mp);
3136         EXT4_MP_UNLOCK(mp);
3137         return r;
3138 }
3139
3140 int ext4_dir_open(ext4_dir *d, const char *path)
3141 {
3142         struct ext4_mountpoint *mp = ext4_get_mount(path);
3143         int r;
3144
3145         if (!mp)
3146                 return ENOENT;
3147
3148         EXT4_MP_LOCK(mp);
3149         r = ext4_generic_open(&d->f, path, "r", false, 0, 0);
3150         d->next_off = 0;
3151         EXT4_MP_UNLOCK(mp);
3152         return r;
3153 }
3154
3155 int ext4_dir_close(ext4_dir *d)
3156 {
3157     return ext4_fclose(&d->f);
3158 }
3159
3160 const ext4_direntry *ext4_dir_entry_next(ext4_dir *d)
3161 {
3162 #define EXT4_DIR_ENTRY_OFFSET_TERM (uint64_t)(-1)
3163
3164         int r;
3165         uint16_t name_length;
3166         ext4_direntry *de = 0;
3167         struct ext4_inode_ref dir;
3168         struct ext4_dir_iter it;
3169
3170         EXT4_MP_LOCK(d->f.mp);
3171
3172         if (d->next_off == EXT4_DIR_ENTRY_OFFSET_TERM) {
3173                 EXT4_MP_UNLOCK(d->f.mp);
3174                 return 0;
3175         }
3176
3177         r = ext4_fs_get_inode_ref(&d->f.mp->fs, d->f.inode, &dir);
3178         if (r != EOK) {
3179                 goto Finish;
3180         }
3181
3182         r = ext4_dir_iterator_init(&it, &dir, d->next_off);
3183         if (r != EOK) {
3184                 ext4_fs_put_inode_ref(&dir);
3185                 goto Finish;
3186         }
3187
3188         memset(&d->de.name, 0, sizeof(d->de.name));
3189         name_length = ext4_dir_en_get_name_len(&d->f.mp->fs.sb,
3190                                                it.curr);
3191         memcpy(&d->de.name, it.curr->name, name_length);
3192
3193         /* Directly copying the content isn't safe for Big-endian targets*/
3194         d->de.inode = ext4_dir_en_get_inode(it.curr);
3195         d->de.entry_length = ext4_dir_en_get_entry_len(it.curr);
3196         d->de.name_length = name_length;
3197         d->de.inode_type = ext4_dir_en_get_inode_type(&d->f.mp->fs.sb,
3198                                                       it.curr);
3199
3200         de = &d->de;
3201
3202         ext4_dir_iterator_next(&it);
3203
3204         d->next_off = it.curr ? it.curr_off : EXT4_DIR_ENTRY_OFFSET_TERM;
3205
3206         ext4_dir_iterator_fini(&it);
3207         ext4_fs_put_inode_ref(&dir);
3208
3209 Finish:
3210         EXT4_MP_UNLOCK(d->f.mp);
3211         return de;
3212 }
3213
3214 void ext4_dir_entry_rewind(ext4_dir *d)
3215 {
3216         d->next_off = 0;
3217 }
3218
3219 /**
3220  * @}
3221  */