-/*\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
-\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 descrpitor.*/\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 alocation 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, 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 (it.current->inode != 0) {\r
- uint16_t name_size =\r
- ext4_dir_entry_ll_get_name_length(&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
- if (ext4_inode_is_type(&mp->fs.sb, child->inode,\r
- EXT4_INODE_MODE_DIRECTORY)) {\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(&mp->fs.sb,\r
- 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, 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
- }\r
-\r
- return EOK;\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) == 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
- ext4_inode_set_deletion_time(child_inode_ref->inode, 0xFFFFFFFF);\r
- ext4_inode_set_links_count(child_inode_ref->inode, 0);\r
- child_inode_ref->dirty = true;\r
-\r
- return EOK;\r
-}\r
-\r
-/****************************************************************************/\r
-\r
-int ext4_mount(const char *dev_name, char *mount_point)\r
-{\r
- ext4_assert(mount_point && dev_name);\r
- int r = EOK;\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
-\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, 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(char *mount_point)\r
-{\r
- int i;\r
- int r = EOK;\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
-\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
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
- struct ext4_directory_search_result result;\r
- struct ext4_inode_ref ref;\r
- bool is_goal = false;\r
- uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;\r
- int r = ENOENT;\r
- uint32_t next_inode;\r
-\r
- f->mp = 0;\r
-\r
- if (!mp)\r
- return ENOENT;\r
-\r
- if (ext4_parse_flags(flags, &f->flags) == false)\r
- return EINVAL;\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 && !file_expect)\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(&mp->fs, &child_ref,\r
- is_goal ? !file_expect : 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
- /*Fali. 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 = result.dentry->inode;\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_REG_FILE) && !file_expect &&\r
- is_goal) {\r
- r = ENOENT;\r
- break;\r
- }\r
-\r
- /*If expected directory error*/\r
- if ((inode_type == EXT4_DIRECTORY_FILETYPE_DIR) && file_expect &&\r
- is_goal) {\r
- r = ENOENT;\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
- 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
-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
- int r;\r
- int len;\r
- bool is_goal;\r
- struct ext4_mountpoint *mp = ext4_get_mount(path);\r
-\r
- struct ext4_inode_ref child;\r
- struct ext4_inode_ref parent;\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
- /*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
- /*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
- r = ext4_fs_free_inode(&child);\r
- if (r != EOK)\r
- goto Finish;\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_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_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
-int ext4_fread(ext4_file *f, void *buf, uint32_t size, uint32_t *rcnt)\r
-{\r
- int r = EOK;\r
- uint32_t u;\r
- uint32_t fblock;\r
- uint32_t fblock_start;\r
- uint32_t fblock_cnt;\r
- struct ext4_block b;\r
- uint8_t *u8_buf = buf;\r
- struct ext4_inode_ref ref;\r
- uint32_t sblock;\r
- uint32_t sblock_end;\r
- uint32_t block_size;\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, &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
-\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(&ref, sblock, &fblock);\r
- if (r != EOK)\r
- break;\r
- } else {\r
- r = ext4_fs_append_inode_block(&ref, &fblock, &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, &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
-/*********************************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, it.current->name_length)) {\r
- inode_up = it.current->inode;\r
- }\r
-\r
- /*If directory or file entry, but not "." ".." entry*/\r
- if (!ext4_is_dots(it.current->name, it.current->name_length)) {\r
-\r
- /*Get child inode reference do unlink directory/file.*/\r
- r = ext4_fs_get_inode_ref(&f.mp->fs, it.current->inode, &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 tirectory.*/\r
- inode_up = inode_current;\r
- inode_current = it.current->inode;\r
- depth++;\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- /*Directory is empty. Truncate it.*/\r
- r = ext4_fs_truncate_inode(&child, 0);\r
- if (r != EOK) {\r
- ext4_fs_put_inode_ref(&child);\r
- break;\r
- }\r
-\r
- /*No children in child directory or file. Just 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
- 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, &parent);\r
- if (r != EOK)\r
- goto End;\r
-\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
- /* In this place all directories should be unlinked.\r
- * Last unlink from root of current directory*/\r
- r = ext4_unlink(f.mp, &parent, ¤t, (char *)path, len);\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 = 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
-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 = 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_xattr.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, bool rename)
+{
+ /* 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) &&
+ !rename) {
+
+#if CONFIG_DIR_INDEX_ENABLE
+ /* Initialize directory index if supported */
+ if (ext4_sb_feature_com(&mp->fs.sb, EXT4_FCOM_DIR_INDEX)) {
+ rc = ext4_dir_dx_init(child, parent);
+ if (rc != EOK)
+ return rc;
+
+ ext4_inode_set_flag(child->inode,
+ EXT4_INODE_FLAG_INDEX);
+ child->dirty = true;
+ } else
+#endif
+ {
+ 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);
+
+ ext4_fs_inode_links_count_inc(parent);
+ child->dirty = true;
+ parent->dirty = true;
+ } else {
+ /*
+ * In case we want to rename a directory,
+ * we reset the original '..' pointer.
+ */
+ if (ext4_inode_is_type(&mp->fs.sb, child->inode,
+ EXT4_INODE_MODE_DIRECTORY)) {
+ int has_flag_index =
+ ext4_inode_has_flag(child->inode,
+ EXT4_INODE_FLAG_INDEX);
+ struct ext4_directory_search_result result;
+ if (!has_flag_index) {
+ rc = ext4_dir_find_entry(&result,
+ child, "..",
+ strlen(".."));
+ 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;
+
+ } else {
+#if CONFIG_DIR_INDEX_ENABLE
+ rc = ext4_dir_dx_reset_parent_inode(child,
+ parent->index);
+ if (rc != EOK)
+ return rc;
+
+#endif
+ }
+
+ ext4_fs_inode_links_count_inc(parent);
+ parent->dirty = true;
+ }
+ if (!rename) {
+ 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 ENOTEMPTY;
+
+ /* 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);
+}
+
+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;
+}
+
+int ext4_mount_point_stats(const char *mount_point,
+ struct ext4_mount_stats *stats)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
+
+ 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 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_DIRENTRY_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_DIRENTRY_UNKNOWN;
+ 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_DIRENTRY_DIR) ||
+ (filetype == EXT4_DIRENTRY_UNKNOWN)))
+ break;
+
+ r = ENOENT;
+ break;
+ }
+
+ r = ext4_dir_find_entry(&result, &ref, path, len);
+ if (r != EOK) {
+
+ /*Destroy last result*/
+ ext4_dir_destroy_result(&ref, &result);
+
+ 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_DIRENTRY_DIR);
+ if (r != EOK)
+ break;
+
+
+ /*Link with root dir.*/
+ r = ext4_link(mp, &ref, &child_ref, path, len, false);
+ 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_DIRENTRY_DIR && !is_goal) {
+ r = ENOENT;
+ break;
+ }
+ if (filetype != EXT4_DIRENTRY_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_DIRENTRY_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_DIRENTRY_REG_FILE;
+ else
+ filetype = EXT4_DIRENTRY_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 rename)
+{
+ bool is_goal = false;
+ uint8_t inode_type = EXT4_DIRENTRY_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) {
+
+ /*Destroy last result*/
+ ext4_dir_destroy_result(&ref, &result);
+
+ if (r != ENOENT || !is_goal)
+ break;
+
+ /*Link with root dir.*/
+ r = ext4_link(mp, &ref, child_ref, path, len, rename);
+ break;
+ } else if (r == EOK && is_goal) {
+ /*Destroy last result*/
+ ext4_dir_destroy_result(&ref, &result);
+ r = EEXIST;
+ break;
+ }
+
+ next_inode = result.dentry->inode;
+ 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_DIRENTRY_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_remove_orig_reference(const char *path,
+ uint32_t name_off,
+ struct ext4_inode_ref *parent_ref,
+ struct ext4_inode_ref *child_ref)
+{
+ bool is_goal;
+ int r;
+ int len;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ /*Set path*/
+ path += name_off;
+
+ len = ext4_path_check(path, &is_goal);
+
+ /* Remove entry from parent directory */
+ r = ext4_dir_remove_entry(parent_ref, path, len);
+ if (r != EOK)
+ goto Finish;
+
+ if (ext4_inode_is_type(&mp->fs.sb, child_ref->inode,
+ EXT4_INODE_MODE_DIRECTORY)) {
+ ext4_fs_inode_links_count_dec(parent_ref);
+ parent_ref->dirty = true;
+ }
+Finish:
+ return r;
+}
+
+int ext4_flink(const char *path, const char *hardlink_path)
+{
+ int r;
+ ext4_file f;
+ uint32_t name_off;
+ bool child_loaded = false;
+ uint32_t parent_inode, child_inode;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ struct ext4_mountpoint *target_mp = ext4_get_mount(hardlink_path);
+ struct ext4_inode_ref child_ref;
+
+ if (!mp)
+ return ENOENT;
+
+ /* Will that happen? Anyway return EINVAL for such case. */
+ if (mp != target_mp)
+ return EINVAL;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDONLY,
+ EXT4_DIRENTRY_UNKNOWN,
+ &parent_inode, &name_off);
+ if (r != EOK)
+ goto Finish;
+
+ child_inode = f.inode;
+ ext4_fclose(&f);
+
+ /*We have file to unlink. Load it.*/
+ r = ext4_fs_get_inode_ref(&mp->fs, child_inode, &child_ref);
+ if (r != EOK)
+ goto Finish;
+
+ child_loaded = true;
+
+ /* Creating hardlink for directory is not allowed. */
+ if (ext4_inode_is_type(&mp->fs.sb, child_ref.inode,
+ EXT4_INODE_MODE_DIRECTORY)) {
+ r = EINVAL;
+ goto Finish;
+ }
+
+ r = __ext4_create_hardlink(hardlink_path, &child_ref, false);
+
+Finish:
+ if (child_loaded)
+ ext4_fs_put_inode_ref(&child_ref);
+
+ EXT4_MP_UNLOCK(mp);
+ return r;
+
+}
+
+int ext4_frename(const char *path, const char *new_path)
+{
+ int r;
+ ext4_file f;
+ uint32_t name_off;
+ bool parent_loaded = false, child_loaded = false;
+ uint32_t parent_inode, child_inode;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ struct ext4_inode_ref child_ref, parent_ref;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDONLY,
+ EXT4_DIRENTRY_UNKNOWN,
+ &parent_inode, &name_off);
+ if (r != EOK)
+ goto Finish;
+
+ child_inode = f.inode;
+ ext4_fclose(&f);
+
+ /*Load parent*/
+ r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent_ref);
+ if (r != EOK)
+ goto Finish;
+
+ parent_loaded = true;
+
+ /*We have file to unlink. Load it.*/
+ r = ext4_fs_get_inode_ref(&mp->fs, child_inode, &child_ref);
+ if (r != EOK)
+ goto Finish;
+
+ child_loaded = true;
+
+ r = __ext4_create_hardlink(new_path, &child_ref, true);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_remove_orig_reference(path, name_off,
+ &parent_ref, &child_ref);
+ if (r != EOK)
+ goto Finish;
+
+Finish:
+ if (parent_loaded)
+ ext4_fs_put_inode_ref(&parent_ref);
+
+ if (child_loaded)
+ ext4_fs_put_inode_ref(&child_ref);
+
+ 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_open2(&f, path, O_RDWR,
+ EXT4_DIRENTRY_UNKNOWN,
+ &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)) {
+ 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 *path,
+ uint32_t *ret_ino,
+ struct ext4_inode *inode)
+{
+ int r;
+ ext4_file f;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ uint32_t ino;
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDONLY,
+ EXT4_DIRENTRY_UNKNOWN,
+ NULL, NULL);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ ino = f.inode;
+ ext4_fclose(&f);
+
+ /*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);
+
+ if (ret_ino)
+ *ret_ino = ino;
+
+ 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)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ int r;
+ int filetype;
+
+ if (!mp)
+ return ENOENT;
+
+ filetype = EXT4_DIRENTRY_REG_FILE;
+
+ 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;
+}
+
+static int ext4_ftruncate_no_lock(ext4_file *f, uint64_t size)
+{
+ struct ext4_inode_ref ref;
+ int r;
+
+
+ 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);
+ return r;
+
+}
+
+int ext4_ftruncate(ext4_file *f, uint64_t size)
+{
+ int r;
+ ext4_assert(f && f->mp);
+
+ if (f->flags & O_RDONLY)
+ return EPERM;
+
+ EXT4_MP_LOCK(f->mp);
+
+ r = ext4_ftruncate_no_lock(f, size);
+
+ EXT4_MP_UNLOCK(f->mp);
+ return r;
+}
+
+int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
+{
+ uint32_t unaligned;
+ uint32_t iblock_idx;
+ uint32_t iblock_last;
+ uint32_t block_size;
+
+ ext4_fsblk_t fblock;
+ ext4_fsblk_t fblock_start;
+ uint32_t fblock_count;
+
+ 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;
+
+ iblock_idx = (f->fpos) / block_size;
+ iblock_last = (f->fpos + size) / block_size;
+ unaligned = (f->fpos) % block_size;
+
+ /*If the size of symlink is smaller than 60 bytes*/
+ if (ext4_inode_is_type(&f->mp->fs.sb, ref.inode, EXT4_INODE_MODE_SOFTLINK)
+ && f->fsize < sizeof(ref.inode->blocks)
+ && !ext4_inode_get_blocks_count(&f->mp->fs.sb, ref.inode)) {
+ char *content = (char *)ref.inode->blocks;
+ if (f->fpos < f->fsize) {
+ r = (unaligned + size > f->fsize)
+ ?(f->fsize - unaligned)
+ :(size);
+ memcpy(buf, content + unaligned, r);
+ if (rcnt)
+ *rcnt = r;
+
+ } else {
+ r = 0;
+ if (rcnt)
+ *rcnt = 0;
+
+ }
+
+ r = EOK;
+ goto Finish;
+ }
+
+ if (unaligned) {
+ uint32_t l = size > (block_size - unaligned) ?
+ (block_size - unaligned) : size;
+ r = ext4_fs_get_inode_data_block_index(&ref, iblock_idx, &fblock,
+ true);
+ if (r != EOK)
+ goto Finish;
+
+ /* Do we get an unwritten range? */
+ if (fblock != 0) {
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
+
+ memcpy(u8_buf, b.data + unaligned, l);
+
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+ } else {
+ /* Yes, we do. */
+ memset(u8_buf, 0, l);
+ }
+
+ u8_buf += l;
+ size -= l;
+ f->fpos += l;
+
+ if (rcnt)
+ *rcnt += l;
+
+ iblock_idx++;
+ }
+
+ fblock_start = 0;
+ fblock_count = 0;
+ while (size >= block_size) {
+ while (iblock_idx < iblock_last) {
+ r = ext4_fs_get_inode_data_block_index(&ref, iblock_idx,
+ &fblock, true);
+ if (r != EOK)
+ goto Finish;
+
+ iblock_idx++;
+
+ if (!fblock_start)
+ fblock_start = fblock;
+
+ if ((fblock_start + fblock_count) != fblock)
+ break;
+
+ fblock_count++;
+ }
+
+ r = ext4_blocks_get_direct(f->mp->fs.bdev, u8_buf, fblock_start,
+ fblock_count);
+ if (r != EOK)
+ goto Finish;
+
+ size -= block_size * fblock_count;
+ u8_buf += block_size * fblock_count;
+ f->fpos += block_size * fblock_count;
+
+ if (rcnt)
+ *rcnt += block_size * fblock_count;
+
+ fblock_start = fblock;
+ fblock_count = 1;
+ }
+
+ if (size) {
+ r = ext4_fs_get_inode_data_block_index(&ref, iblock_idx, &fblock,
+ true);
+ 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, size_t size, size_t *wcnt)
+{
+ uint32_t unaligned;
+ uint32_t iblock_idx;
+ uint32_t iblock_last;
+ uint32_t ifile_blocks;
+ uint32_t block_size;
+
+ uint32_t fblock_count;
+ ext4_fsblk_t fblock;
+ ext4_fsblk_t fblock_start;
+
+ struct ext4_block b;
+ struct ext4_inode_ref ref;
+ const uint8_t *u8_buf = buf;
+ int r, rr = EOK;
+
+ 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);
+
+ iblock_last = (f->fpos + size) / block_size;
+ iblock_idx = (f->fpos) / block_size;
+ ifile_blocks = (f->fsize + block_size - 1) / block_size;
+
+ unaligned = (f->fpos) % block_size;
+
+ if (unaligned) {
+ uint32_t l = size > (block_size - unaligned) ?
+ (block_size - unaligned) : size;
+ r = ext4_fs_init_inode_data_block_index(&ref, iblock_idx, &fblock);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_block_get(f->mp->fs.bdev, &b, fblock);
+ if (r != EOK)
+ goto Finish;
+
+ memcpy(b.data + unaligned, u8_buf, l);
+ b.dirty = true;
+
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+
+ u8_buf += l;
+ size -= l;
+ f->fpos += l;
+
+ if (wcnt)
+ *wcnt += l;
+
+ iblock_idx++;
+ }
+
+ /*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_count = 0;
+ while (size >= block_size) {
+
+ while (iblock_idx < iblock_last) {
+ if (iblock_idx < ifile_blocks) {
+ r = ext4_fs_init_inode_data_block_index(
+ &ref, iblock_idx, &fblock);
+ if (r != EOK)
+ goto Finish;
+ } else {
+ rr = ext4_fs_append_inode_block(&ref, &fblock,
+ &iblock_idx);
+ if (rr != EOK) {
+ /* Unable to append more blocks. But some
+ * block might be allocated already.
+ * */
+ break;
+ }
+ }
+
+ iblock_idx++;
+
+ if (!fblock_start) {
+ fblock_start = fblock;
+ }
+
+ if ((fblock_start + fblock_count) != fblock)
+ break;
+
+ fblock_count++;
+ }
+
+ r = ext4_blocks_set_direct(f->mp->fs.bdev, u8_buf, fblock_start,
+ fblock_count);
+ if (r != EOK)
+ break;
+
+ size -= block_size * fblock_count;
+ u8_buf += block_size * fblock_count;
+ f->fpos += block_size * fblock_count;
+
+ if (wcnt)
+ *wcnt += block_size * fblock_count;
+
+ fblock_start = fblock;
+ fblock_count = 1;
+
+ if (rr != EOK) {
+ /*ext4_fs_append_inode_block has failed and no
+ * more blocks might be written. But node size
+ * should be updated.*/
+ r = rr;
+ goto out_fsize;
+ }
+ }
+
+ /*Stop write back cache mode*/
+ ext4_block_cache_write_back(f->mp->fs.bdev, 0);
+
+ if (r != EOK)
+ goto Finish;
+
+ if (size) {
+ if (iblock_idx < ifile_blocks) {
+ r = ext4_fs_init_inode_data_block_index(&ref, iblock_idx,
+ &fblock);
+ if (r != EOK)
+ goto Finish;
+ } else {
+ r = ext4_fs_append_inode_block(&ref, &fblock, &iblock_idx);
+ if (r != EOK)
+ /*Node size sholud be updated.*/
+ goto out_fsize;
+ }
+
+ 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;
+ }
+
+out_fsize:
+ 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_chmod(const char *path, uint32_t mode)
+{
+ int r;
+ uint32_t ino;
+ ext4_file f;
+ struct ext4_sblock *sb;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+ ino = f.inode;
+ sb = &mp->fs.sb;
+ ext4_fclose(&f);
+ r = ext4_fs_get_inode_ref(&mp->fs, ino, &inode_ref);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+
+ 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_chown(const char *path, uint32_t uid, uint32_t gid)
+{
+ int r;
+ ext4_file f;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+ ino = f.inode;
+ ext4_fclose(&f);
+ 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(const char *path, uint32_t atime)
+{
+ int r;
+ ext4_file f;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+ ino = f.inode;
+ ext4_fclose(&f);
+ 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(const char *path, uint32_t mtime)
+{
+ int r;
+ ext4_file f;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+ ino = f.inode;
+ ext4_fclose(&f);
+ 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(const char *path, uint32_t ctime)
+{
+ int r;
+ ext4_file f;
+ uint32_t ino;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+
+ if (!mp)
+ return ENOENT;
+
+ EXT4_MP_LOCK(mp);
+
+ r = ext4_generic_open2(&f, path, O_RDWR, EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK) {
+ EXT4_MP_UNLOCK(mp);
+ return r;
+ }
+ ino = f.inode;
+ ext4_fclose(&f);
+ 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;
+}
+
+static int ext4_fsymlink_set(ext4_file *f, const void *buf, uint32_t size)
+{
+ struct ext4_block b;
+ struct ext4_inode_ref ref;
+ uint32_t sblock;
+ ext4_fsblk_t fblock;
+ uint32_t block_size;
+ int r;
+
+ ext4_assert(f && f->mp);
+
+ if (!size)
+ return EOK;
+
+ 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*/
+ block_size = ext4_sb_get_block_size(&f->mp->fs.sb);
+ if (size > block_size) {
+ r = EINVAL;
+ goto Finish;
+ }
+ r = ext4_ftruncate_no_lock(f, 0);
+ if (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;
+
+ /*If the size of symlink is smaller than 60 bytes*/
+ if (size < sizeof(ref.inode->blocks)) {
+ memset(ref.inode->blocks, 0, sizeof(ref.inode->blocks));
+ memcpy(ref.inode->blocks, buf, size);
+ ext4_inode_clear_flag(ref.inode, EXT4_INODE_FLAG_EXTENTS);
+ } else {
+ ext4_fs_inode_blocks_init(&f->mp->fs, &ref);
+ 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, buf, size);
+ b.dirty = true;
+ r = ext4_block_set(f->mp->fs.bdev, &b);
+ if (r != EOK)
+ goto Finish;
+ }
+
+ /*Stop write back cache mode*/
+ ext4_block_cache_write_back(f->mp->fs.bdev, 0);
+
+ if (r != EOK)
+ goto Finish;
+
+ ext4_inode_set_size(ref.inode, size);
+ ref.dirty = true;
+
+ f->fsize = size;
+ if (f->fpos > size)
+ f->fpos = size;
+
+Finish:
+ ext4_fs_put_inode_ref(&ref);
+ return r;
+}
+
+int ext4_fsymlink(const char *target, const char *path)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ int r;
+ ext4_file f;
+ int filetype;
+
+ if (!mp)
+ return ENOENT;
+
+ filetype = EXT4_DIRENTRY_SYMLINK;
+
+ EXT4_MP_LOCK(mp);
+ ext4_block_cache_write_back(mp->fs.bdev, 1);
+ r = ext4_generic_open2(&f, path, O_RDWR|O_CREAT, filetype, 0, 0);
+ if (r == EOK)
+ r = ext4_fsymlink_set(&f, target, strlen(target));
+ else
+ goto Finish;
+
+ ext4_fclose(&f);
+
+Finish:
+ ext4_block_cache_write_back(mp->fs.bdev, 0);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_readlink(const char *path, char *buf, size_t bufsize, size_t *rcnt)
+{
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ int r;
+ ext4_file f;
+ int filetype;
+
+ if (!mp)
+ return ENOENT;
+
+ if (!buf)
+ return EINVAL;
+
+ filetype = EXT4_DIRENTRY_SYMLINK;
+
+ EXT4_MP_LOCK(mp);
+ ext4_block_cache_write_back(mp->fs.bdev, 1);
+ r = ext4_generic_open2(&f, path, O_RDONLY, filetype, 0, 0);
+ if (r == EOK)
+ r = ext4_fread(&f, buf, bufsize, rcnt);
+ else
+ goto Finish;
+
+ ext4_fclose(&f);
+
+Finish:
+ ext4_block_cache_write_back(mp->fs.bdev, 0);
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_setxattr(const char *path, const char *name, size_t name_len,
+ const void *data, size_t data_size, bool replace)
+{
+ int r = EOK;
+ ext4_file f;
+ uint32_t inode;
+ uint8_t name_index;
+ const char *dissected_name = NULL;
+ size_t dissected_len = 0;
+ struct ext4_xattr_ref xattr_ref;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ if (!mp)
+ return ENOENT;
+
+ dissected_name = ext4_extract_xattr_name(name, name_len,
+ &name_index, &dissected_len);
+ if (!dissected_len)
+ return EINVAL;
+
+ EXT4_MP_LOCK(mp);
+ r = ext4_generic_open2(&f, path, O_RDWR,
+ EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK)
+ goto Finish;
+ inode = f.inode;
+ ext4_fclose(&f);
+
+ r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_fs_get_xattr_ref(&mp->fs, &inode_ref,
+ &xattr_ref);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&inode_ref);
+ goto Finish;
+ }
+
+ r = ext4_fs_set_xattr(&xattr_ref, name_index, dissected_name,
+ dissected_len, data, data_size, replace);
+
+ ext4_fs_put_xattr_ref(&xattr_ref);
+ ext4_fs_put_inode_ref(&inode_ref);
+Finish:
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+int ext4_getxattr(const char *path, const char *name, size_t name_len,
+ void *buf, size_t buf_size, size_t *data_size)
+{
+ int r = EOK;
+ ext4_file f;
+ uint32_t inode;
+ uint8_t name_index;
+ const char *dissected_name = NULL;
+ size_t dissected_len = 0;
+ struct ext4_xattr_ref xattr_ref;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ if (!mp)
+ return ENOENT;
+
+ dissected_name = ext4_extract_xattr_name(name, name_len,
+ &name_index, &dissected_len);
+ if (!dissected_len)
+ return EINVAL;
+
+ EXT4_MP_LOCK(mp);
+ r = ext4_generic_open2(&f, path, O_RDWR,
+ EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK)
+ goto Finish;
+ inode = f.inode;
+ ext4_fclose(&f);
+
+ r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_fs_get_xattr_ref(&mp->fs, &inode_ref,
+ &xattr_ref);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&inode_ref);
+ goto Finish;
+ }
+
+ r = ext4_fs_get_xattr(&xattr_ref, name_index,
+ dissected_name, dissected_len,
+ buf, buf_size, data_size);
+
+ ext4_fs_put_xattr_ref(&xattr_ref);
+ ext4_fs_put_inode_ref(&inode_ref);
+Finish:
+ EXT4_MP_UNLOCK(mp);
+ return r;
+}
+
+struct ext4_listxattr_iterator {
+ char *list;
+ char *list_ptr;
+ size_t size;
+ size_t ret_size;
+ bool list_too_small;
+ bool get_required_size;
+};
+
+static int ext4_iterate_ea_list(struct ext4_xattr_ref *ref,
+ struct ext4_xattr_item *item)
+{
+ struct ext4_listxattr_iterator *lxi;
+ lxi = ref->iter_arg;
+ if (!lxi->get_required_size) {
+ size_t prefix_len;
+ const char *prefix;
+ prefix = ext4_get_xattr_name_prefix(item->name_index,
+ &prefix_len);
+ if (lxi->ret_size +
+ prefix_len + item->name_len + 1 >
+ lxi->size) {
+
+ lxi->list_too_small = 1;
+ return EXT4_XATTR_ITERATE_STOP;
+ }
+ if (prefix) {
+ memcpy(lxi->list_ptr, prefix, prefix_len);
+ lxi->list_ptr += prefix_len;
+ lxi->ret_size += prefix_len;
+ }
+ memcpy(lxi->list_ptr, item->name, item->name_len);
+ lxi->list_ptr[item->name_len] = 0;
+ lxi->list_ptr += item->name_len + 1;
+ }
+ lxi->ret_size += item->name_len + 1;
+ return EXT4_XATTR_ITERATE_CONT;
+}
+
+int ext4_listxattr(const char *path, char *list, size_t size, size_t *ret_size)
+{
+ int r = EOK;
+ ext4_file f;
+ uint32_t inode;
+ struct ext4_xattr_ref xattr_ref;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_listxattr_iterator lxi;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ if (!mp)
+ return ENOENT;
+
+ lxi.list = list;
+ lxi.list_ptr = list;
+ lxi.size = size;
+ lxi.ret_size = 0;
+ lxi.list_too_small = false;
+ lxi.get_required_size = (!size) ? true : false;
+
+ EXT4_MP_LOCK(mp);
+ r = ext4_generic_open2(&f, path, O_RDWR,
+ EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK)
+ goto Finish;
+ inode = f.inode;
+ ext4_fclose(&f);
+
+ r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_fs_get_xattr_ref(&mp->fs, &inode_ref,
+ &xattr_ref);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&inode_ref);
+ goto Finish;
+ }
+
+ xattr_ref.iter_arg = &lxi;
+ ext4_fs_xattr_iterate(&xattr_ref, ext4_iterate_ea_list);
+ if (lxi.list_too_small)
+ r = ERANGE;
+
+ if (r == EOK) {
+ if (ret_size)
+ *ret_size = lxi.ret_size;
+
+ }
+ ext4_fs_put_xattr_ref(&xattr_ref);
+ ext4_fs_put_inode_ref(&inode_ref);
+Finish:
+ EXT4_MP_UNLOCK(mp);
+ return r;
+
+}
+
+int ext4_removexattr(const char *path, const char *name, size_t name_len)
+{
+ int r = EOK;
+ ext4_file f;
+ uint32_t inode;
+ uint8_t name_index;
+ const char *dissected_name = NULL;
+ size_t dissected_len = 0;
+ struct ext4_xattr_ref xattr_ref;
+ struct ext4_inode_ref inode_ref;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
+ if (!mp)
+ return ENOENT;
+
+ dissected_name = ext4_extract_xattr_name(name, name_len,
+ &name_index, &dissected_len);
+ if (!dissected_len)
+ return EINVAL;
+
+ EXT4_MP_LOCK(mp);
+ r = ext4_generic_open2(&f, path, O_RDWR,
+ EXT4_DIRENTRY_UNKNOWN, 0, 0);
+ if (r != EOK)
+ goto Finish;
+ inode = f.inode;
+ ext4_fclose(&f);
+
+ r = ext4_fs_get_inode_ref(&mp->fs, inode, &inode_ref);
+ if (r != EOK)
+ goto Finish;
+
+ r = ext4_fs_get_xattr_ref(&mp->fs, &inode_ref,
+ &xattr_ref);
+ if (r != EOK) {
+ ext4_fs_put_inode_ref(&inode_ref);
+ goto Finish;
+ }
+
+ r = ext4_fs_remove_xattr(&xattr_ref, name_index, dissected_name,
+ dissected_len);
+
+ ext4_fs_put_xattr_ref(&xattr_ref);
+ ext4_fs_put_inode_ref(&inode_ref);
+Finish:
+ 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) {
+ EXT4_MP_UNLOCK(d->f.mp);
+ 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;
+}
+
+void ext4_dir_entry_rewind(ext4_dir *d)
+{
+ d->next_off = 0;
+}
+
+/**
+ * @}
+ */
projects / lwext4.git / blobdiff