-/*\r
- * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)\r
- * All rights reserved.\r
- *\r
- * Redistribution and use in source and binary forms, with or without\r
- * modification, are permitted provided that the following conditions\r
- * are met:\r
- *\r
- * - Redistributions of source code must retain the above copyright\r
- * notice, this list of conditions and the following disclaimer.\r
- * - Redistributions in binary form must reproduce the above copyright\r
- * notice, this list of conditions and the following disclaimer in the\r
- * documentation and/or other materials provided with the distribution.\r
- * - The name of the author may not be used to endorse or promote products\r
- * derived from this software without specific prior written permission.\r
- *\r
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR\r
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES\r
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.\r
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,\r
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\r
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\r
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\r
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\r
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\r
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
- */\r
-\r
-/** @addtogroup lwext4\r
- * @{\r
- */\r
-/**\r
- * @file ext4.h\r
- * @brief Ext4 high level operations (file, directory, mountpoints...)\r
- */\r
-\r
-#include "ext4_config.h"\r
-#include "ext4_blockdev.h"\r
-#include "ext4_types.h"\r
-#include "ext4_debug.h"\r
-#include "ext4_errno.h"\r
-#include "ext4_fs.h"\r
-#include "ext4_dir.h"\r
-#include "ext4_inode.h"\r
-#include "ext4_super.h"\r
-#include "ext4_dir_idx.h"\r
-#include "ext4.h"\r
-\r
-#include <stdlib.h>\r
-#include <string.h>\r
-\r
-/**@brief Mount point OS dependent lock*/\r
-#define EXT4_MP_LOCK(_m) \\r
- do { \\r
- if ((_m)->os_locks) \\r
- (_m)->os_locks->lock(); \\r
- } while (0)\r
-\r
-/**@brief Mount point OS dependent unlock*/\r
-#define EXT4_MP_UNLOCK(_m) \\r
- do { \\r
- if ((_m)->os_locks) \\r
- (_m)->os_locks->unlock(); \\r
- } while (0)\r
-\r
-/**@brief Mount point descriptor.*/\r
-struct ext4_mountpoint {\r
-\r
- /**@brief Mount done flag.*/\r
- bool mounted;\r
-\r
- /**@brief Mount point name (@ref ext4_mount)*/\r
- char name[32];\r
-\r
- /**@brief OS dependent lock/unlock functions.*/\r
- const struct ext4_lock *os_locks;\r
-\r
- /**@brief Ext4 filesystem internals.*/\r
- struct ext4_fs fs;\r
-\r
- /**@brief Dynamic allocation cache flag.*/\r
- bool cache_dynamic;\r
-};\r
-\r
-/**@brief Block devices descriptor.*/\r
-struct _ext4_devices {\r
-\r
- /**@brief Block device name (@ref ext4_device_register)*/\r
- char name[32];\r
-\r
- /**@brief Block device handle.*/\r
- struct ext4_blockdev *bd;\r
-\r
- /**@brief Block cache handle.*/\r
- struct ext4_bcache *bc;\r
-};\r
-\r
-/**@brief Block devices.*/\r
-struct _ext4_devices _bdevices[CONFIG_EXT4_BLOCKDEVS_COUNT];\r
-\r
-/**@brief Mountpoints.*/\r
-struct ext4_mountpoint _mp[CONFIG_EXT4_MOUNTPOINTS_COUNT];\r
-\r
-int ext4_device_register(struct ext4_blockdev *bd, struct ext4_bcache *bc,\r
- const char *dev_name)\r
-{\r
- uint32_t i;\r
- ext4_assert(bd && dev_name);\r
-\r
- for (i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {\r
- if (!_bdevices[i].bd) {\r
- strcpy(_bdevices[i].name, dev_name);\r
- _bdevices[i].bd = bd;\r
- _bdevices[i].bc = bc;\r
- return EOK;\r
- }\r
-\r
- if (!strcmp(_bdevices[i].name, dev_name))\r
- return EOK;\r
- }\r
- return ENOSPC;\r
-}\r
-\r
-/****************************************************************************/\r
-\r
-static bool ext4_is_dots(const uint8_t *name, size_t name_size)\r
-{\r
- if ((name_size == 1) && (name[0] == '.'))\r
- return true;\r
-\r
- if ((name_size == 2) && (name[0] == '.') && (name[1] == '.'))\r
- return true;\r
-\r
- return false;\r
-}\r
-\r
-static int ext4_has_children(bool *has_children, struct ext4_inode_ref *enode)\r
-{\r
- struct ext4_fs *fs = enode->fs;\r
-\r
- /* Check if node is directory */\r
- if (!ext4_inode_is_type(&fs->sb, enode->inode,\r
- EXT4_INODE_MODE_DIRECTORY)) {\r
- *has_children = false;\r
- return EOK;\r
- }\r
-\r
- struct ext4_directory_iterator it;\r
- int rc = ext4_dir_iterator_init(&it, enode, 0);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- /* Find a non-empty directory entry */\r
- bool found = false;\r
- while (it.current != NULL) {\r
- if (ext4_dir_entry_ll_get_inode(it.current) != 0) {\r
- uint16_t name_size = ext4_dir_entry_ll_get_name_length(\r
- &fs->sb, it.current);\r
- if (!ext4_is_dots(it.current->name, name_size)) {\r
- found = true;\r
- break;\r
- }\r
- }\r
-\r
- rc = ext4_dir_iterator_next(&it);\r
- if (rc != EOK) {\r
- ext4_dir_iterator_fini(&it);\r
- return rc;\r
- }\r
- }\r
-\r
- rc = ext4_dir_iterator_fini(&it);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- *has_children = found;\r
-\r
- return EOK;\r
-}\r
-\r
-static int ext4_link(struct ext4_mountpoint *mp, struct ext4_inode_ref *parent,\r
- struct ext4_inode_ref *child, const char *name,\r
- uint32_t name_len)\r
-{\r
- /* Check maximum name length */\r
- if (name_len > EXT4_DIRECTORY_FILENAME_LEN)\r
- return EINVAL;\r
-\r
- /* Add entry to parent directory */\r
- int rc = ext4_dir_add_entry(parent, name, name_len, child);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- /* Fill new dir -> add '.' and '..' entries.\r
- * Also newly allocated inode should have 0 link count.\r
- */\r
- if (ext4_inode_is_type(&mp->fs.sb, child->inode,\r
- EXT4_INODE_MODE_DIRECTORY) &&\r
- ext4_inode_get_links_count(child->inode) == 0) {\r
- rc = ext4_dir_add_entry(child, ".", strlen("."), child);\r
- if (rc != EOK) {\r
- ext4_dir_remove_entry(parent, name, strlen(name));\r
- return rc;\r
- }\r
-\r
- rc = ext4_dir_add_entry(child, "..", strlen(".."), parent);\r
- if (rc != EOK) {\r
- ext4_dir_remove_entry(parent, name, strlen(name));\r
- ext4_dir_remove_entry(child, ".", strlen("."));\r
- return rc;\r
- }\r
-\r
- /*New empty directory. Two links (. and ..) */\r
- ext4_inode_set_links_count(child->inode, 2);\r
-\r
-#if CONFIG_DIR_INDEX_ENABLE\r
- /* Initialize directory index if supported */\r
- if (ext4_sb_has_feature_compatible(\r
- &mp->fs.sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) {\r
- rc = ext4_dir_dx_init(child);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- ext4_inode_set_flag(child->inode,\r
- EXT4_INODE_FLAG_INDEX);\r
- child->dirty = true;\r
- }\r
-#endif\r
-\r
- ext4_fs_inode_links_count_inc(parent);\r
- child->dirty = true;\r
- parent->dirty = true;\r
- } else {\r
- if (ext4_inode_is_type(&mp->fs.sb, child->inode,\r
- EXT4_INODE_MODE_DIRECTORY)) {\r
- /* FIXME: SO TRICKY. */\r
- int has_flag_index = ext4_inode_has_flag(\r
- child->inode, EXT4_INODE_FLAG_INDEX);\r
- struct ext4_directory_search_result result;\r
- if (has_flag_index)\r
- ext4_inode_clear_flag(child->inode,\r
- EXT4_INODE_FLAG_INDEX);\r
-\r
- rc = ext4_dir_find_entry(&result, child, "..",\r
- strlen(".."));\r
- if (has_flag_index)\r
- ext4_inode_set_flag(child->inode,\r
- EXT4_INODE_FLAG_INDEX);\r
-\r
- if (rc != EOK)\r
- return EIO;\r
-\r
- ext4_dir_entry_ll_set_inode(result.dentry,\r
- parent->index);\r
- result.block.dirty = true;\r
- rc = ext4_dir_destroy_result(child, &result);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- ext4_fs_inode_links_count_inc(parent);\r
- parent->dirty = true;\r
- } else {\r
- ext4_fs_inode_links_count_inc(child);\r
- child->dirty = true;\r
- }\r
- }\r
-\r
- return rc;\r
-}\r
-\r
-static int ext4_unlink(struct ext4_mountpoint *mp,\r
- struct ext4_inode_ref *parent,\r
- struct ext4_inode_ref *child_inode_ref, const char *name,\r
- uint32_t name_len)\r
-{\r
- bool has_children;\r
- int rc = ext4_has_children(&has_children, child_inode_ref);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- /* Cannot unlink non-empty node */\r
- if (has_children)\r
- return ENOTSUP;\r
-\r
- /* Remove entry from parent directory */\r
- rc = ext4_dir_remove_entry(parent, name, name_len);\r
- if (rc != EOK)\r
- return rc;\r
-\r
- bool is_dir = ext4_inode_is_type(&mp->fs.sb, child_inode_ref->inode,\r
- EXT4_INODE_MODE_DIRECTORY);\r
-\r
- /* If directory - handle links from parent */\r
- if (is_dir) {\r
- // ext4_assert(ext4_inode_get_links_count(child_inode_ref->inode)\r
- // == 1);\r
- ext4_fs_inode_links_count_dec(parent);\r
- parent->dirty = true;\r
- }\r
-\r
- /*\r
- * TODO: Update timestamps of the parent\r
- * (when we have wall-clock time).\r
- *\r
- * ext4_inode_set_change_inode_time(parent->inode, (uint32_t) now);\r
- * ext4_inode_set_modification_time(parent->inode, (uint32_t) now);\r
- * parent->dirty = true;\r
- */\r
-\r
- /*\r
- * TODO: Update timestamp for inode.\r
- *\r
- * ext4_inode_set_change_inode_time(child_inode_ref->inode,\r
- * (uint32_t) now);\r
- */\r
- if (ext4_inode_get_links_count(child_inode_ref->inode)) {\r
- ext4_fs_inode_links_count_dec(child_inode_ref);\r
- child_inode_ref->dirty = true;\r
- }\r
-\r
- return EOK;\r
-}\r
-\r
-/****************************************************************************/\r
-\r
-int ext4_mount(const char *dev_name, const char *mount_point)\r
-{\r
- ext4_assert(mount_point && dev_name);\r
- int r;\r
- int i;\r
-\r
- uint32_t bsize;\r
- struct ext4_blockdev *bd = 0;\r
- struct ext4_bcache *bc = 0;\r
- struct ext4_mountpoint *mp = 0;\r
-\r
- if (mount_point[strlen(mount_point) - 1] != '/')\r
- return ENOTSUP;\r
-\r
- for (i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {\r
- if (_bdevices[i].name) {\r
- if (!strcmp(dev_name, _bdevices[i].name)) {\r
- bd = _bdevices[i].bd;\r
- bc = _bdevices[i].bc;\r
- break;\r
- }\r
- }\r
- }\r
-\r
- if (!bd)\r
- return ENODEV;\r
-\r
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {\r
- if (!_mp[i].mounted) {\r
- strcpy(_mp[i].name, mount_point);\r
- _mp[i].mounted = 1;\r
- mp = &_mp[i];\r
- break;\r
- }\r
-\r
- if (!strcmp(_mp[i].name, mount_point))\r
- return EOK;\r
- }\r
-\r
- if (!mp)\r
- return ENOMEM;\r
-\r
- r = ext4_block_init(bd);\r
- if (r != EOK)\r
- return r;\r
-\r
- r = ext4_fs_init(&mp->fs, bd);\r
- if (r != EOK) {\r
- ext4_block_fini(bd);\r
- return r;\r
- }\r
-\r
- bsize = ext4_sb_get_block_size(&mp->fs.sb);\r
- ext4_block_set_lb_size(bd, bsize);\r
-\r
- mp->cache_dynamic = 0;\r
-\r
- if (!bc) {\r
- /*Automatic block cache alloc.*/\r
- mp->cache_dynamic = 1;\r
- bc = malloc(sizeof(struct ext4_bcache));\r
-\r
- r = ext4_bcache_init_dynamic(bc, CONFIG_BLOCK_DEV_CACHE_SIZE,\r
- bsize);\r
- if (r != EOK) {\r
- free(bc);\r
- ext4_block_fini(bd);\r
- return r;\r
- }\r
- }\r
-\r
- if (bsize != bc->itemsize)\r
- return ENOTSUP;\r
-\r
- /*Bind block cache to block device*/\r
- r = ext4_block_bind_bcache(bd, bc);\r
- if (r != EOK) {\r
- ext4_block_fini(bd);\r
- if (mp->cache_dynamic) {\r
- ext4_bcache_fini_dynamic(bc);\r
- free(bc);\r
- }\r
- return r;\r
- }\r
-\r
- return r;\r
-}\r
-\r
-int ext4_umount(const char *mount_point)\r
-{\r
- int i;\r
- int r;\r
- struct ext4_mountpoint *mp = 0;\r
-\r
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {\r
- if (!strcmp(_mp[i].name, mount_point)) {\r
- mp = &_mp[i];\r
- break;\r
- }\r
- }\r
-\r
- if (!mp)\r
- return ENODEV;\r
-\r
- r = ext4_fs_fini(&mp->fs);\r
- if (r != EOK)\r
- return r;\r
-\r
- mp->mounted = 0;\r
-\r
- if (mp->cache_dynamic) {\r
- ext4_bcache_fini_dynamic(mp->fs.bdev->bc);\r
- free(mp->fs.bdev->bc);\r
- }\r
-\r
- return ext4_block_fini(mp->fs.bdev);\r
-}\r
-\r
-int ext4_mount_point_stats(const char *mount_point,\r
- struct ext4_mount_stats *stats)\r
-{\r
- uint32_t i;\r
- struct ext4_mountpoint *mp = 0;\r
-\r
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {\r
- if (!strcmp(_mp[i].name, mount_point)) {\r
- mp = &_mp[i];\r
- break;\r
- }\r
- }\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
- stats->inodes_count = ext4_get32(&mp->fs.sb, inodes_count);\r
- stats->free_inodes_count = ext4_get32(&mp->fs.sb, free_inodes_count);\r
- stats->blocks_count = ext4_sb_get_blocks_cnt(&mp->fs.sb);\r
- stats->free_blocks_count = ext4_sb_get_free_blocks_cnt(&mp->fs.sb);\r
- stats->block_size = ext4_sb_get_block_size(&mp->fs.sb);\r
-\r
- stats->block_group_count = ext4_block_group_cnt(&mp->fs.sb);\r
- stats->blocks_per_group = ext4_get32(&mp->fs.sb, blocks_per_group);\r
- stats->inodes_per_group = ext4_get32(&mp->fs.sb, inodes_per_group);\r
-\r
- memcpy(stats->volume_name, mp->fs.sb.volume_name, 16);\r
- EXT4_MP_UNLOCK(mp);\r
-\r
- return EOK;\r
-}\r
-\r
-int ext4_mount_setup_locks(const char *mount_point,\r
- const struct ext4_lock *locks)\r
-{\r
- uint32_t i;\r
- struct ext4_mountpoint *mp = 0;\r
-\r
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {\r
- if (!strcmp(_mp[i].name, mount_point)) {\r
- mp = &_mp[i];\r
- break;\r
- }\r
- }\r
- if (!mp)\r
- return ENOENT;\r
-\r
- mp->os_locks = locks;\r
- return EOK;\r
-}\r
-\r
-/********************************FILE OPERATIONS*****************************/\r
-\r
-static struct ext4_mountpoint *ext4_get_mount(const char *path)\r
-{\r
- int i;\r
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {\r
-\r
- if (!_mp[i].mounted)\r
- continue;\r
-\r
- if (!strncmp(_mp[i].name, path, strlen(_mp[i].name)))\r
- return &_mp[i];\r
- }\r
- return 0;\r
-}\r
-\r
-static int ext4_path_check(const char *path, bool *is_goal)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < EXT4_DIRECTORY_FILENAME_LEN; ++i) {\r
-\r
- if (path[i] == '/') {\r
- *is_goal = false;\r
- return i;\r
- }\r
-\r
- if (path[i] == 0) {\r
- *is_goal = true;\r
- return i;\r
- }\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-static bool ext4_parse_flags(const char *flags, uint32_t *file_flags)\r
-{\r
- if (!flags)\r
- return false;\r
-\r
- if (!strcmp(flags, "r") || !strcmp(flags, "rb")) {\r
- *file_flags = O_RDONLY;\r
- return true;\r
- }\r
-\r
- if (!strcmp(flags, "w") || !strcmp(flags, "wb")) {\r
- *file_flags = O_WRONLY | O_CREAT | O_TRUNC;\r
- return true;\r
- }\r
-\r
- if (!strcmp(flags, "a") || !strcmp(flags, "ab")) {\r
- *file_flags = O_WRONLY | O_CREAT | O_APPEND;\r
- return true;\r
- }\r
-\r
- if (!strcmp(flags, "r+") || !strcmp(flags, "rb+") ||\r
- !strcmp(flags, "r+b")) {\r
- *file_flags = O_RDWR;\r
- return true;\r
- }\r
-\r
- if (!strcmp(flags, "w+") || !strcmp(flags, "wb+") ||\r
- !strcmp(flags, "w+b")) {\r
- *file_flags = O_RDWR | O_CREAT | O_TRUNC;\r
- return true;\r
- }\r
-\r
- if (!strcmp(flags, "a+") || !strcmp(flags, "ab+") ||\r
- !strcmp(flags, "a+b")) {\r
- *file_flags = O_RDWR | O_CREAT | O_APPEND;\r
- return true;\r
- }\r
-\r
- return false;\r
-}\r
-\r
-/*\r
- * NOTICE: if filetype is equal to EXT4_DIRECTORY_FILETYPE_UNKNOWN,\r
- * any filetype of the target dir entry will be accepted.\r
- */\r
-static int ext4_generic_open2(ext4_file *f, const char *path, int flags,\r
- int filetype, uint32_t *parent_inode,\r
- uint32_t *name_off)\r
-{\r
- bool is_goal = false;\r
- uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;\r
- uint32_t next_inode;\r
-\r
- int r;\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- struct ext4_directory_search_result result;\r
- struct ext4_inode_ref ref;\r
-\r
- f->mp = 0;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- f->flags = flags;\r
-\r
- /*Skip mount point*/\r
- path += strlen(mp->name);\r
-\r
- if (name_off)\r
- *name_off = strlen(mp->name);\r
-\r
- /*Load root*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, EXT4_INODE_ROOT_INDEX, &ref);\r
-\r
- if (r != EOK)\r
- return r;\r
-\r
- if (parent_inode)\r
- *parent_inode = ref.index;\r
-\r
- int len = ext4_path_check(path, &is_goal);\r
-\r
- while (1) {\r
-\r
- len = ext4_path_check(path, &is_goal);\r
-\r
- if (!len) {\r
- /*If root open was request.*/\r
- if (is_goal &&\r
- ((filetype == EXT4_DIRECTORY_FILETYPE_DIR) ||\r
- (filetype == EXT4_DIRECTORY_FILETYPE_UNKNOWN)))\r
- break;\r
-\r
- r = ENOENT;\r
- break;\r
- }\r
-\r
- r = ext4_dir_find_entry(&result, &ref, path, len);\r
- if (r != EOK) {\r
-\r
- if (r != ENOENT)\r
- break;\r
-\r
- if (!(f->flags & O_CREAT))\r
- break;\r
-\r
- /*O_CREAT allows create new entry*/\r
- struct ext4_inode_ref child_ref;\r
- r = ext4_fs_alloc_inode(\r
- &mp->fs, &child_ref,\r
- is_goal ? (filetype == EXT4_DIRECTORY_FILETYPE_DIR)\r
- : true);\r
- if (r != EOK)\r
- break;\r
-\r
- /*Destroy last result*/\r
- ext4_dir_destroy_result(&ref, &result);\r
-\r
- /*Link with root dir.*/\r
- r = ext4_link(mp, &ref, &child_ref, path, len);\r
- if (r != EOK) {\r
- /*Fail. Free new inode.*/\r
- ext4_fs_free_inode(&child_ref);\r
- /*We do not want to write new inode.\r
- But block has to be released.*/\r
- child_ref.dirty = false;\r
- ext4_fs_put_inode_ref(&child_ref);\r
- break;\r
- }\r
-\r
- ext4_fs_put_inode_ref(&child_ref);\r
-\r
- continue;\r
- }\r
-\r
- if (parent_inode)\r
- *parent_inode = ref.index;\r
-\r
- next_inode = ext4_dir_entry_ll_get_inode(result.dentry);\r
- inode_type =\r
- ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, result.dentry);\r
-\r
- r = ext4_dir_destroy_result(&ref, &result);\r
- if (r != EOK)\r
- break;\r
-\r
- /*If expected file error*/\r
- if (inode_type != EXT4_DIRECTORY_FILETYPE_DIR && !is_goal) {\r
- r = ENOENT;\r
- break;\r
- }\r
- if (filetype != EXT4_DIRECTORY_FILETYPE_UNKNOWN) {\r
- if ((inode_type != filetype) && is_goal) {\r
- r = ENOENT;\r
- break;\r
- }\r
- }\r
-\r
- r = ext4_fs_put_inode_ref(&ref);\r
- if (r != EOK)\r
- break;\r
-\r
- r = ext4_fs_get_inode_ref(&mp->fs, next_inode, &ref);\r
- if (r != EOK)\r
- break;\r
-\r
- if (is_goal)\r
- break;\r
-\r
- path += len + 1;\r
-\r
- if (name_off)\r
- *name_off += len + 1;\r
- };\r
-\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&ref);\r
- return r;\r
- }\r
-\r
- if (is_goal) {\r
-\r
- if ((f->flags & O_TRUNC) &&\r
- (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE)) {\r
-\r
- r = ext4_fs_truncate_inode(&ref, 0);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&ref);\r
- return r;\r
- }\r
- }\r
-\r
- f->mp = mp;\r
- f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);\r
- f->inode = ref.index;\r
- f->fpos = 0;\r
-\r
- if (f->flags & O_APPEND)\r
- f->fpos = f->fsize;\r
- }\r
-\r
- r = ext4_fs_put_inode_ref(&ref);\r
- return r;\r
-}\r
-\r
-/****************************************************************************/\r
-\r
-static int ext4_generic_open(ext4_file *f, const char *path, const char *flags,\r
- bool file_expect, uint32_t *parent_inode,\r
- uint32_t *name_off)\r
-{\r
- uint32_t iflags;\r
- int filetype;\r
- if (ext4_parse_flags(flags, &iflags) == false)\r
- return EINVAL;\r
-\r
- if (file_expect == true)\r
- filetype = EXT4_DIRECTORY_FILETYPE_REG_FILE;\r
- else\r
- filetype = EXT4_DIRECTORY_FILETYPE_DIR;\r
-\r
- return ext4_generic_open2(f, path, iflags, filetype, parent_inode,\r
- name_off);\r
-}\r
-\r
-static int __ext4_create_hardlink(const char *path,\r
- struct ext4_inode_ref *child_ref)\r
-{\r
- bool is_goal = false;\r
- uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;\r
- uint32_t next_inode;\r
-\r
- int r;\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- struct ext4_directory_search_result result;\r
- struct ext4_inode_ref ref;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- /*Skip mount point*/\r
- path += strlen(mp->name);\r
-\r
- /*Load root*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, EXT4_INODE_ROOT_INDEX, &ref);\r
-\r
- if (r != EOK)\r
- return r;\r
-\r
- int len = ext4_path_check(path, &is_goal);\r
-\r
- while (1) {\r
-\r
- len = ext4_path_check(path, &is_goal);\r
-\r
- if (!len) {\r
- /*If root open was request.*/\r
- if (is_goal)\r
- r = EINVAL;\r
- else\r
- r = ENOENT;\r
- break;\r
- }\r
-\r
- r = ext4_dir_find_entry(&result, &ref, path, len);\r
- if (r != EOK) {\r
-\r
- if (r != ENOENT || !is_goal)\r
- break;\r
-\r
- /*Destroy last result*/\r
- ext4_dir_destroy_result(&ref, &result);\r
-\r
- /*Link with root dir.*/\r
- r = ext4_link(mp, &ref, child_ref, path, len);\r
- break;\r
- }\r
-\r
- next_inode = ext4_dir_entry_ll_get_inode(result.dentry);\r
- inode_type =\r
- ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, result.dentry);\r
-\r
- r = ext4_dir_destroy_result(&ref, &result);\r
- if (r != EOK)\r
- break;\r
-\r
- if (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE) {\r
- if (is_goal)\r
- r = EEXIST;\r
- else\r
- r = ENOENT;\r
-\r
- break;\r
- }\r
-\r
- r = ext4_fs_put_inode_ref(&ref);\r
- if (r != EOK)\r
- break;\r
-\r
- r = ext4_fs_get_inode_ref(&mp->fs, next_inode, &ref);\r
- if (r != EOK)\r
- break;\r
-\r
- if (is_goal)\r
- break;\r
-\r
- path += len + 1;\r
- };\r
-\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&ref);\r
- return r;\r
- }\r
-\r
- r = ext4_fs_put_inode_ref(&ref);\r
- return r;\r
-}\r
-\r
-static int __ext4_get_inode_ref_remove_hardlink(const char *path,\r
- struct ext4_inode_ref *child)\r
-{\r
- ext4_file f;\r
- uint32_t parent_inode;\r
- uint32_t name_off;\r
- bool is_goal;\r
- int r;\r
- int len;\r
- struct ext4_inode_ref parent;\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- r = ext4_generic_open2(&f, path, O_RDONLY,\r
- EXT4_DIRECTORY_FILETYPE_UNKNOWN, &parent_inode,\r
- &name_off);\r
- if (r != EOK)\r
- return r;\r
-\r
- /*Load parent*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);\r
- if (r != EOK) {\r
- return r;\r
- }\r
-\r
- /*We have file to unlink. Load it.*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, f.inode, child);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&parent);\r
- return r;\r
- }\r
-\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- /*Set path*/\r
- path += name_off;\r
-\r
- len = ext4_path_check(path, &is_goal);\r
-\r
- /*Unlink from parent*/\r
- r = ext4_unlink(mp, &parent, child, path, len);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
-Finish:\r
- if (r != EOK)\r
- ext4_fs_put_inode_ref(child);\r
-\r
- ext4_fs_put_inode_ref(&parent);\r
- return r;\r
-}\r
-\r
-int ext4_frename(const char *path, const char *new_path)\r
-{\r
- int r;\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- struct ext4_inode_ref inode_ref;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- r = __ext4_get_inode_ref_remove_hardlink(path, &inode_ref);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- r = __ext4_create_hardlink(new_path, &inode_ref);\r
- if (r != EOK)\r
- r = __ext4_create_hardlink(path, &inode_ref);\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
-\r
-Finish:\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-/****************************************************************************/\r
-\r
-int ext4_get_sblock(const char *mount_point, struct ext4_sblock **sb)\r
-{\r
- struct ext4_mountpoint *mp = ext4_get_mount(mount_point);\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- *sb = &mp->fs.sb;\r
- return EOK;\r
-}\r
-\r
-int ext4_cache_write_back(const char *path, bool on)\r
-{\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
- ext4_block_cache_write_back(mp->fs.bdev, on);\r
- EXT4_MP_UNLOCK(mp);\r
- return EOK;\r
-}\r
-\r
-int ext4_fremove(const char *path)\r
-{\r
- ext4_file f;\r
- uint32_t parent_inode;\r
- uint32_t name_off;\r
- bool is_goal;\r
- int r;\r
- int len;\r
- struct ext4_inode_ref child;\r
- struct ext4_inode_ref parent;\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
- r = ext4_generic_open(&f, path, "r", true, &parent_inode, &name_off);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- /*Load parent*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- /*We have file to delete. Load it.*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &child);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&parent);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- /*Set path*/\r
- path += name_off;\r
-\r
- len = ext4_path_check(path, &is_goal);\r
-\r
- /*Unlink from parent*/\r
- r = ext4_unlink(mp, &parent, &child, path, len);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- /*Link count is zero, the inode should be freed. */\r
- if (!ext4_inode_get_links_count(child.inode)) {\r
- printf("ttttt\n");\r
- ext4_inode_set_deletion_time(child.inode, 0xFFFFFFFF);\r
- /*Turncate*/\r
- ext4_block_cache_write_back(mp->fs.bdev, 1);\r
- /*Truncate may be IO heavy. Do it writeback cache mode.*/\r
- r = ext4_fs_truncate_inode(&child, 0);\r
- ext4_block_cache_write_back(mp->fs.bdev, 0);\r
-\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- r = ext4_fs_free_inode(&child);\r
- if (r != EOK)\r
- goto Finish;\r
- }\r
-\r
-Finish:\r
- ext4_fs_put_inode_ref(&child);\r
- ext4_fs_put_inode_ref(&parent);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_fill_raw_inode(const char *mount_point, uint32_t ino,\r
- struct ext4_inode *inode)\r
-{\r
- int r;\r
- struct ext4_inode_ref inode_ref;\r
- struct ext4_mountpoint *mp = ext4_get_mount(mount_point);\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- /*Load parent*/\r
- r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- memcpy(inode, inode_ref.inode, sizeof(struct ext4_inode));\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_fopen(ext4_file *f, const char *path, const char *flags)\r
-{\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- int r;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
- ext4_block_cache_write_back(mp->fs.bdev, 1);\r
- r = ext4_generic_open(f, path, flags, true, 0, 0);\r
- ext4_block_cache_write_back(mp->fs.bdev, 0);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_fopen2(ext4_file *f, const char *path, int flags, bool file_expect)\r
-{\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- int r;\r
- int filetype;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- if (file_expect == true)\r
- filetype = EXT4_DIRECTORY_FILETYPE_REG_FILE;\r
- else\r
- filetype = EXT4_DIRECTORY_FILETYPE_DIR;\r
-\r
- EXT4_MP_LOCK(mp);\r
- ext4_block_cache_write_back(mp->fs.bdev, 1);\r
- r = ext4_generic_open2(f, path, flags, filetype, 0, 0);\r
- ext4_block_cache_write_back(mp->fs.bdev, 0);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_fclose(ext4_file *f)\r
-{\r
- ext4_assert(f && f->mp);\r
-\r
- f->mp = 0;\r
- f->flags = 0;\r
- f->inode = 0;\r
- f->fpos = f->fsize = 0;\r
-\r
- return EOK;\r
-}\r
-\r
-int ext4_ftruncate(ext4_file *f, uint64_t size)\r
-{\r
- struct ext4_inode_ref ref;\r
- int r;\r
-\r
- ext4_assert(f && f->mp);\r
-\r
- if (f->flags & O_RDONLY)\r
- return EPERM;\r
-\r
- EXT4_MP_LOCK(f->mp);\r
-\r
- r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(f->mp);\r
- return r;\r
- }\r
-\r
- /*Sync file size*/\r
- f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);\r
- if (f->fsize <= size) {\r
- r = EOK;\r
- goto Finish;\r
- }\r
-\r
- /*Start write back cache mode.*/\r
- r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- r = ext4_fs_truncate_inode(&ref, size);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- f->fsize = size;\r
- if (f->fpos > size)\r
- f->fpos = size;\r
-\r
- /*Stop write back cache mode*/\r
- ext4_block_cache_write_back(f->mp->fs.bdev, 0);\r
-\r
- if (r != EOK)\r
- goto Finish;\r
-\r
-Finish:\r
- ext4_fs_put_inode_ref(&ref);\r
- EXT4_MP_UNLOCK(f->mp);\r
- return r;\r
-}\r
-\r
-int ext4_fread(ext4_file *f, void *buf, uint32_t size, uint32_t *rcnt)\r
-{\r
- uint32_t u;\r
- uint32_t fblock;\r
- uint32_t fblock_start;\r
- uint32_t fblock_cnt;\r
- uint32_t sblock;\r
- uint32_t sblock_end;\r
- uint32_t block_size;\r
- uint8_t *u8_buf = buf;\r
- int r;\r
- struct ext4_block b;\r
- struct ext4_inode_ref ref;\r
-\r
- ext4_assert(f && f->mp);\r
-\r
- if (f->flags & O_WRONLY)\r
- return EPERM;\r
-\r
- if (!size)\r
- return EOK;\r
-\r
- EXT4_MP_LOCK(f->mp);\r
-\r
- if (rcnt)\r
- *rcnt = 0;\r
-\r
- r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(f->mp);\r
- return r;\r
- }\r
-\r
- /*Sync file size*/\r
- f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);\r
-\r
- block_size = ext4_sb_get_block_size(&f->mp->fs.sb);\r
- size = size > (f->fsize - f->fpos) ? (f->fsize - f->fpos) : size;\r
- sblock = (f->fpos) / block_size;\r
- sblock_end = (f->fpos + size) / block_size;\r
- u = (f->fpos) % block_size;\r
-\r
- if (u) {\r
-\r
- uint32_t ll = size > (block_size - u) ? (block_size - u) : size;\r
-\r
- r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- memcpy(u8_buf, b.data + u, ll);\r
-\r
- r = ext4_block_set(f->mp->fs.bdev, &b);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- u8_buf += ll;\r
- size -= ll;\r
- f->fpos += ll;\r
-\r
- if (rcnt)\r
- *rcnt += ll;\r
-\r
- sblock++;\r
- }\r
-\r
- fblock_start = 0;\r
- fblock_cnt = 0;\r
- while (size >= block_size) {\r
- while (sblock < sblock_end) {\r
- r = ext4_fs_get_inode_data_block_index(&ref, sblock,\r
- &fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- sblock++;\r
-\r
- if (!fblock_start) {\r
- fblock_start = fblock;\r
- }\r
-\r
- if ((fblock_start + fblock_cnt) != fblock)\r
- break;\r
-\r
- fblock_cnt++;\r
- }\r
-\r
- r = ext4_blocks_get_direct(f->mp->fs.bdev, u8_buf, fblock_start,\r
- fblock_cnt);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- size -= block_size * fblock_cnt;\r
- u8_buf += block_size * fblock_cnt;\r
- f->fpos += block_size * fblock_cnt;\r
-\r
- if (rcnt)\r
- *rcnt += block_size * fblock_cnt;\r
-\r
- fblock_start = fblock;\r
- fblock_cnt = 1;\r
- }\r
-\r
- if (size) {\r
- r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- memcpy(u8_buf, b.data, size);\r
-\r
- r = ext4_block_set(f->mp->fs.bdev, &b);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- f->fpos += size;\r
-\r
- if (rcnt)\r
- *rcnt += size;\r
- }\r
-\r
-Finish:\r
- ext4_fs_put_inode_ref(&ref);\r
- EXT4_MP_UNLOCK(f->mp);\r
- return r;\r
-}\r
-\r
-int ext4_fwrite(ext4_file *f, const void *buf, uint32_t size, uint32_t *wcnt)\r
-{\r
- uint32_t u;\r
- uint32_t fblock;\r
-\r
- uint32_t sblock;\r
- uint32_t sblock_end;\r
- uint32_t file_blocks;\r
- uint32_t block_size;\r
- uint32_t fblock_start;\r
- uint32_t fblock_cnt;\r
-\r
- struct ext4_block b;\r
- struct ext4_inode_ref ref;\r
- const uint8_t *u8_buf = buf;\r
- int r;\r
-\r
- ext4_assert(f && f->mp);\r
-\r
- if (f->flags & O_RDONLY)\r
- return EPERM;\r
-\r
- if (!size)\r
- return EOK;\r
-\r
- EXT4_MP_LOCK(f->mp);\r
-\r
- if (wcnt)\r
- *wcnt = 0;\r
-\r
- r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(f->mp);\r
- return r;\r
- }\r
-\r
- /*Sync file size*/\r
- f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);\r
-\r
- block_size = ext4_sb_get_block_size(&f->mp->fs.sb);\r
-\r
- sblock_end = (f->fpos + size) > f->fsize ? (f->fpos + size) : f->fsize;\r
- sblock_end /= block_size;\r
- file_blocks = (f->fsize / block_size);\r
-\r
- if (f->fsize % block_size)\r
- file_blocks++;\r
-\r
- sblock = (f->fpos) / block_size;\r
-\r
- u = (f->fpos) % block_size;\r
-\r
- if (u) {\r
- uint32_t ll = size > (block_size - u) ? (block_size - u) : size;\r
-\r
- r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- memcpy(b.data + u, u8_buf, ll);\r
- b.dirty = true;\r
-\r
- r = ext4_block_set(f->mp->fs.bdev, &b);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- u8_buf += ll;\r
- size -= ll;\r
- f->fpos += ll;\r
-\r
- if (wcnt)\r
- *wcnt += ll;\r
-\r
- sblock++;\r
- }\r
-\r
- /*Start write back cache mode.*/\r
- r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- fblock_start = 0;\r
- fblock_cnt = 0;\r
- while (size >= block_size) {\r
-\r
- while (sblock < sblock_end) {\r
- if (sblock < file_blocks) {\r
- r = ext4_fs_get_inode_data_block_index(\r
- &ref, sblock, &fblock);\r
- if (r != EOK)\r
- break;\r
- } else {\r
- r = ext4_fs_append_inode_block(&ref, &fblock,\r
- &sblock);\r
- if (r != EOK)\r
- break;\r
- }\r
-\r
- sblock++;\r
-\r
- if (!fblock_start) {\r
- fblock_start = fblock;\r
- }\r
-\r
- if ((fblock_start + fblock_cnt) != fblock)\r
- break;\r
-\r
- fblock_cnt++;\r
- }\r
-\r
- r = ext4_blocks_set_direct(f->mp->fs.bdev, u8_buf, fblock_start,\r
- fblock_cnt);\r
- if (r != EOK)\r
- break;\r
-\r
- size -= block_size * fblock_cnt;\r
- u8_buf += block_size * fblock_cnt;\r
- f->fpos += block_size * fblock_cnt;\r
-\r
- if (wcnt)\r
- *wcnt += block_size * fblock_cnt;\r
-\r
- fblock_start = fblock;\r
- fblock_cnt = 1;\r
- }\r
-\r
- /*Stop write back cache mode*/\r
- ext4_block_cache_write_back(f->mp->fs.bdev, 0);\r
-\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- if (size) {\r
- if (sblock < file_blocks) {\r
- r = ext4_fs_get_inode_data_block_index(&ref, sblock,\r
- &fblock);\r
- if (r != EOK)\r
- goto Finish;\r
- } else {\r
- r = ext4_fs_append_inode_block(&ref, &fblock, &sblock);\r
- if (r != EOK)\r
- goto Finish;\r
- }\r
-\r
- r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- memcpy(b.data, u8_buf, size);\r
- b.dirty = true;\r
-\r
- r = ext4_block_set(f->mp->fs.bdev, &b);\r
- if (r != EOK)\r
- goto Finish;\r
-\r
- f->fpos += size;\r
-\r
- if (wcnt)\r
- *wcnt += size;\r
- }\r
-\r
- if (f->fpos > f->fsize) {\r
- f->fsize = f->fpos;\r
- ext4_inode_set_size(ref.inode, f->fsize);\r
- ref.dirty = true;\r
- }\r
-\r
-Finish:\r
- ext4_fs_put_inode_ref(&ref);\r
- EXT4_MP_UNLOCK(f->mp);\r
- return r;\r
-}\r
-\r
-int ext4_fseek(ext4_file *f, uint64_t offset, uint32_t origin)\r
-{\r
- switch (origin) {\r
- case SEEK_SET:\r
- if (offset > f->fsize)\r
- return EINVAL;\r
-\r
- f->fpos = offset;\r
- return EOK;\r
- case SEEK_CUR:\r
- if ((offset + f->fpos) > f->fsize)\r
- return EINVAL;\r
-\r
- f->fpos += offset;\r
- return EOK;\r
- case SEEK_END:\r
- if (offset > f->fsize)\r
- return EINVAL;\r
-\r
- f->fpos = f->fsize - offset;\r
- return EOK;\r
- }\r
- return EINVAL;\r
-}\r
-\r
-uint64_t ext4_ftell(ext4_file *f) { return f->fpos; }\r
-\r
-uint64_t ext4_fsize(ext4_file *f) { return f->fsize; }\r
-\r
-int ext4_fchmod(ext4_file *f, uint32_t mode)\r
-{\r
- int r;\r
- uint32_t ino;\r
- struct ext4_sblock *sb;\r
- struct ext4_inode_ref inode_ref;\r
- struct ext4_mountpoint *mp = f->mp;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- ino = f->inode;\r
- r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- sb = &f->mp->fs.sb;\r
- ext4_inode_set_mode(sb, inode_ref.inode, mode);\r
- inode_ref.dirty = true;\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_fchown(ext4_file *f, uint32_t uid, uint32_t gid)\r
-{\r
- int r;\r
- uint32_t ino;\r
- struct ext4_inode_ref inode_ref;\r
- struct ext4_mountpoint *mp = f->mp;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- ino = f->inode;\r
- r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- ext4_inode_set_uid(inode_ref.inode, uid);\r
- ext4_inode_set_gid(inode_ref.inode, gid);\r
- inode_ref.dirty = true;\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_file_set_atime(ext4_file *f, uint32_t atime)\r
-{\r
- int r;\r
- uint32_t ino;\r
- struct ext4_inode_ref inode_ref;\r
- struct ext4_mountpoint *mp = f->mp;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- ino = f->inode;\r
- r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- ext4_inode_set_access_time(inode_ref.inode, atime);\r
- inode_ref.dirty = true;\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_file_set_mtime(ext4_file *f, uint32_t mtime)\r
-{\r
- int r;\r
- uint32_t ino;\r
- struct ext4_inode_ref inode_ref;\r
- struct ext4_mountpoint *mp = f->mp;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- ino = f->inode;\r
- r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- ext4_inode_set_modification_time(inode_ref.inode, mtime);\r
- inode_ref.dirty = true;\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_file_set_ctime(ext4_file *f, uint32_t ctime)\r
-{\r
- int r;\r
- uint32_t ino;\r
- struct ext4_inode_ref inode_ref;\r
- struct ext4_mountpoint *mp = f->mp;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- ino = f->inode;\r
- r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- ext4_inode_set_change_inode_time(inode_ref.inode, ctime);\r
- inode_ref.dirty = true;\r
-\r
- ext4_fs_put_inode_ref(&inode_ref);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-/*********************************DIRECTORY OPERATION************************/\r
-\r
-int ext4_dir_rm(const char *path)\r
-{\r
- int r;\r
- int len;\r
- ext4_file f;\r
-\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- struct ext4_inode_ref current;\r
- struct ext4_inode_ref child;\r
- struct ext4_directory_iterator it;\r
-\r
- uint32_t name_off;\r
- uint32_t inode_up;\r
- uint32_t inode_current;\r
- uint32_t depth = 1;\r
-\r
- bool has_children;\r
- bool is_goal;\r
- bool dir_end;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- /*Check if exist.*/\r
- r = ext4_generic_open(&f, path, "r", false, &inode_up, &name_off);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- path += name_off;\r
- len = ext4_path_check(path, &is_goal);\r
-\r
- inode_current = f.inode;\r
- dir_end = false;\r
-\r
- ext4_block_cache_write_back(mp->fs.bdev, 1);\r
-\r
- do {\r
- /*Load directory node.*/\r
- r = ext4_fs_get_inode_ref(&f.mp->fs, inode_current, ¤t);\r
- if (r != EOK) {\r
- break;\r
- }\r
-\r
- /*Initialize iterator.*/\r
- r = ext4_dir_iterator_init(&it, ¤t, 0);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(¤t);\r
- break;\r
- }\r
-\r
- while (r == EOK) {\r
-\r
- if (!it.current) {\r
- dir_end = true;\r
- break;\r
- }\r
-\r
- /*Get up directory inode when ".." entry*/\r
- if ((it.current->name_length == 2) &&\r
- ext4_is_dots(it.current->name,\r
- it.current->name_length)) {\r
- inode_up = ext4_dir_entry_ll_get_inode(it.current);\r
- }\r
-\r
- /*If directory or file entry, but not "." ".." entry*/\r
- if (!ext4_is_dots(it.current->name,\r
- it.current->name_length)) {\r
-\r
- /*Get child inode reference do unlink\r
- * directory/file.*/\r
- r = ext4_fs_get_inode_ref(&f.mp->fs,\r
- ext4_dir_entry_ll_get_inode(it.current),\r
- &child);\r
- if (r != EOK)\r
- break;\r
-\r
- /*If directory with no leaf children*/\r
- r = ext4_has_children(&has_children, &child);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- if (has_children) {\r
- /*Has directory children. Go into this\r
- * directory.*/\r
- inode_up = inode_current;\r
- inode_current = ext4_dir_entry_ll_get_inode(it.current);\r
- depth++;\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- /*No children in child directory or file. Just\r
- * unlink.*/\r
- r = ext4_unlink(f.mp, ¤t, &child,\r
- (char *)it.current->name,\r
- it.current->name_length);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- ext4_inode_set_deletion_time(child.inode,\r
- 0xFFFFFFFF);\r
- ext4_inode_set_links_count(child.inode, 0);\r
- child.dirty = true;\r
- /*Turncate*/\r
- r = ext4_fs_truncate_inode(&child, 0);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- r = ext4_fs_free_inode(&child);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- r = ext4_fs_put_inode_ref(&child);\r
- if (r != EOK)\r
- break;\r
- }\r
-\r
- r = ext4_dir_iterator_next(&it);\r
- }\r
-\r
- if (dir_end) {\r
- /*Directory iterator reached last entry*/\r
- ext4_has_children(&has_children, ¤t);\r
- if (!has_children) {\r
- inode_current = inode_up;\r
- if (depth)\r
- depth--;\r
- }\r
- /*Last unlink*/\r
- if (!depth) {\r
- /*Load parent.*/\r
- struct ext4_inode_ref parent;\r
- r = ext4_fs_get_inode_ref(&f.mp->fs, inode_up,\r
- &parent);\r
- if (r != EOK)\r
- goto End;\r
-\r
- /* In this place all directories should be\r
- * unlinked.\r
- * Last unlink from root of current directory*/\r
- r = ext4_unlink(f.mp, &parent, ¤t,\r
- (char *)path, len);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&parent);\r
- goto End;\r
- }\r
-\r
- if (ext4_inode_get_links_count(current.inode) ==\r
- 2) {\r
- ext4_inode_set_deletion_time(\r
- current.inode, 0xFFFFFFFF);\r
- ext4_inode_set_links_count(\r
- current.inode, 0);\r
- current.dirty = true;\r
- /*Turncate*/\r
- r = ext4_fs_truncate_inode(¤t, 0);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&parent);\r
- goto End;\r
- }\r
-\r
- r = ext4_fs_free_inode(¤t);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&parent);\r
- goto End;\r
- }\r
- }\r
-\r
- r = ext4_fs_put_inode_ref(&parent);\r
- if (r != EOK)\r
- goto End;\r
- }\r
- }\r
-\r
- End:\r
- ext4_dir_iterator_fini(&it);\r
- ext4_fs_put_inode_ref(¤t);\r
- dir_end = false;\r
-\r
- /*When something goes wrong. End loop.*/\r
- if (r != EOK)\r
- break;\r
-\r
- } while (depth);\r
-\r
- ext4_block_cache_write_back(mp->fs.bdev, 0);\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_dir_mk(const char *path)\r
-{\r
- int r;\r
- ext4_file f;\r
-\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
-\r
- /*Check if exist.*/\r
- r = ext4_generic_open(&f, path, "r", false, 0, 0);\r
- if (r == EOK) {\r
- /*Directory already created*/\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- /*Create new dir*/\r
- r = ext4_generic_open(&f, path, "w", false, 0, 0);\r
- if (r != EOK) {\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
- }\r
-\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_dir_open(ext4_dir *d, const char *path)\r
-{\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- int r;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- EXT4_MP_LOCK(mp);\r
- r = ext4_generic_open(&d->f, path, "r", false, 0, 0);\r
- d->next_off = 0;\r
- EXT4_MP_UNLOCK(mp);\r
- return r;\r
-}\r
-\r
-int ext4_dir_close(ext4_dir *d) { return ext4_fclose(&d->f); }\r
-\r
-const ext4_direntry *ext4_dir_entry_next(ext4_dir *d)\r
-{\r
-#define EXT4_DIR_ENTRY_OFFSET_TERM (uint64_t)(-1)\r
-\r
- int r;\r
- ext4_direntry *de = 0;\r
- struct ext4_inode_ref dir;\r
- struct ext4_directory_iterator it;\r
-\r
- EXT4_MP_LOCK(d->f.mp);\r
-\r
- if (d->next_off == EXT4_DIR_ENTRY_OFFSET_TERM)\r
- return 0;\r
-\r
- r = ext4_fs_get_inode_ref(&d->f.mp->fs, d->f.inode, &dir);\r
- if (r != EOK) {\r
- goto Finish;\r
- }\r
-\r
- r = ext4_dir_iterator_init(&it, &dir, d->next_off);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&dir);\r
- goto Finish;\r
- }\r
-\r
- memcpy(&d->de, it.current, sizeof(ext4_direntry));\r
- de = &d->de;\r
-\r
- ext4_dir_iterator_next(&it);\r
-\r
- d->next_off =\r
- it.current ? it.current_offset : EXT4_DIR_ENTRY_OFFSET_TERM;\r
-\r
- ext4_dir_iterator_fini(&it);\r
- ext4_fs_put_inode_ref(&dir);\r
-\r
-Finish:\r
- EXT4_MP_UNLOCK(d->f.mp);\r
- return de;\r
-}\r
-\r
-/**\r
- * @}\r
- */\r
+/*
+ * Copyright (c) 2013 Grzegorz Kostka (kostka.grzegorz@gmail.com)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup lwext4
+ * @{
+ */
+/**
+ * @file ext4.h
+ * @brief Ext4 high level operations (file, directory, mountpoints...)
+ */
+
+#include "ext4_config.h"
+#include "ext4_blockdev.h"
+#include "ext4_types.h"
+#include "ext4_debug.h"
+#include "ext4_errno.h"
+#include "ext4_fs.h"
+#include "ext4_dir.h"
+#include "ext4_inode.h"
+#include "ext4_super.h"
+#include "ext4_dir_idx.h"
+#include "ext4.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+/**@brief Mount point OS dependent lock*/
+#define EXT4_MP_LOCK(_m) \
+ do { \
+ if ((_m)->os_locks) \
+ (_m)->os_locks->lock(); \
+ } while (0)
+
+/**@brief Mount point OS dependent unlock*/
+#define EXT4_MP_UNLOCK(_m) \
+ do { \
+ if ((_m)->os_locks) \
+ (_m)->os_locks->unlock(); \
+ } while (0)
+
+/**@brief Mount point descriptor.*/
+struct ext4_mountpoint {
+
+ /**@brief Mount done flag.*/
+ bool mounted;
+
+ /**@brief Mount point name (@ref ext4_mount)*/
+ char name[32];
+
+ /**@brief OS dependent lock/unlock functions.*/
+ const struct ext4_lock *os_locks;
+
+ /**@brief Ext4 filesystem internals.*/
+ struct ext4_fs fs;
+
+ /**@brief Dynamic allocation cache flag.*/
+ bool cache_dynamic;
+};
+
+/**@brief Block devices descriptor.*/
+struct _ext4_devices {
+
+ /**@brief Block device name (@ref ext4_device_register)*/
+ char name[32];
+
+ /**@brief Block device handle.*/
+ struct ext4_blockdev *bd;
+
+ /**@brief Block cache handle.*/
+ struct ext4_bcache *bc;
+};
+
+/**@brief Block devices.*/
+struct _ext4_devices _bdevices[CONFIG_EXT4_BLOCKDEVS_COUNT];
+
+/**@brief Mountpoints.*/
+struct ext4_mountpoint _mp[CONFIG_EXT4_MOUNTPOINTS_COUNT];
+
+int ext4_device_register(struct ext4_blockdev *bd, struct ext4_bcache *bc,
+ const char *dev_name)
+{
+ uint32_t i;
+ ext4_assert(bd && dev_name);
+
+ for (i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {
+ if (!_bdevices[i].bd) {
+ strcpy(_bdevices[i].name, dev_name);
+ _bdevices[i].bd = bd;
+ _bdevices[i].bc = bc;
+ return EOK;
+ }
+
+ if (!strcmp(_bdevices[i].name, dev_name))
+ return EOK;
+ }
+ return ENOSPC;
+}
+
+/****************************************************************************/
+
+static bool ext4_is_dots(const uint8_t *name, size_t name_size)
+{
+ if ((name_size == 1) && (name[0] == '.'))
+ return true;
+
+ if ((name_size == 2) && (name[0] == '.') && (name[1] == '.'))
+ return true;
+
+ return false;
+}
+
+static int ext4_has_children(bool *has_children, struct ext4_inode_ref *enode)
+{
+ struct ext4_fs *fs = enode->fs;
+
+ /* Check if node is directory */
+ if (!ext4_inode_is_type(&fs->sb, enode->inode,
+ EXT4_INODE_MODE_DIRECTORY)) {
+ *has_children = false;
+ return EOK;
+ }
+
+ struct ext4_directory_iterator it;
+ int rc = ext4_dir_iterator_init(&it, enode, 0);
+ if (rc != EOK)
+ return rc;
+
+ /* Find a non-empty directory entry */
+ bool found = false;
+ while (it.current != NULL) {
+ if (ext4_dir_entry_ll_get_inode(it.current) != 0) {
+ uint16_t name_size = ext4_dir_entry_ll_get_name_length(
+ &fs->sb, it.current);
+ if (!ext4_is_dots(it.current->name, name_size)) {
+ found = true;
+ break;
+ }
+ }
+
+ rc = ext4_dir_iterator_next(&it);
+ if (rc != EOK) {
+ ext4_dir_iterator_fini(&it);
+ return rc;
+ }
+ }
+
+ rc = ext4_dir_iterator_fini(&it);
+ if (rc != EOK)
+ return rc;
+
+ *has_children = found;
+
+ return EOK;
+}
+
+static int ext4_link(struct ext4_mountpoint *mp, struct ext4_inode_ref *parent,
+ struct ext4_inode_ref *child, const char *name,
+ uint32_t name_len)
+{
+ /* Check maximum name length */
+ if (name_len > EXT4_DIRECTORY_FILENAME_LEN)
+ return EINVAL;
+
+ /* Add entry to parent directory */
+ int rc = ext4_dir_add_entry(parent, name, name_len, child);
+ if (rc != EOK)
+ return rc;
+
+ /* Fill new dir -> add '.' and '..' entries.
+ * Also newly allocated inode should have 0 link count.
+ */
+ if (ext4_inode_is_type(&mp->fs.sb, child->inode,
+ EXT4_INODE_MODE_DIRECTORY) &&
+ ext4_inode_get_links_count(child->inode) == 0) {
+ rc = ext4_dir_add_entry(child, ".", strlen("."), child);
+ if (rc != EOK) {
+ ext4_dir_remove_entry(parent, name, strlen(name));
+ return rc;
+ }
+
+ rc = ext4_dir_add_entry(child, "..", strlen(".."), parent);
+ if (rc != EOK) {
+ ext4_dir_remove_entry(parent, name, strlen(name));
+ ext4_dir_remove_entry(child, ".", strlen("."));
+ return rc;
+ }
+
+ /*New empty directory. Two links (. and ..) */
+ ext4_inode_set_links_count(child->inode, 2);
+
+#if CONFIG_DIR_INDEX_ENABLE
+ /* Initialize directory index if supported */
+ if (ext4_sb_has_feature_compatible(
+ &mp->fs.sb, EXT4_FEATURE_COMPAT_DIR_INDEX)) {
+ rc = ext4_dir_dx_init(child);
+ if (rc != EOK)
+ return rc;
+
+ ext4_inode_set_flag(child->inode,
+ EXT4_INODE_FLAG_INDEX);
+ child->dirty = true;
+ }
+#endif
+
+ ext4_fs_inode_links_count_inc(parent);
+ child->dirty = true;
+ parent->dirty = true;
+ } else {
+ if (ext4_inode_is_type(&mp->fs.sb, child->inode,
+ EXT4_INODE_MODE_DIRECTORY)) {
+ /* FIXME: SO TRICKY. */
+ int has_flag_index = ext4_inode_has_flag(
+ child->inode, EXT4_INODE_FLAG_INDEX);
+ struct ext4_directory_search_result result;
+ if (has_flag_index)
+ ext4_inode_clear_flag(child->inode,
+ EXT4_INODE_FLAG_INDEX);
+
+ rc = ext4_dir_find_entry(&result, child, "..",
+ strlen(".."));
+ if (has_flag_index)
+ ext4_inode_set_flag(child->inode,
+ EXT4_INODE_FLAG_INDEX);
+
+ if (rc != EOK)
+ return EIO;
+
+ ext4_dir_entry_ll_set_inode(result.dentry,
+ parent->index);
+ result.block.dirty = true;
+ rc = ext4_dir_destroy_result(child, &result);
+ if (rc != EOK)
+ return rc;
+
+ ext4_fs_inode_links_count_inc(parent);
+ parent->dirty = true;
+ } else {
+ ext4_fs_inode_links_count_inc(child);
+ child->dirty = true;
+ }
+ }
+
+ return rc;
+}
+
+static int ext4_unlink(struct ext4_mountpoint *mp,
+ struct ext4_inode_ref *parent,
+ struct ext4_inode_ref *child_inode_ref, const char *name,
+ uint32_t name_len)
+{
+ bool has_children;
+ int rc = ext4_has_children(&has_children, child_inode_ref);
+ if (rc != EOK)
+ return rc;
+
+ /* Cannot unlink non-empty node */
+ if (has_children)
+ return ENOTSUP;
+
+ /* Remove entry from parent directory */
+ rc = ext4_dir_remove_entry(parent, name, name_len);
+ if (rc != EOK)
+ return rc;
+
+ bool is_dir = ext4_inode_is_type(&mp->fs.sb, child_inode_ref->inode,
+ EXT4_INODE_MODE_DIRECTORY);
+
+ /* If directory - handle links from parent */
+ if (is_dir) {
+ // ext4_assert(ext4_inode_get_links_count(child_inode_ref->inode)
+ // == 1);
+ ext4_fs_inode_links_count_dec(parent);
+ parent->dirty = true;
+ }
+
+ /*
+ * TODO: Update timestamps of the parent
+ * (when we have wall-clock time).
+ *
+ * ext4_inode_set_change_inode_time(parent->inode, (uint32_t) now);
+ * ext4_inode_set_modification_time(parent->inode, (uint32_t) now);
+ * parent->dirty = true;
+ */
+
+ /*
+ * TODO: Update timestamp for inode.
+ *
+ * ext4_inode_set_change_inode_time(child_inode_ref->inode,
+ * (uint32_t) now);
+ */
+ if (ext4_inode_get_links_count(child_inode_ref->inode)) {
+ ext4_fs_inode_links_count_dec(child_inode_ref);
+ child_inode_ref->dirty = true;
+ }
+
+ return EOK;
+}
+
+/****************************************************************************/
+
+int ext4_mount(const char *dev_name, const char *mount_point)
+{
+ ext4_assert(mount_point && dev_name);
+ int r;
+ int i;
+
+ uint32_t bsize;
+ struct ext4_blockdev *bd = 0;
+ struct ext4_bcache *bc = 0;
+ struct ext4_mountpoint *mp = 0;
+
+ if (mount_point[strlen(mount_point) - 1] != '/')
+ return ENOTSUP;
+
+ for (i = 0; i < CONFIG_EXT4_BLOCKDEVS_COUNT; ++i) {
+ if (_bdevices[i].name) {
+ if (!strcmp(dev_name, _bdevices[i].name)) {
+ bd = _bdevices[i].bd;
+ bc = _bdevices[i].bc;
+ break;
+ }
+ }
+ }
+
+ if (!bd)
+ return ENODEV;
+
+ for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
+ if (!_mp[i].mounted) {
+ strcpy(_mp[i].name, mount_point);
+ _mp[i].mounted = 1;
+ mp = &_mp[i];
+ break;
+ }
+
+ if (!strcmp(_mp[i].name, mount_point))
+ return EOK;
+ }
+
+ if (!mp)
+ return ENOMEM;
+
+ r = ext4_block_init(bd);
+ if (r != EOK)
+ return r;
+
+ r = ext4_fs_init(&mp->fs, bd);
+ if (r != EOK) {
+ ext4_block_fini(bd);
+ return r;
+ }
+
+ bsize = ext4_sb_get_block_size(&mp->fs.sb);
+ ext4_block_set_lb_size(bd, bsize);
+
+ mp->cache_dynamic = 0;
+
+ if (!bc) {
+ /*Automatic block cache alloc.*/
+ mp->cache_dynamic = 1;
+ bc = malloc(sizeof(struct ext4_bcache));
+
+ r = ext4_bcache_init_dynamic(bc, CONFIG_BLOCK_DEV_CACHE_SIZE,
+ bsize);
+ if (r != EOK) {
+ free(bc);
+ ext4_block_fini(bd);
+ return r;
+ }
+ }
+
+ if (bsize != bc->itemsize)
+ return ENOTSUP;
+
+ /*Bind block cache to block device*/
+ r = ext4_block_bind_bcache(bd, bc);
+ if (r != EOK) {
+ ext4_block_fini(bd);
+ if (mp->cache_dynamic) {
+ ext4_bcache_fini_dynamic(bc);
+ free(bc);
+ }
+ return r;
+ }
+
+ return r;
+}
+
+int ext4_umount(const char *mount_point)
+{
+ int i;
+ int r;
+ struct ext4_mountpoint *mp = 0;
+
+ for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
+ if (!strcmp(_mp[i].name, mount_point)) {
+ mp = &_mp[i];
+ break;
+ }
+ }
+
+ if (!mp)
+ return ENODEV;
+
+ r = ext4_fs_fini(&mp->fs);
+ if (r != EOK)
+ return r;
+
+ mp->mounted = 0;
+
+ if (mp->cache_dynamic) {
+ ext4_bcache_fini_dynamic(mp->fs.bdev->bc);
+ free(mp->fs.bdev->bc);
+ }
+
+ return ext4_block_fini(mp->fs.bdev);
+}
+
+int ext4_mount_point_stats(const char *mount_point,
+ struct ext4_mount_stats *stats)
+{
+ uint32_t i;
+ struct ext4_mountpoint *mp = 0;
+
+ for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
+ if (!strcmp(_mp[i].name, mount_point)) {
+ mp = &_mp[i];
+ break;
+ }
+ }
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+ stats->inodes_count = ext4_get32(&mp->fs.sb, inodes_count);
+ stats->free_inodes_count = ext4_get32(&mp->fs.sb, free_inodes_count);
+ stats->blocks_count = ext4_sb_get_blocks_cnt(&mp->fs.sb);
+ stats->free_blocks_count = ext4_sb_get_free_blocks_cnt(&mp->fs.sb);
+ stats->block_size = ext4_sb_get_block_size(&mp->fs.sb);
+
+ stats->block_group_count = ext4_block_group_cnt(&mp->fs.sb);
+ stats->blocks_per_group = ext4_get32(&mp->fs.sb, blocks_per_group);
+ stats->inodes_per_group = ext4_get32(&mp->fs.sb, inodes_per_group);
+
+ memcpy(stats->volume_name, mp->fs.sb.volume_name, 16);
+ EXT4_MP_UNLOCK(mp);
+
+ return EOK;
+}
+
+int ext4_mount_setup_locks(const char *mount_point,
+ const struct ext4_lock *locks)
+{
+ uint32_t i;
+ struct ext4_mountpoint *mp = 0;
+
+ for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
+ if (!strcmp(_mp[i].name, mount_point)) {
+ mp = &_mp[i];
+ break;
+ }
+ }
+ if (!mp)
+ return ENOENT;
+
+ mp->os_locks = locks;
+ return EOK;
+}
+
+/********************************FILE OPERATIONS*****************************/
+
+static struct ext4_mountpoint *ext4_get_mount(const char *path)
+{
+ int i;
+ for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
+
+ if (!_mp[i].mounted)
+ continue;
+
+ if (!strncmp(_mp[i].name, path, strlen(_mp[i].name)))
+ return &_mp[i];
+ }
+ return 0;
+}
+
+static int ext4_path_check(const char *path, bool *is_goal)
+{
+ int i;
+
+ for (i = 0; i < EXT4_DIRECTORY_FILENAME_LEN; ++i) {
+
+ if (path[i] == '/') {
+ *is_goal = false;
+ return i;
+ }
+
+ if (path[i] == 0) {
+ *is_goal = true;
+ return i;
+ }
+ }
+
+ return 0;
+}
+
+static bool ext4_parse_flags(const char *flags, uint32_t *file_flags)
+{
+ if (!flags)
+ return false;
+
+ if (!strcmp(flags, "r") || !strcmp(flags, "rb")) {
+ *file_flags = O_RDONLY;
+ return true;
+ }
+
+ if (!strcmp(flags, "w") || !strcmp(flags, "wb")) {
+ *file_flags = O_WRONLY | O_CREAT | O_TRUNC;
+ return true;
+ }
+
+ if (!strcmp(flags, "a") || !strcmp(flags, "ab")) {
+ *file_flags = O_WRONLY | O_CREAT | O_APPEND;
+ return true;
+ }
+
+ if (!strcmp(flags, "r+") || !strcmp(flags, "rb+") ||
+ !strcmp(flags, "r+b")) {
+ *file_flags = O_RDWR;
+ return true;
+ }
+
+ if (!strcmp(flags, "w+") || !strcmp(flags, "wb+") ||
+ !strcmp(flags, "w+b")) {
+ *file_flags = O_RDWR | O_CREAT | O_TRUNC;
+ return true;
+ }
+
+ if (!strcmp(flags, "a+") || !strcmp(flags, "ab+") ||
+ !strcmp(flags, "a+b")) {
+ *file_flags = O_RDWR | O_CREAT | O_APPEND;
+ return true;
+ }
+
+ return false;
+}
+
+/*
+ * NOTICE: if filetype is equal to EXT4_DIRECTORY_FILETYPE_UNKNOWN,
+ * any filetype of the target dir entry will be accepted.
+ */
+static int ext4_generic_open2(ext4_file *f, const char *path, int flags,
+ int filetype, uint32_t *parent_inode,
+ uint32_t *name_off)
+{
+ bool is_goal = false;
+ uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;
+ uint32_t next_inode;
+
+ int r;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ struct ext4_directory_search_result result;
+ struct ext4_inode_ref ref;
+
+ f->mp = 0;
+
+ if (!mp)
+ return ENOENT;
+
+ f->flags = flags;
+
+ /*Skip mount point*/
+ path += strlen(mp->name);
+
+ if (name_off)
+ *name_off = strlen(mp->name);
+
+ /*Load root*/
+ r = ext4_fs_get_inode_ref(&mp->fs, EXT4_INODE_ROOT_INDEX, &ref);
+
+ if (r != EOK)
+ return r;
+
+ if (parent_inode)
+ *parent_inode = ref.index;
+
+ int len = ext4_path_check(path, &is_goal);
+
+ while (1) {
+
+ len = ext4_path_check(path, &is_goal);
+
+ if (!len) {
+ /*If root open was request.*/
+ if (is_goal &&
+ ((filetype == EXT4_DIRECTORY_FILETYPE_DIR) ||
+ (filetype == EXT4_DIRECTORY_FILETYPE_UNKNOWN)))
+ break;
+
+ r = ENOENT;
+ break;
+ }
+
+ r = ext4_dir_find_entry(&result, &ref, path, len);
+ if (r != EOK) {
+
+ if (r != ENOENT)
+ break;
+
+ if (!(f->flags & O_CREAT))
+ break;
+
+ /*O_CREAT allows create new entry*/
+ struct ext4_inode_ref child_ref;
+ r = ext4_fs_alloc_inode(
+ &mp->fs, &child_ref,
+ is_goal ? (filetype == EXT4_DIRECTORY_FILETYPE_DIR)
+ : true);
+ if (r != EOK)
+ break;
+
+ /*Destroy last result*/
+ ext4_dir_destroy_result(&ref, &result);
+
+ /*Link with root dir.*/
+ r = ext4_link(mp, &ref, &child_ref, path, len);
+ if (r != EOK) {
+ /*Fail. Free new inode.*/
+ ext4_fs_free_inode(&child_ref);
+ /*We do not want to write new inode.
+ But block has to be released.*/
+ child_ref.dirty = false;
+ ext4_fs_put_inode_ref(&child_ref);
+ break;
+ }
+
+ ext4_fs_put_inode_ref(&child_ref);
+
+ continue;
+ }
+
+ if (parent_inode)
+ *parent_inode = ref.index;
+
+ next_inode = ext4_dir_entry_ll_get_inode(result.dentry);
+ inode_type =
+ ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, result.dentry);
+
+ r = ext4_dir_destroy_result(&ref, &result);
+ if (r != EOK)
+ break;
+
+ /*If expected file error*/
+ if (inode_type != EXT4_DIRECTORY_FILETYPE_DIR && !is_goal) {
+ r = ENOENT;
+ break;
+ }
+ if (filetype != EXT4_DIRECTORY_FILETYPE_UNKNOWN) {
+ if ((inode_type != filetype) && is_goal) {
+ r = ENOENT;
+ break;
+ }
+ }
+
+ r = ext4_fs_put_inode_ref(&ref);
+ if (r != EOK)
+ break;
+
+ r = ext4_fs_get_inode_ref(&mp->fs, next_inode, &ref);
+ if (r != EOK)
+ break;
+
+ if (is_goal)
+ break;
+
+ path += len + 1;
+
+ if (name_off)
+ *name_off += len + 1;
+ };
+
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&ref);
+ return r;
+ }
+
+ if (is_goal) {
+
+ if ((f->flags & O_TRUNC) &&
+ (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE)) {
+
+ r = ext4_fs_truncate_inode(&ref, 0);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&ref);
+ return r;
+ }
+ }
+
+ f->mp = mp;
+ f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);
+ f->inode = ref.index;
+ f->fpos = 0;
+
+ if (f->flags & O_APPEND)
+ f->fpos = f->fsize;
+ }
+
+ r = ext4_fs_put_inode_ref(&ref);
+ return r;
+}
+
+/****************************************************************************/
+
+static int ext4_generic_open(ext4_file *f, const char *path, const char *flags,
+ bool file_expect, uint32_t *parent_inode,
+ uint32_t *name_off)
+{
+ uint32_t iflags;
+ int filetype;
+ if (ext4_parse_flags(flags, &iflags) == false)
+ return EINVAL;
+
+ if (file_expect == true)
+ filetype = EXT4_DIRECTORY_FILETYPE_REG_FILE;
+ else
+ filetype = EXT4_DIRECTORY_FILETYPE_DIR;
+
+ return ext4_generic_open2(f, path, iflags, filetype, parent_inode,
+ name_off);
+}
+
+static int __ext4_create_hardlink(const char *path,
+ struct ext4_inode_ref *child_ref)
+{
+ bool is_goal = false;
+ uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;
+ uint32_t next_inode;
+
+ int r;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ struct ext4_directory_search_result result;
+ struct ext4_inode_ref ref;
+
+ if (!mp)
+ return ENOENT;
+
+ /*Skip mount point*/
+ path += strlen(mp->name);
+
+ /*Load root*/
+ r = ext4_fs_get_inode_ref(&mp->fs, EXT4_INODE_ROOT_INDEX, &ref);
+
+ if (r != EOK)
+ return r;
+
+ int len = ext4_path_check(path, &is_goal);
+
+ while (1) {
+
+ len = ext4_path_check(path, &is_goal);
+
+ if (!len) {
+ /*If root open was request.*/
+ if (is_goal)
+ r = EINVAL;
+ else
+ r = ENOENT;
+ break;
+ }
+
+ r = ext4_dir_find_entry(&result, &ref, path, len);
+ if (r != EOK) {
+
+ if (r != ENOENT || !is_goal)
+ break;
+
+ /*Destroy last result*/
+ ext4_dir_destroy_result(&ref, &result);
+
+ /*Link with root dir.*/
+ r = ext4_link(mp, &ref, child_ref, path, len);
+ break;
+ }
+
+ next_inode = ext4_dir_entry_ll_get_inode(result.dentry);
+ inode_type =
+ ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, result.dentry);
+
+ r = ext4_dir_destroy_result(&ref, &result);
+ if (r != EOK)
+ break;
+
+ if (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE) {
+ if (is_goal)
+ r = EEXIST;
+ else
+ r = ENOENT;
+
+ break;
+ }
+
+ r = ext4_fs_put_inode_ref(&ref);
+ if (r != EOK)
+ break;
+
+ r = ext4_fs_get_inode_ref(&mp->fs, next_inode, &ref);
+ if (r != EOK)
+ break;
+
+ if (is_goal)
+ break;
+
+ path += len + 1;
+ };
+
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&ref);
+ return r;
+ }
+
+ r = ext4_fs_put_inode_ref(&ref);
+ return r;
+}
+
+static int __ext4_get_inode_ref_remove_hardlink(const char *path,
+ struct ext4_inode_ref *child)
+{
+ ext4_file f;
+ uint32_t parent_inode;
+ uint32_t name_off;
+ bool is_goal;
+ int r;
+ int len;
+ struct ext4_inode_ref parent;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ r = ext4_generic_open2(&f, path, O_RDONLY,
+ EXT4_DIRECTORY_FILETYPE_UNKNOWN, &parent_inode,
+ &name_off);
+ if (r != EOK)
+ return r;
+
+ /*Load parent*/
+ r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);
+ if (r != EOK) {
+ return r;
+ }
+
+ /*We have file to unlink. Load it.*/
+ r = ext4_fs_get_inode_ref(&mp->fs, f.inode, child);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&parent);
+ return r;
+ }
+
+ if (r != EOK)
+ goto Finish;
+
+ /*Set path*/
+ path += name_off;
+
+ len = ext4_path_check(path, &is_goal);
+
+ /*Unlink from parent*/
+ r = ext4_unlink(mp, &parent, child, path, len);
+ if (r != EOK)
+ goto Finish;
+
+Finish:
+ if (r != EOK)
+ ext4_fs_put_inode_ref(child);
+
+ ext4_fs_put_inode_ref(&parent);
+ return r;
+}
+
+int ext4_frename(const char *path, const char *new_path)
+{
+ int r;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ struct ext4_inode_ref inode_ref;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = __ext4_get_inode_ref_remove_hardlink(path, &inode_ref);
+ if (r != EOK)
+ goto Finish;
+
+ r = __ext4_create_hardlink(new_path, &inode_ref);
+ if (r != EOK)
+ r = __ext4_create_hardlink(path, &inode_ref);
+
+ ext4_fs_put_inode_ref(&inode_ref);
+
+Finish:
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+/****************************************************************************/
+
+int ext4_get_sblock(const char *mount_point, struct ext4_sblock **sb)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
+
+ if (!mp)
+ return ENOENT;
+
+ *sb = &mp->fs.sb;
+ return EOK;
+}
+
+int ext4_cache_write_back(const char *path, bool on)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+ ext4_block_cache_write_back(mp->fs.bdev, on);
+ EXT4_MP_UNLOCK(mp);
+ return EOK;
+}
+
+int ext4_fremove(const char *path)
+{
+ ext4_file f;
+ uint32_t parent_inode;
+ uint32_t name_off;
+ bool is_goal;
+ int r;
+ int len;
+ struct ext4_inode_ref child;
+ struct ext4_inode_ref parent;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+ r = ext4_generic_open(&f, path, "r", true, &parent_inode, &name_off);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ /*Load parent*/
+ r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ /*We have file to delete. Load it.*/
+ r = ext4_fs_get_inode_ref(&mp->fs, f.inode, &child);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&parent);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ /*Set path*/
+ path += name_off;
+
+ len = ext4_path_check(path, &is_goal);
+
+ /*Unlink from parent*/
+ r = ext4_unlink(mp, &parent, &child, path, len);
+ if (r != EOK)
+ goto Finish;
+
+ /*Link count is zero, the inode should be freed. */
+ if (!ext4_inode_get_links_count(child.inode)) {
+ printf("ttttt\n");
+ ext4_inode_set_deletion_time(child.inode, 0xFFFFFFFF);
+ /*Turncate*/
+ ext4_block_cache_write_back(mp->fs.bdev, 1);
+ /*Truncate may be IO heavy. Do it writeback cache mode.*/
+ r = ext4_fs_truncate_inode(&child, 0);
+ ext4_block_cache_write_back(mp->fs.bdev, 0);
+
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_fs_free_inode(&child);
+ if (r != EOK)
+ goto Finish;
+ }
+
+Finish:
+ ext4_fs_put_inode_ref(&child);
+ ext4_fs_put_inode_ref(&parent);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_fill_raw_inode(const char *mount_point, uint32_t ino,
+ struct ext4_inode *inode)
+{
+ int r;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ /*Load parent*/
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ memcpy(inode, inode_ref.inode, sizeof(struct ext4_inode));
+
+ ext4_fs_put_inode_ref(&inode_ref);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_fopen(ext4_file *f, const char *path, const char *flags)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ int r;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+ ext4_block_cache_write_back(mp->fs.bdev, 1);
+ r = ext4_generic_open(f, path, flags, true, 0, 0);
+ ext4_block_cache_write_back(mp->fs.bdev, 0);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_fopen2(ext4_file *f, const char *path, int flags, bool file_expect)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ int r;
+ int filetype;
+
+ if (!mp)
+ return ENOENT;
+
+ if (file_expect == true)
+ filetype = EXT4_DIRECTORY_FILETYPE_REG_FILE;
+ else
+ filetype = EXT4_DIRECTORY_FILETYPE_DIR;
+
+ EXT4_MP_LOCK(mp);
+ ext4_block_cache_write_back(mp->fs.bdev, 1);
+ r = ext4_generic_open2(f, path, flags, filetype, 0, 0);
+ ext4_block_cache_write_back(mp->fs.bdev, 0);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_fclose(ext4_file *f)
+{
+ ext4_assert(f && f->mp);
+
+ f->mp = 0;
+ f->flags = 0;
+ f->inode = 0;
+ f->fpos = f->fsize = 0;
+
+ return EOK;
+}
+
+int ext4_ftruncate(ext4_file *f, uint64_t size)
+{
+ struct ext4_inode_ref ref;
+ int r;
+
+ ext4_assert(f && f->mp);
+
+ if (f->flags & O_RDONLY)
+ return EPERM;
+
+ EXT4_MP_LOCK(f->mp);
+
+ r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+ }
+
+ /*Sync file size*/
+ f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);
+ if (f->fsize <= size) {
+ r = EOK;
+ goto Finish;
+ }
+
+ /*Start write back cache mode.*/
+ r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_fs_truncate_inode(&ref, size);
+ if (r != EOK)
+ goto Finish;
+
+ f->fsize = size;
+ if (f->fpos > size)
+ f->fpos = size;
+
+ /*Stop write back cache mode*/
+ ext4_block_cache_write_back(f->mp->fs.bdev, 0);
+
+ if (r != EOK)
+ goto Finish;
+
+Finish:
+ ext4_fs_put_inode_ref(&ref);
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+}
+
+int ext4_fread(ext4_file *f, void *buf, uint32_t size, uint32_t *rcnt)
+{
+ uint32_t u;
+ uint32_t fblock;
+ uint32_t fblock_start;
+ uint32_t fblock_cnt;
+ uint32_t sblock;
+ uint32_t sblock_end;
+ uint32_t block_size;
+ uint8_t *u8_buf = buf;
+ int r;
+ struct ext4_block b;
+ struct ext4_inode_ref ref;
+
+ ext4_assert(f && f->mp);
+
+ if (f->flags & O_WRONLY)
+ return EPERM;
+
+ if (!size)
+ return EOK;
+
+ EXT4_MP_LOCK(f->mp);
+
+ if (rcnt)
+ *rcnt = 0;
+
+ r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+ }
+
+ /*Sync file size*/
+ f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);
+
+ block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
+ size = size > (f->fsize - f->fpos) ? (f->fsize - f->fpos) : size;
+ sblock = (f->fpos) / block_size;
+ sblock_end = (f->fpos + size) / block_size;
+ u = (f->fpos) % block_size;
+
+ if (u) {
+
+ uint32_t ll = size > (block_size - u) ? (block_size - u) : size;
+
+ r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
+
+ memcpy(u8_buf, b.data + u, ll);
+
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+
+ u8_buf += ll;
+ size -= ll;
+ f->fpos += ll;
+
+ if (rcnt)
+ *rcnt += ll;
+
+ sblock++;
+ }
+
+ fblock_start = 0;
+ fblock_cnt = 0;
+ while (size >= block_size) {
+ while (sblock < sblock_end) {
+ r = ext4_fs_get_inode_data_block_index(&ref, sblock,
+ &fblock);
+ if (r != EOK)
+ goto Finish;
+
+ sblock++;
+
+ if (!fblock_start) {
+ fblock_start = fblock;
+ }
+
+ if ((fblock_start + fblock_cnt) != fblock)
+ break;
+
+ fblock_cnt++;
+ }
+
+ r = ext4_blocks_get_direct(f->mp->fs.bdev, u8_buf, fblock_start,
+ fblock_cnt);
+ if (r != EOK)
+ goto Finish;
+
+ size -= block_size * fblock_cnt;
+ u8_buf += block_size * fblock_cnt;
+ f->fpos += block_size * fblock_cnt;
+
+ if (rcnt)
+ *rcnt += block_size * fblock_cnt;
+
+ fblock_start = fblock;
+ fblock_cnt = 1;
+ }
+
+ if (size) {
+ r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
+
+ memcpy(u8_buf, b.data, size);
+
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+
+ f->fpos += size;
+
+ if (rcnt)
+ *rcnt += size;
+ }
+
+Finish:
+ ext4_fs_put_inode_ref(&ref);
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+}
+
+int ext4_fwrite(ext4_file *f, const void *buf, uint32_t size, uint32_t *wcnt)
+{
+ uint32_t u;
+ uint32_t fblock;
+
+ uint32_t sblock;
+ uint32_t sblock_end;
+ uint32_t file_blocks;
+ uint32_t block_size;
+ uint32_t fblock_start;
+ uint32_t fblock_cnt;
+
+ struct ext4_block b;
+ struct ext4_inode_ref ref;
+ const uint8_t *u8_buf = buf;
+ int r;
+
+ ext4_assert(f && f->mp);
+
+ if (f->flags & O_RDONLY)
+ return EPERM;
+
+ if (!size)
+ return EOK;
+
+ EXT4_MP_LOCK(f->mp);
+
+ if (wcnt)
+ *wcnt = 0;
+
+ r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+ }
+
+ /*Sync file size*/
+ f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);
+
+ block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
+
+ sblock_end = (f->fpos + size) > f->fsize ? (f->fpos + size) : f->fsize;
+ sblock_end /= block_size;
+ file_blocks = (f->fsize / block_size);
+
+ if (f->fsize % block_size)
+ file_blocks++;
+
+ sblock = (f->fpos) / block_size;
+
+ u = (f->fpos) % block_size;
+
+ if (u) {
+ uint32_t ll = size > (block_size - u) ? (block_size - u) : size;
+
+ r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
+
+ memcpy(b.data + u, u8_buf, ll);
+ b.dirty = true;
+
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+
+ u8_buf += ll;
+ size -= ll;
+ f->fpos += ll;
+
+ if (wcnt)
+ *wcnt += ll;
+
+ sblock++;
+ }
+
+ /*Start write back cache mode.*/
+ r = ext4_block_cache_write_back(f->mp->fs.bdev, 1);
+ if (r != EOK)
+ goto Finish;
+
+ fblock_start = 0;
+ fblock_cnt = 0;
+ while (size >= block_size) {
+
+ while (sblock < sblock_end) {
+ if (sblock < file_blocks) {
+ r = ext4_fs_get_inode_data_block_index(
+ &ref, sblock, &fblock);
+ if (r != EOK)
+ break;
+ } else {
+ r = ext4_fs_append_inode_block(&ref, &fblock,
+ &sblock);
+ if (r != EOK)
+ break;
+ }
+
+ sblock++;
+
+ if (!fblock_start) {
+ fblock_start = fblock;
+ }
+
+ if ((fblock_start + fblock_cnt) != fblock)
+ break;
+
+ fblock_cnt++;
+ }
+
+ r = ext4_blocks_set_direct(f->mp->fs.bdev, u8_buf, fblock_start,
+ fblock_cnt);
+ if (r != EOK)
+ break;
+
+ size -= block_size * fblock_cnt;
+ u8_buf += block_size * fblock_cnt;
+ f->fpos += block_size * fblock_cnt;
+
+ if (wcnt)
+ *wcnt += block_size * fblock_cnt;
+
+ fblock_start = fblock;
+ fblock_cnt = 1;
+ }
+
+ /*Stop write back cache mode*/
+ ext4_block_cache_write_back(f->mp->fs.bdev, 0);
+
+ if (r != EOK)
+ goto Finish;
+
+ if (size) {
+ if (sblock < file_blocks) {
+ r = ext4_fs_get_inode_data_block_index(&ref, sblock,
+ &fblock);
+ if (r != EOK)
+ goto Finish;
+ } else {
+ r = ext4_fs_append_inode_block(&ref, &fblock, &sblock);
+ if (r != EOK)
+ goto Finish;
+ }
+
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
+
+ memcpy(b.data, u8_buf, size);
+ b.dirty = true;
+
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+
+ f->fpos += size;
+
+ if (wcnt)
+ *wcnt += size;
+ }
+
+ if (f->fpos > f->fsize) {
+ f->fsize = f->fpos;
+ ext4_inode_set_size(ref.inode, f->fsize);
+ ref.dirty = true;
+ }
+
+Finish:
+ ext4_fs_put_inode_ref(&ref);
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+}
+
+int ext4_fseek(ext4_file *f, uint64_t offset, uint32_t origin)
+{
+ switch (origin) {
+ case SEEK_SET:
+ if (offset > f->fsize)
+ return EINVAL;
+
+ f->fpos = offset;
+ return EOK;
+ case SEEK_CUR:
+ if ((offset + f->fpos) > f->fsize)
+ return EINVAL;
+
+ f->fpos += offset;
+ return EOK;
+ case SEEK_END:
+ if (offset > f->fsize)
+ return EINVAL;
+
+ f->fpos = f->fsize - offset;
+ return EOK;
+ }
+ return EINVAL;
+}
+
+uint64_t ext4_ftell(ext4_file *f) { return f->fpos; }
+
+uint64_t ext4_fsize(ext4_file *f) { return f->fsize; }
+
+int ext4_fchmod(ext4_file *f, uint32_t mode)
+{
+ int r;
+ uint32_t ino;
+ struct ext4_sblock *sb;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = f->mp;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ ino = f->inode;
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ sb = &f->mp->fs.sb;
+ ext4_inode_set_mode(sb, inode_ref.inode, mode);
+ inode_ref.dirty = true;
+
+ ext4_fs_put_inode_ref(&inode_ref);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_fchown(ext4_file *f, uint32_t uid, uint32_t gid)
+{
+ int r;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = f->mp;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ ino = f->inode;
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ ext4_inode_set_uid(inode_ref.inode, uid);
+ ext4_inode_set_gid(inode_ref.inode, gid);
+ inode_ref.dirty = true;
+
+ ext4_fs_put_inode_ref(&inode_ref);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_file_set_atime(ext4_file *f, uint32_t atime)
+{
+ int r;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = f->mp;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ ino = f->inode;
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ ext4_inode_set_access_time(inode_ref.inode, atime);
+ inode_ref.dirty = true;
+
+ ext4_fs_put_inode_ref(&inode_ref);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_file_set_mtime(ext4_file *f, uint32_t mtime)
+{
+ int r;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = f->mp;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ ino = f->inode;
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ ext4_inode_set_modification_time(inode_ref.inode, mtime);
+ inode_ref.dirty = true;
+
+ ext4_fs_put_inode_ref(&inode_ref);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_file_set_ctime(ext4_file *f, uint32_t ctime)
+{
+ int r;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = f->mp;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ ino = f->inode;
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ ext4_inode_set_change_inode_time(inode_ref.inode, ctime);
+ inode_ref.dirty = true;
+
+ ext4_fs_put_inode_ref(&inode_ref);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+/*********************************DIRECTORY OPERATION************************/
+
+int ext4_dir_rm(const char *path)
+{
+ int r;
+ int len;
+ ext4_file f;
+
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ struct ext4_inode_ref current;
+ struct ext4_inode_ref child;
+ struct ext4_directory_iterator it;
+
+ uint32_t name_off;
+ uint32_t inode_up;
+ uint32_t inode_current;
+ uint32_t depth = 1;
+
+ bool has_children;
+ bool is_goal;
+ bool dir_end;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ /*Check if exist.*/
+ r = ext4_generic_open(&f, path, "r", false, &inode_up, &name_off);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ path += name_off;
+ len = ext4_path_check(path, &is_goal);
+
+ inode_current = f.inode;
+ dir_end = false;
+
+ ext4_block_cache_write_back(mp->fs.bdev, 1);
+
+ do {
+ /*Load directory node.*/
+ r = ext4_fs_get_inode_ref(&f.mp->fs, inode_current, ¤t);
+ if (r != EOK) {
+ break;
+ }
+
+ /*Initialize iterator.*/
+ r = ext4_dir_iterator_init(&it, ¤t, 0);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(¤t);
+ break;
+ }
+
+ while (r == EOK) {
+
+ if (!it.current) {
+ dir_end = true;
+ break;
+ }
+
+ /*Get up directory inode when ".." entry*/
+ if ((it.current->name_length == 2) &&
+ ext4_is_dots(it.current->name,
+ it.current->name_length)) {
+ inode_up = ext4_dir_entry_ll_get_inode(it.current);
+ }
+
+ /*If directory or file entry, but not "." ".." entry*/
+ if (!ext4_is_dots(it.current->name,
+ it.current->name_length)) {
+
+ /*Get child inode reference do unlink
+ * directory/file.*/
+ r = ext4_fs_get_inode_ref(&f.mp->fs,
+ ext4_dir_entry_ll_get_inode(it.current),
+ &child);
+ if (r != EOK)
+ break;
+
+ /*If directory with no leaf children*/
+ r = ext4_has_children(&has_children, &child);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&child);
+ break;
+ }
+
+ if (has_children) {
+ /*Has directory children. Go into this
+ * directory.*/
+ inode_up = inode_current;
+ inode_current = ext4_dir_entry_ll_get_inode(it.current);
+ depth++;
+ ext4_fs_put_inode_ref(&child);
+ break;
+ }
+
+ /*No children in child directory or file. Just
+ * unlink.*/
+ r = ext4_unlink(f.mp, ¤t, &child,
+ (char *)it.current->name,
+ it.current->name_length);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&child);
+ break;
+ }
+
+ ext4_inode_set_deletion_time(child.inode,
+ 0xFFFFFFFF);
+ ext4_inode_set_links_count(child.inode, 0);
+ child.dirty = true;
+ /*Turncate*/
+ r = ext4_fs_truncate_inode(&child, 0);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&child);
+ break;
+ }
+
+ r = ext4_fs_free_inode(&child);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&child);
+ break;
+ }
+
+ r = ext4_fs_put_inode_ref(&child);
+ if (r != EOK)
+ break;
+ }
+
+ r = ext4_dir_iterator_next(&it);
+ }
+
+ if (dir_end) {
+ /*Directory iterator reached last entry*/
+ ext4_has_children(&has_children, ¤t);
+ if (!has_children) {
+ inode_current = inode_up;
+ if (depth)
+ depth--;
+ }
+ /*Last unlink*/
+ if (!depth) {
+ /*Load parent.*/
+ struct ext4_inode_ref parent;
+ r = ext4_fs_get_inode_ref(&f.mp->fs, inode_up,
+ &parent);
+ if (r != EOK)
+ goto End;
+
+ /* In this place all directories should be
+ * unlinked.
+ * Last unlink from root of current directory*/
+ r = ext4_unlink(f.mp, &parent, ¤t,
+ (char *)path, len);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&parent);
+ goto End;
+ }
+
+ if (ext4_inode_get_links_count(current.inode) ==
+ 2) {
+ ext4_inode_set_deletion_time(
+ current.inode, 0xFFFFFFFF);
+ ext4_inode_set_links_count(
+ current.inode, 0);
+ current.dirty = true;
+ /*Turncate*/
+ r = ext4_fs_truncate_inode(¤t, 0);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&parent);
+ goto End;
+ }
+
+ r = ext4_fs_free_inode(¤t);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&parent);
+ goto End;
+ }
+ }
+
+ r = ext4_fs_put_inode_ref(&parent);
+ if (r != EOK)
+ goto End;
+ }
+ }
+
+ End:
+ ext4_dir_iterator_fini(&it);
+ ext4_fs_put_inode_ref(¤t);
+ dir_end = false;
+
+ /*When something goes wrong. End loop.*/
+ if (r != EOK)
+ break;
+
+ } while (depth);
+
+ ext4_block_cache_write_back(mp->fs.bdev, 0);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_dir_mk(const char *path)
+{
+ int r;
+ ext4_file f;
+
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ /*Check if exist.*/
+ r = ext4_generic_open(&f, path, "r", false, 0, 0);
+ if (r == EOK) {
+ /*Directory already created*/
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ /*Create new dir*/
+ r = ext4_generic_open(&f, path, "w", false, 0, 0);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_dir_open(ext4_dir *d, const char *path)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ int r;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+ r = ext4_generic_open(&d->f, path, "r", false, 0, 0);
+ d->next_off = 0;
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_dir_close(ext4_dir *d) { return ext4_fclose(&d->f); }
+
+const ext4_direntry *ext4_dir_entry_next(ext4_dir *d)
+{
+#define EXT4_DIR_ENTRY_OFFSET_TERM (uint64_t)(-1)
+
+ int r;
+ ext4_direntry *de = 0;
+ struct ext4_inode_ref dir;
+ struct ext4_directory_iterator it;
+
+ EXT4_MP_LOCK(d->f.mp);
+
+ if (d->next_off == EXT4_DIR_ENTRY_OFFSET_TERM)
+ return 0;
+
+ r = ext4_fs_get_inode_ref(&d->f.mp->fs, d->f.inode, &dir);
+ if (r != EOK) {
+ goto Finish;
+ }
+
+ r = ext4_dir_iterator_init(&it, &dir, d->next_off);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&dir);
+ goto Finish;
+ }
+
+ memcpy(&d->de, it.current, sizeof(ext4_direntry));
+ de = &d->de;
+
+ ext4_dir_iterator_next(&it);
+
+ d->next_off =
+ it.current ? it.current_offset : EXT4_DIR_ENTRY_OFFSET_TERM;
+
+ ext4_dir_iterator_fini(&it);
+ ext4_fs_put_inode_ref(&dir);
+
+Finish:
+ EXT4_MP_UNLOCK(d->f.mp);
+ return de;
+}
+
+/**
+ * @}
+ */
projects / lwext4.git / blobdiff