#include "ext4_inode.h"
#include "ext4_super.h"
#include "ext4_dir_idx.h"
+#include "ext4_xattr.h"
#include "ext4.h"
#include <stdlib.h>
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)
+ uint32_t name_len, bool rename)
{
/* Check maximum name length */
if (name_len > EXT4_DIRECTORY_FILENAME_LEN)
*/
if (ext4_inode_is_type(&mp->fs.sb, child->inode,
EXT4_INODE_MODE_DIRECTORY) &&
- ext4_inode_get_links_count(child->inode) == 0) {
+ !rename) {
rc = ext4_dir_add_entry(child, ".", strlen("."), child);
if (rc != EOK) {
ext4_dir_remove_entry(parent, name, strlen(name));
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)) {
- /* FIXME: SO TRICKY. */
- int has_flag_index = ext4_inode_has_flag(
- child->inode, EXT4_INODE_FLAG_INDEX);
- struct ext4_directory_search_result result;
- if (has_flag_index)
- ext4_inode_clear_flag(child->inode,
- EXT4_INODE_FLAG_INDEX);
-
- rc = ext4_dir_find_entry(&result, child, "..",
- strlen(".."));
- if (has_flag_index)
- ext4_inode_set_flag(child->inode,
+ EXT4_INODE_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;
- if (rc != EOK)
- return EIO;
+ } else {
+#if CONFIG_DIR_INDEX_ENABLE
+ rc = ext4_dir_dx_reset_parent_inode(child,
+ parent->index);
+ if (rc != EOK)
+ return rc;
- 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;
+#endif
+ }
ext4_fs_inode_links_count_inc(parent);
parent->dirty = true;
- } else {
+ }
+ if (!rename) {
ext4_fs_inode_links_count_inc(child);
child->dirty = true;
}
/* Cannot unlink non-empty node */
if (has_children)
- return ENOTSUP;
+ return ENOTEMPTY;
/* Remove entry from parent directory */
rc = ext4_dir_remove_entry(parent, name, name_len);
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)
{
- uint32_t i;
- struct ext4_mountpoint *mp = 0;
+ struct ext4_mountpoint *mp = ext4_get_mount(mount_point);
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
- if (!strcmp(_mp[i].name, mount_point)) {
- mp = &_mp[i];
- break;
- }
- }
if (!mp)
return ENOENT;
/********************************FILE OPERATIONS*****************************/
-static struct ext4_mountpoint *ext4_get_mount(const char *path)
-{
- int i;
- for (i = 0; i < CONFIG_EXT4_MOUNTPOINTS_COUNT; ++i) {
-
- if (!_mp[i].mounted)
- continue;
-
- if (!strncmp(_mp[i].name, path, strlen(_mp[i].name)))
- return &_mp[i];
- }
- return 0;
-}
-
static int ext4_path_check(const char *path, bool *is_goal)
{
int i;
}
/*
- * NOTICE: if filetype is equal to EXT4_DIRECTORY_FILETYPE_UNKNOWN,
+ * 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,
uint32_t *name_off)
{
bool is_goal = false;
- uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;
+ uint8_t inode_type = EXT4_DIRENTRY_UNKNOWN;
uint32_t next_inode;
int r;
if (!len) {
/*If root open was request.*/
if (is_goal &&
- ((filetype == EXT4_DIRECTORY_FILETYPE_DIR) ||
- (filetype == EXT4_DIRECTORY_FILETYPE_UNKNOWN)))
+ ((filetype == EXT4_DIRENTRY_DIR) ||
+ (filetype == EXT4_DIRENTRY_UNKNOWN)))
break;
r = ENOENT;
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;
struct ext4_inode_ref child_ref;
r = ext4_fs_alloc_inode(
&mp->fs, &child_ref,
- is_goal ? (filetype == EXT4_DIRECTORY_FILETYPE_DIR)
- : true);
+ is_goal ? filetype
+ : EXT4_DIRENTRY_DIR);
if (r != EOK)
break;
- /*Destroy last result*/
- ext4_dir_destroy_result(&ref, &result);
/*Link with root dir.*/
- r = ext4_link(mp, &ref, &child_ref, path, len);
+ r = ext4_link(mp, &ref, &child_ref, path, len, false);
if (r != EOK) {
/*Fail. Free new inode.*/
ext4_fs_free_inode(&child_ref);
break;
/*If expected file error*/
- if (inode_type != EXT4_DIRECTORY_FILETYPE_DIR && !is_goal) {
+ if (inode_type != EXT4_DIRENTRY_DIR && !is_goal) {
r = ENOENT;
break;
}
- if (filetype != EXT4_DIRECTORY_FILETYPE_UNKNOWN) {
+ if (filetype != EXT4_DIRENTRY_UNKNOWN) {
if ((inode_type != filetype) && is_goal) {
r = ENOENT;
break;
if (is_goal) {
if ((f->flags & O_TRUNC) &&
- (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE)) {
+ (inode_type == EXT4_DIRENTRY_REG_FILE)) {
r = ext4_fs_truncate_inode(&ref, 0);
if (r != EOK) {
if (f->flags & O_APPEND)
f->fpos = f->fsize;
+
}
r = ext4_fs_put_inode_ref(&ref);
return EINVAL;
if (file_expect == true)
- filetype = EXT4_DIRECTORY_FILETYPE_REG_FILE;
+ filetype = EXT4_DIRENTRY_REG_FILE;
else
- filetype = EXT4_DIRECTORY_FILETYPE_DIR;
+ 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)
+ struct ext4_inode_ref *child_ref,
+ bool rename)
{
bool is_goal = false;
- uint8_t inode_type = EXT4_DIRECTORY_FILETYPE_DIR;
+ uint8_t inode_type = EXT4_DIRENTRY_DIR;
uint32_t next_inode;
int r;
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);
-
- /*Link with root dir.*/
- r = ext4_link(mp, &ref, child_ref, path, len);
+ r = EEXIST;
break;
}
- next_inode = ext4_dir_entry_ll_get_inode(result.dentry);
+ next_inode = result.dentry->inode;
inode_type =
- ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, result.dentry);
+ ext4_dir_entry_ll_get_inode_type(&mp->fs.sb, result.dentry);
r = ext4_dir_destroy_result(&ref, &result);
if (r != EOK)
break;
- if (inode_type == EXT4_DIRECTORY_FILETYPE_REG_FILE) {
+ if (inode_type == EXT4_DIRENTRY_REG_FILE) {
if (is_goal)
r = EEXIST;
else
return r;
}
-static int __ext4_get_inode_ref_remove_hardlink(const char *path,
- struct ext4_inode_ref *child)
+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)
{
- ext4_file f;
- uint32_t parent_inode;
- uint32_t name_off;
bool is_goal;
int r;
int len;
- struct ext4_inode_ref parent;
struct ext4_mountpoint *mp = ext4_get_mount(path);
if (!mp)
return ENOENT;
- r = ext4_generic_open2(&f, path, O_RDONLY,
- EXT4_DIRECTORY_FILETYPE_UNKNOWN, &parent_inode,
- &name_off);
+ /*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)
- return r;
+ goto Finish;
- /*Load parent*/
- r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent);
- if (r != EOK) {
- return r;
+ 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;
+}
- /*We have file to unlink. Load it.*/
- r = ext4_fs_get_inode_ref(&mp->fs, f.inode, child);
- if (r != EOK) {
- ext4_fs_put_inode_ref(&parent);
- return r;
- }
+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;
- /*Set path*/
- path += name_off;
-
- len = ext4_path_check(path, &is_goal);
+ child_inode = f.inode;
+ ext4_fclose(&f);
- /*Unlink from parent*/
- r = ext4_unlink(mp, &parent, child, path, len);
+ /*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 (r != EOK)
- ext4_fs_put_inode_ref(child);
+ if (child_loaded)
+ ext4_fs_put_inode_ref(&child_ref);
- ext4_fs_put_inode_ref(&parent);
+ 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 inode_ref;
+ struct ext4_inode_ref child_ref, parent_ref;
if (!mp)
return ENOENT;
EXT4_MP_LOCK(mp);
- r = __ext4_get_inode_ref_remove_hardlink(path, &inode_ref);
+ r = ext4_generic_open2(&f, path, O_RDONLY,
+ EXT4_DIRENTRY_UNKNOWN,
+ &parent_inode, &name_off);
if (r != EOK)
goto Finish;
- r = __ext4_create_hardlink(new_path, &inode_ref);
+ child_inode = f.inode;
+ ext4_fclose(&f);
+
+ /*Load parent*/
+ r = ext4_fs_get_inode_ref(&mp->fs, parent_inode, &parent_ref);
if (r != EOK)
- r = __ext4_create_hardlink(path, &inode_ref);
+ goto Finish;
- ext4_fs_put_inode_ref(&inode_ref);
+ 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;
+
}
/****************************************************************************/
return ENOENT;
EXT4_MP_LOCK(mp);
- r = ext4_generic_open(&f, path, "r", true, &parent_inode, &name_off);
+ r = ext4_generic_open2(&f, path, O_RDWR,
+ EXT4_DIRENTRY_UNKNOWN,
+ &parent_inode, &name_off);
if (r != EOK) {
EXT4_MP_UNLOCK(mp);
return r;
/*Link count is zero, the inode should be freed. */
if (!ext4_inode_get_links_count(child.inode)) {
- printf("ttttt\n");
ext4_inode_set_deletion_time(child.inode, 0xFFFFFFFF);
/*Turncate*/
ext4_block_cache_write_back(mp->fs.bdev, 1);
return r;
}
-int ext4_fill_raw_inode(const char *mount_point, uint32_t ino,
+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(mount_point);
+ 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_fs_put_inode_ref(&inode_ref);
EXT4_MP_UNLOCK(mp);
+
+ if (ret_ino)
+ *ret_ino = ino;
+
return r;
}
return r;
}
-int ext4_fopen2(ext4_file *f, const char *path, int flags, bool file_expect)
+int ext4_fopen2(ext4_file *f, const char *path, int flags)
{
struct ext4_mountpoint *mp = ext4_get_mount(path);
int r;
if (!mp)
return ENOENT;
- if (file_expect == true)
- filetype = EXT4_DIRECTORY_FILETYPE_REG_FILE;
- else
- filetype = EXT4_DIRECTORY_FILETYPE_DIR;
+ filetype = EXT4_DIRENTRY_REG_FILE;
EXT4_MP_LOCK(mp);
ext4_block_cache_write_back(mp->fs.bdev, 1);
return EOK;
}
-int ext4_ftruncate(ext4_file *f, uint64_t size)
+static int ext4_ftruncate_no_lock(ext4_file *f, uint64_t size)
{
struct ext4_inode_ref ref;
int r;
- ext4_assert(f && f->mp);
-
- if (f->flags & O_RDONLY)
- return EPERM;
-
- EXT4_MP_LOCK(f->mp);
r = ext4_fs_get_inode_ref(&f->mp->fs, f->inode, &ref);
if (r != EOK) {
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, uint32_t size, uint32_t *rcnt)
+int ext4_fread(ext4_file *f, void *buf, size_t size, size_t *rcnt)
{
uint32_t u;
uint32_t fblock;
sblock_end = (f->fpos + size) / block_size;
u = (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 = (u + size > f->fsize)
+ ?(f->fsize - u)
+ :(size);
+ memcpy(buf, content + u, r);
+ if (rcnt)
+ *rcnt = r;
+
+ } else {
+ r = 0;
+ if (rcnt)
+ *rcnt = 0;
+
+ }
+
+ r = EOK;
+ goto Finish;
+ }
+
if (u) {
uint32_t ll = size > (block_size - u) ? (block_size - u) : size;
return r;
}
-int ext4_fwrite(ext4_file *f, const void *buf, uint32_t size, uint32_t *wcnt)
+int ext4_fwrite(ext4_file *f, const void *buf, size_t size, size_t *wcnt)
{
uint32_t u;
uint32_t fblock;
uint64_t ext4_fsize(ext4_file *f) { return f->fsize; }
-int ext4_fchmod(ext4_file *f, uint32_t mode)
+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 = f->mp;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
if (!mp)
return ENOENT;
EXT4_MP_LOCK(mp);
- ino = f->inode;
+ 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;
}
- sb = &f->mp->fs.sb;
ext4_inode_set_mode(sb, inode_ref.inode, mode);
inode_ref.dirty = true;
return r;
}
-int ext4_fchown(ext4_file *f, uint32_t uid, uint32_t gid)
+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 = f->mp;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
if (!mp)
return ENOENT;
EXT4_MP_LOCK(mp);
- ino = f->inode;
+ 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;
}
-int ext4_file_set_atime(ext4_file *f, uint32_t atime)
+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 = f->mp;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
if (!mp)
return ENOENT;
EXT4_MP_LOCK(mp);
- ino = f->inode;
+ 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;
}
-int ext4_file_set_mtime(ext4_file *f, uint32_t mtime)
+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 = f->mp;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
if (!mp)
return ENOENT;
EXT4_MP_LOCK(mp);
- ino = f->inode;
+ 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;
}
-int ext4_file_set_ctime(ext4_file *f, uint32_t ctime)
+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 = f->mp;
+ struct ext4_mountpoint *mp = ext4_get_mount(path);
if (!mp)
return ENOENT;
EXT4_MP_LOCK(mp);
- ino = f->inode;
+ 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;
}
+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, 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)) {
+ char *content = (char *)ref.inode->blocks;
+ memset(content, 0, sizeof(ref.inode->blocks));
+ memcpy(content, 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;
+
+ memset(buf, 0, sizeof(bufsize));
+
+ 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;
+}
+
/*********************************DIRECTORY OPERATION************************/
int ext4_dir_rm(const char *path)
return r;
}
-int ext4_dir_close(ext4_dir *d) { return ext4_fclose(&d->f); }
+int ext4_dir_close(ext4_dir *d)
+{
+ return ext4_fclose(&d->f);
+}
const ext4_direntry *ext4_dir_entry_next(ext4_dir *d)
{
return de;
}
+void ext4_dir_entry_rewind(ext4_dir *d)
+{
+ d->next_off = 0;
+}
+
/**
* @}
*/
projects / lwext4.git / blobdiff