* @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_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
-#include <ext4.h>\r
-\r
/**@brief Mount point OS dependent lock*/\r
-#define EXT4_MP_LOCK(_m) \\r
- do { if((_m)->os_locks) (_m)->os_locks->lock(); }while(0)\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 { if((_m)->os_locks) (_m)->os_locks->unlock(); }while(0)\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
+ bool mounted;\r
\r
/**@brief Mount point name (@ref ext4_mount)*/\r
char name[32];\r
\r
/**@brief Os dependent lock/unlock functions.*/\r
- struct ext4_lock *os_locks;\r
+ const struct ext4_lock *os_locks;\r
\r
/**@brief Ext4 filesystem internals.*/\r
struct ext4_fs fs;\r
/**@brief Block devices.*/\r
struct _ext4_devices _bdevices[CONFIG_EXT4_BLOCKDEVS_COUNT];\r
\r
-\r
/**@brief Mountpoints.*/\r
struct ext4_mountpoint _mp[CONFIG_EXT4_MOUNTPOINTS_COUNT];\r
\r
-\r
int ext4_device_register(struct ext4_blockdev *bd, struct ext4_bcache *bc,\r
- const char *dev_name)\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
+ 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
+ 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
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
+ if (!ext4_inode_is_type(&fs->sb, enode->inode, EXT4_INODE_MODE_DIRECTORY)) {\r
*has_children = false;\r
return EOK;\r
}\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,\r
- it.current);\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
return EOK;\r
}\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, uint32_t name_len)\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
+ 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,\r
- child);\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("."),\r
- child);\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(".."),\r
- parent);\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_check_feature_compatible(&mp->fs.sb,\r
- EXT4_FEATURE_COMPAT_DIR_INDEX)) {\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,\r
- EXT4_INODE_FLAG_INDEX);\r
+ ext4_inode_set_flag(child->inode, EXT4_INODE_FLAG_INDEX);\r
child->dirty = true;\r
}\r
#endif\r
\r
- uint16_t parent_links =\r
- ext4_inode_get_links_count(parent->inode);\r
- parent_links++;\r
- ext4_inode_set_links_count(parent->inode, parent_links);\r
-\r
+ ext4_fs_inode_links_count_inc(parent);\r
+ child->dirty = true;\r
parent->dirty = true;\r
}\r
\r
- uint16_t child_links =\r
- ext4_inode_get_links_count(child->inode);\r
- child_links++;\r
- ext4_inode_set_links_count(child->inode, child_links);\r
-\r
- child->dirty = true;\r
-\r
return EOK;\r
}\r
\r
static int ext4_unlink(struct ext4_mountpoint *mp,\r
- struct ext4_inode_ref *parent, struct ext4_inode_ref *child_inode_ref,\r
- const char *name, uint32_t name_len)\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
return ENOTSUP;\r
\r
/* Remove entry from parent directory */\r
-\r
rc = ext4_dir_remove_entry(parent, name, name_len);\r
if (rc != EOK)\r
return rc;\r
\r
-\r
- uint32_t lnk_count =\r
- ext4_inode_get_links_count(child_inode_ref->inode);\r
- lnk_count--;\r
-\r
bool is_dir = ext4_inode_is_type(&mp->fs.sb, child_inode_ref->inode,\r
- EXT4_INODE_MODE_DIRECTORY);\r
+ EXT4_INODE_MODE_DIRECTORY);\r
\r
/* If directory - handle links from parent */\r
- if ((lnk_count <= 1) && (is_dir)) {\r
- ext4_assert(lnk_count == 1);\r
-\r
- lnk_count--;\r
-\r
- uint32_t parent_lnk_count = ext4_inode_get_links_count(\r
- parent->inode);\r
-\r
- parent_lnk_count--;\r
- ext4_inode_set_links_count(parent->inode, parent_lnk_count);\r
-\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
* ext4_inode_set_change_inode_time(child_inode_ref->inode,\r
* (uint32_t) now);\r
*/\r
-\r
- ext4_inode_set_deletion_time(child_inode_ref->inode, 1);\r
- ext4_inode_set_links_count(child_inode_ref->inode, lnk_count);\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
-int ext4_mount(const char * dev_name, char *mount_point)\r
+int ext4_mount(const char *dev_name, const char *mount_point)\r
{\r
ext4_assert(mount_point && dev_name);\r
int r = EOK;\r
struct ext4_bcache *bc = 0;\r
struct ext4_mountpoint *mp = 0;\r
\r
- if(mount_point[strlen(mount_point) - 1] != '/')\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
+ 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
- if(!bd)\r
+ if (!bd)\r
return ENODEV;\r
\r
for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {\r
- if(!_mp[i].mounted){\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
+ if (!strcmp(_mp[i].name, mount_point)) {\r
return EOK;\r
}\r
}\r
\r
- if(!mp)\r
+ if (!mp)\r
return ENOMEM;\r
\r
r = ext4_block_init(bd);\r
- if(r != EOK)\r
+ if (r != EOK)\r
return r;\r
\r
r = ext4_fs_init(&mp->fs, bd);\r
- if(r != EOK){\r
+ if (r != EOK) {\r
ext4_block_fini(bd);\r
return r;\r
}\r
\r
mp->cache_dynamic = 0;\r
\r
- if(!bc){\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
+ if (r != EOK) {\r
free(bc);\r
ext4_block_fini(bd);\r
return r;\r
}\r
}\r
\r
- if(bsize != bc->itemsize)\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
+ if (r != EOK) {\r
ext4_block_fini(bd);\r
- if(mp->cache_dynamic){\r
+ if (mp->cache_dynamic) {\r
ext4_bcache_fini_dynamic(bc);\r
free(bc);\r
}\r
return r;\r
}\r
\r
-\r
-int ext4_umount(char *mount_point)\r
+int ext4_umount(const 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
+ if (!strcmp(_mp[i].name, mount_point)) {\r
mp = &_mp[i];\r
break;\r
}\r
}\r
\r
- if(!mp)\r
+ if (!mp)\r
return ENODEV;\r
\r
r = ext4_fs_fini(&mp->fs);\r
- if(r != EOK)\r
+ if (r != EOK)\r
return r;\r
\r
mp->mounted = 0;\r
\r
- if(mp->cache_dynamic){\r
+ if (mp->cache_dynamic) {\r
ext4_bcache_fini_dynamic(mp->fs.bdev->bc);\r
free(mp->fs.bdev->bc);\r
}\r
}\r
\r
int ext4_mount_point_stats(const char *mount_point,\r
- struct ext4_mount_stats *stats)\r
+ struct ext4_mount_stats *stats)\r
{\r
uint32_t i;\r
- struct ext4_mountpoint *mp = 0;\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
+ if (!strcmp(_mp[i].name, mount_point)) {\r
mp = &_mp[i];\r
break;\r
}\r
-\r
}\r
- if(!mp)\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->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->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
+ 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
+ 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
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
+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
+ if (!_mp[i].mounted)\r
continue;\r
\r
- if(!strncmp(_mp[i].name, path, strlen(_mp[i].name)))\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
+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
+ if (path[i] == '/') {\r
*is_goal = false;\r
return i;\r
}\r
\r
- if(path[i] == 0){\r
+ if (path[i] == 0) {\r
*is_goal = true;\r
return i;\r
}\r
\r
static bool ext4_parse_flags(const char *flags, uint32_t *file_flags)\r
{\r
- if(!flags)\r
+ if (!flags)\r
return false;\r
\r
- if(!strcmp(flags, "r") || !strcmp(flags, "rb")){\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
+ 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
+ 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+") || !strcmp(flags, "r+b")){\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+") || !strcmp(flags, "w+b")){\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+") || !strcmp(flags, "a+b")){\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
/****************************************************************************/\r
\r
-static int ext4_generic_open (ext4_file *f, const char *path,\r
- const char *flags, bool file_expect, uint32_t *parent_inode, uint32_t *name_off)\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
\r
f->mp = 0;\r
\r
- if(!mp)\r
+ if (!mp)\r
return ENOENT;\r
\r
- if(ext4_parse_flags(flags, &f->flags) == false)\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
+ 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
+ if (r != EOK)\r
return r;\r
\r
- if(parent_inode)\r
+ if (parent_inode)\r
*parent_inode = ref.index;\r
\r
int len = ext4_path_check(path, &is_goal);\r
\r
- while(1){\r
+ while (1) {\r
\r
len = ext4_path_check(path, &is_goal);\r
\r
- if(!len){\r
+ if (!len) {\r
/*If root open was request.*/\r
- if(is_goal && !file_expect)\r
+ if (is_goal && !file_expect)\r
break;\r
\r
r = ENOENT;\r
}\r
\r
r = ext4_dir_find_entry(&result, &ref, path, len);\r
- if(r != EOK){\r
+ if (r != EOK) {\r
\r
- if(r != ENOENT)\r
+ if (r != ENOENT)\r
break;\r
\r
- if(!(f->flags & O_CREAT))\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, is_goal ? !file_expect : true);\r
- if(r != EOK)\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
\r
/*Link with root dir.*/\r
r = ext4_link(mp, &ref, &child_ref, path, len);\r
- if(r != EOK){\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
continue;\r
}\r
\r
- if(parent_inode)\r
+ if (parent_inode)\r
*parent_inode = ref.index;\r
\r
next_inode = result.dentry->inode;\r
- inode_type = ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, 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
+ if (r != EOK)\r
break;\r
\r
/*If expected file error*/\r
- if((inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE)\r
- && !file_expect && is_goal){\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)\r
- && file_expect && is_goal){\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
+ if (r != EOK)\r
break;\r
\r
r = ext4_fs_get_inode_ref(&mp->fs, next_inode, &ref);\r
- if(r != EOK)\r
+ if (r != EOK)\r
break;\r
\r
- if(is_goal)\r
+ if (is_goal)\r
break;\r
\r
path += len + 1;\r
\r
- if(name_off)\r
+ if (name_off)\r
*name_off += len + 1;\r
};\r
\r
- if(r != EOK){\r
+ if (r != EOK) {\r
ext4_fs_put_inode_ref(&ref);\r
return r;\r
}\r
\r
- if(is_goal){\r
+ if (is_goal) {\r
\r
- if((f->flags & O_TRUNC) &&\r
- (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE)){\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
+ if (r != EOK) {\r
ext4_fs_put_inode_ref(&ref);\r
return 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
+ f->fpos = 0;\r
\r
- if(f->flags & O_APPEND)\r
+ if (f->flags & O_APPEND)\r
f->fpos = f->fsize;\r
}\r
\r
{\r
struct ext4_mountpoint *mp = ext4_get_mount(path);\r
\r
- if(!mp)\r
+ if (!mp)\r
return ENOENT;\r
\r
EXT4_MP_LOCK(mp);\r
return EOK;\r
}\r
\r
-\r
int ext4_fremove(const char *path)\r
{\r
- ext4_file f;\r
+ ext4_file f;\r
uint32_t parent_inode;\r
uint32_t name_off;\r
int r;\r
struct ext4_inode_ref child;\r
struct ext4_inode_ref parent;\r
\r
- if(!mp)\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
+ 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
+ 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
+ if (r != EOK) {\r
ext4_fs_put_inode_ref(&parent);\r
EXT4_MP_UNLOCK(mp);\r
return r;\r
r = ext4_fs_truncate_inode(&child, 0);\r
ext4_block_cache_write_back(mp->fs.bdev, 0);\r
\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
/*Set path*/\r
\r
/*Unlink from parent.*/\r
r = ext4_unlink(mp, &parent, &child, path, len);\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
r = ext4_fs_free_inode(&child);\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
- Finish:\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
+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
+ if (!mp)\r
return ENOENT;\r
\r
EXT4_MP_LOCK(mp);\r
{\r
ext4_assert(f && f->mp);\r
\r
- f->mp = 0;\r
+ f->mp = 0;\r
f->flags = 0;\r
f->inode = 0;\r
- f->fpos = f->fsize = 0;\r
+ f->fpos = f->fsize = 0;\r
\r
return EOK;\r
}\r
\r
ext4_assert(f && f->mp);\r
\r
- if(f->flags & O_WRONLY)\r
+ if (f->flags & O_WRONLY)\r
return EPERM;\r
\r
- if(!size)\r
+ if (!size)\r
return EOK;\r
\r
EXT4_MP_LOCK(f->mp);\r
\r
- if(rcnt)\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
+ if (r != EOK) {\r
EXT4_MP_UNLOCK(f->mp);\r
return r;\r
}\r
/*Sync file size*/\r
f->fsize = ext4_inode_get_size(&f->mp->fs.sb, ref.inode);\r
\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
-\r
- if(u){\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
+ if (r != EOK)\r
goto Finish;\r
\r
r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if(r != EOK)\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
+ if (r != EOK)\r
goto Finish;\r
\r
- u8_buf += ll;\r
- size -= ll;\r
+ u8_buf += ll;\r
+ size -= ll;\r
f->fpos += ll;\r
\r
- if(rcnt)\r
+ if (rcnt)\r
*rcnt += ll;\r
\r
sblock++;\r
\r
fblock_start = 0;\r
fblock_cnt = 0;\r
- while(size >= block_size){\r
- while(sblock < sblock_end){\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
+ if (r != EOK)\r
goto Finish;\r
\r
sblock++;\r
\r
- if(!fblock_start){\r
+ if (!fblock_start) {\r
fblock_start = fblock;\r
}\r
\r
- if((fblock_start + fblock_cnt) != fblock)\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, fblock_cnt);\r
- if(r != EOK)\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
+ size -= block_size * fblock_cnt;\r
+ u8_buf += block_size * fblock_cnt;\r
f->fpos += block_size * fblock_cnt;\r
\r
- if(rcnt)\r
+ if (rcnt)\r
*rcnt += block_size * fblock_cnt;\r
\r
fblock_start = fblock;\r
fblock_cnt = 1;\r
}\r
\r
- if(size){\r
+ if (size) {\r
r = ext4_fs_get_inode_data_block_index(&ref, sblock, &fblock);\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
- memcpy(u8_buf, b.data , size);\r
+ memcpy(u8_buf, b.data, size);\r
\r
r = ext4_block_set(f->mp->fs.bdev, &b);\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
f->fpos += size;\r
\r
- if(rcnt)\r
+ if (rcnt)\r
*rcnt += size;\r
}\r
\r
- Finish:\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, void *buf, uint32_t size, uint32_t *wcnt)\r
+int ext4_fwrite(ext4_file *f, const void *buf, uint32_t size, uint32_t *wcnt)\r
{\r
- int r = EOK;\r
uint32_t u;\r
uint32_t fblock;\r
- struct ext4_block b;\r
- uint8_t *u8_buf = buf;\r
- struct ext4_inode_ref ref;\r
+\r
uint32_t sblock;\r
uint32_t sblock_end;\r
uint32_t file_blocks;\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
+ if (f->flags & O_RDONLY)\r
return EPERM;\r
\r
- if(!size)\r
+ if (!size)\r
return EOK;\r
\r
EXT4_MP_LOCK(f->mp);\r
\r
- if(wcnt)\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
+ if (r != EOK) {\r
EXT4_MP_UNLOCK(f->mp);\r
return r;\r
}\r
sblock_end /= block_size;\r
file_blocks = (f->fsize / block_size);\r
\r
- if(f->fsize % block_size)\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
-\r
- if(u){\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
+ if (r != EOK)\r
goto Finish;\r
\r
r = ext4_block_get(f->mp->fs.bdev, &b, fblock);\r
- if(r != EOK)\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
+ if (r != EOK)\r
goto Finish;\r
\r
- u8_buf += ll;\r
- size -= ll;\r
+ u8_buf += ll;\r
+ size -= ll;\r
f->fpos += ll;\r
\r
- if(wcnt)\r
+ if (wcnt)\r
*wcnt += ll;\r
\r
sblock++;\r
}\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
+ if (r != EOK)\r
goto Finish;\r
\r
fblock_start = 0;\r
fblock_cnt = 0;\r
- while(size >= block_size){\r
+ while (size >= block_size) {\r
\r
- while(sblock < sblock_end){\r
- if(sblock < file_blocks){\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
+ if (r != EOK)\r
break;\r
- }\r
- else {\r
+ } else {\r
r = ext4_fs_append_inode_block(&ref, &fblock, &sblock);\r
- if(r != EOK)\r
+ if (r != EOK)\r
break;\r
}\r
\r
sblock++;\r
\r
- if(!fblock_start){\r
+ if (!fblock_start) {\r
fblock_start = fblock;\r
}\r
\r
- if((fblock_start + fblock_cnt) != fblock)\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, fblock_cnt);\r
- if(r != EOK)\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
+ size -= block_size * fblock_cnt;\r
+ u8_buf += block_size * fblock_cnt;\r
f->fpos += block_size * fblock_cnt;\r
\r
- if(wcnt)\r
+ if (wcnt)\r
*wcnt += block_size * fblock_cnt;\r
\r
fblock_start = fblock;\r
/*Stop write back cache mode*/\r
ext4_block_cache_write_back(f->mp->fs.bdev, 0);\r
\r
- if(r != EOK)\r
+ if (r != EOK)\r
goto Finish;\r
\r
- if(size){\r
- if(sblock < file_blocks){\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
+ if (r != EOK)\r
goto Finish;\r
- }\r
- else {\r
+ } else {\r
r = ext4_fs_append_inode_block(&ref, &fblock, &sblock);\r
- if(r != EOK)\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
+ if (r != EOK)\r
goto Finish;\r
\r
- memcpy(b.data, u8_buf , size);\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
+ if (r != EOK)\r
goto Finish;\r
\r
f->fpos += size;\r
\r
- if(wcnt)\r
+ if (wcnt)\r
*wcnt += size;\r
}\r
\r
- if(f->fpos > f->fsize){\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
+Finish:\r
ext4_fs_put_inode_ref(&ref);\r
EXT4_MP_UNLOCK(f->mp);\r
return r;\r
-\r
}\r
\r
int ext4_fseek(ext4_file *f, uint64_t offset, uint32_t origin)\r
{\r
- switch(origin){\r
+ switch (origin) {\r
case SEEK_SET:\r
- if(offset > f->fsize)\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
+ 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
+ if (offset > f->fsize)\r
return EINVAL;\r
\r
f->fpos = f->fsize - offset;\r
return EOK;\r
-\r
}\r
return EINVAL;\r
}\r
\r
-uint64_t ext4_ftell (ext4_file *f)\r
-{\r
- return f->fpos;\r
-}\r
+uint64_t ext4_ftell(ext4_file *f) { return f->fpos; }\r
\r
-uint64_t ext4_fsize (ext4_file *f)\r
-{\r
- return f->fsize;\r
-}\r
+uint64_t ext4_fsize(ext4_file *f) { return f->fsize; }\r
\r
/*********************************DIRECTORY OPERATION************************/\r
\r
bool is_goal;\r
bool dir_end;\r
\r
- if(!mp)\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
+ if (r != EOK) {\r
EXT4_MP_UNLOCK(mp);\r
return r;\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
+ if (r != EOK) {\r
break;\r
}\r
\r
/*Initialize iterator.*/\r
r = ext4_dir_iterator_init(&it, ¤t, 0);\r
- if(r != EOK){\r
+ if (r != EOK) {\r
ext4_fs_put_inode_ref(¤t);\r
break;\r
}\r
\r
- while(r == EOK){\r
+ while (r == EOK) {\r
\r
- if(!it.current){\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
+ 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
+ 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
+ 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
+ if (r != EOK) {\r
ext4_fs_put_inode_ref(&child);\r
break;\r
}\r
\r
- if(has_children){\r
+ if (has_children) {\r
/*Has directory children. Go into this tirectory.*/\r
inode_up = inode_current;\r
inode_current = it.current->inode;\r
\r
/*Directory is empty. Truncate it.*/\r
r = ext4_fs_truncate_inode(&child, 0);\r
- if(r != EOK){\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, it.current->name_length);\r
- if(r != EOK){\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
+ 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
+ if (r != EOK)\r
break;\r
}\r
\r
r = ext4_dir_iterator_next(&it);\r
}\r
\r
- if(dir_end){\r
+ if (dir_end) {\r
/*Directory iterator reached last entry*/\r
ext4_has_children(&has_children, ¤t);\r
- if(!has_children){\r
+ if (!has_children) {\r
inode_current = inode_up;\r
- if(depth)\r
+ if (depth)\r
depth--;\r
}\r
/*Last unlink*/\r
- if(!depth){\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
+ if (r != EOK)\r
goto End;\r
\r
r = ext4_fs_truncate_inode(¤t, 0);\r
- if(r != EOK){\r
+ if (r != EOK) {\r
ext4_fs_put_inode_ref(&parent);\r
goto End;\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
+ 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
+ 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
+ if (r != EOK)\r
goto End;\r
}\r
}\r
\r
- End:\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
+ if (r != EOK)\r
break;\r
\r
- }while(depth);\r
+ } while (depth);\r
\r
ext4_block_cache_write_back(mp->fs.bdev, 0);\r
EXT4_MP_UNLOCK(mp);\r
\r
struct ext4_mountpoint *mp = ext4_get_mount(path);\r
\r
- if(!mp)\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
+ if (r == EOK) {\r
/*Directory already created*/\r
EXT4_MP_UNLOCK(mp);\r
return r;\r
\r
/*Create new dir*/\r
r = ext4_generic_open(&f, path, "w", false, 0, 0);\r
- if(r != EOK){\r
+ if (r != EOK) {\r
EXT4_MP_UNLOCK(mp);\r
return r;\r
}\r
return r;\r
}\r
\r
-int ext4_dir_open (ext4_dir *d, const char *path)\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
+ 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)\r
-{\r
- return ext4_fclose(&d->f);\r
-}\r
+int ext4_dir_close(ext4_dir *d) { return ext4_fclose(&d->f); }\r
\r
-ext4_direntry* ext4_dir_entry_get(ext4_dir *d, uint32_t id)\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
- uint32_t i;\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
+ if (r != EOK) {\r
goto Finish;\r
}\r
\r
- r = ext4_dir_iterator_init(&it, &dir, 0);\r
- if(r != EOK){\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
- i = 0;\r
- while(r == EOK){\r
-\r
- if(!it.current)\r
- break;\r
+ memcpy(&d->de, it.current, sizeof(ext4_direntry));\r
+ de = &d->de;\r
\r
- if(i == id){\r
- memcpy(&d->de, it.current, sizeof(ext4_direntry));\r
- de = &d->de;\r
- break;\r
- }\r
+ ext4_dir_iterator_next(&it);\r
\r
- i++;\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
+Finish:\r
EXT4_MP_UNLOCK(d->f.mp);\r
return de;\r
}\r
projects / lwext4.git / blobdiff