src/ext4.c

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