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