fs/f2fs/data.c | 5 +++++ fs/f2fs/extent_cache.c | 10 ++++++++++ fs/f2fs/f2fs.h | 5 +++++ fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++---- fs/f2fs/inode.c | 10 ++++++++-- fs/f2fs/sysfs.c | 2 ++ 6 files changed, 62 insertions(+), 6 deletions(-)
From: Daeho Jeong <daehojeong@google.com>
F2FS should understand how the device aliasing file works and support
deleting the file after use. A device aliasing file can be created by
mkfs.f2fs tool and it can map the whole device with an extrent, not
using node blocks. The file space should be pinned and normally used for
read-only usages.
Signed-off-by: Daeho Jeong <daehojeong@google.com>
---
fs/f2fs/data.c | 5 +++++
fs/f2fs/extent_cache.c | 10 ++++++++++
fs/f2fs/f2fs.h | 5 +++++
fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++----
fs/f2fs/inode.c | 10 ++++++++--
fs/f2fs/sysfs.c | 2 ++
6 files changed, 62 insertions(+), 6 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 6457e5bca9c9..9ce92093ba1e 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -3423,6 +3423,11 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
if (!f2fs_lookup_read_extent_cache_block(inode, index,
&dn.data_blkaddr)) {
+ if (IS_DEVICE_ALIASING(inode)) {
+ err = -ENODATA;
+ goto out;
+ }
+
if (locked) {
err = f2fs_reserve_block(&dn, index);
goto out;
diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
index fd1fc06359ee..03883963b991 100644
--- a/fs/f2fs/extent_cache.c
+++ b/fs/f2fs/extent_cache.c
@@ -401,6 +401,11 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage)
if (atomic_read(&et->node_cnt) || !ei.len)
goto skip;
+ if (IS_DEVICE_ALIASING(inode)) {
+ et->largest = ei;
+ goto skip;
+ }
+
en = __attach_extent_node(sbi, et, &ei, NULL,
&et->root.rb_root.rb_node, true);
if (en) {
@@ -463,6 +468,11 @@ static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
goto out;
}
+ if (IS_DEVICE_ALIASING(inode)) {
+ ret = false;
+ goto out;
+ }
+
en = __lookup_extent_node(&et->root, et->cached_en, pgofs);
if (!en)
goto out;
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index ac19c61f0c3e..59179b9b3a83 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -208,6 +208,7 @@ struct f2fs_mount_info {
#define F2FS_FEATURE_CASEFOLD 0x00001000
#define F2FS_FEATURE_COMPRESSION 0x00002000
#define F2FS_FEATURE_RO 0x00004000
+#define F2FS_FEATURE_DEVICE_ALIAS 0x00008000
#define __F2FS_HAS_FEATURE(raw_super, mask) \
((raw_super->feature & cpu_to_le32(mask)) != 0)
@@ -3001,6 +3002,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
#define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
#define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
#define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
+#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */
#define F2FS_QUOTA_DEFAULT_FL (F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL)
@@ -3016,6 +3018,8 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
/* Flags that are appropriate for non-directories/regular files. */
#define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
+#define IS_DEVICE_ALIASING(inode) (F2FS_I(inode)->i_flags & F2FS_DEVICE_ALIAS_FL)
+
static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
{
if (S_ISDIR(mode))
@@ -4478,6 +4482,7 @@ F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
F2FS_FEATURE_FUNCS(compression, COMPRESSION);
F2FS_FEATURE_FUNCS(readonly, RO);
+F2FS_FEATURE_FUNCS(device_alias, DEVICE_ALIAS);
#ifdef CONFIG_BLK_DEV_ZONED
static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 168f08507004..0f4af6b303ff 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -727,6 +727,11 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
trace_f2fs_truncate_blocks_enter(inode, from);
+ if (IS_DEVICE_ALIASING(inode) && from) {
+ err = -EINVAL;
+ goto out_err;
+ }
+
free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
if (free_from >= max_file_blocks(inode))
@@ -741,6 +746,21 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
goto out;
}
+ if (IS_DEVICE_ALIASING(inode)) {
+ struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
+ struct extent_info ei = et->largest;
+ unsigned int i;
+
+ for (i = 0; i < ei.len; i++)
+ f2fs_invalidate_blocks(sbi, ei.blk + i);
+
+ dec_valid_block_count(sbi, inode, ei.len);
+ f2fs_update_time(sbi, REQ_TIME);
+
+ f2fs_put_page(ipage, 1);
+ goto out;
+ }
+
if (f2fs_has_inline_data(inode)) {
f2fs_truncate_inline_inode(inode, ipage, from);
f2fs_put_page(ipage, 1);
@@ -776,7 +796,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
/* lastly zero out the first data page */
if (!err)
err = truncate_partial_data_page(inode, from, truncate_page);
-
+out_err:
trace_f2fs_truncate_blocks_exit(inode, err);
return err;
}
@@ -994,7 +1014,8 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
return -EPERM;
if ((attr->ia_valid & ATTR_SIZE)) {
- if (!f2fs_is_compress_backend_ready(inode))
+ if (!f2fs_is_compress_backend_ready(inode) ||
+ IS_DEVICE_ALIASING(inode))
return -EOPNOTSUPP;
if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
!IS_ALIGNED(attr->ia_size,
@@ -1855,7 +1876,7 @@ static long f2fs_fallocate(struct file *file, int mode,
return -EIO;
if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
return -ENOSPC;
- if (!f2fs_is_compress_backend_ready(inode))
+ if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
return -EOPNOTSUPP;
/* f2fs only support ->fallocate for regular file */
@@ -3264,6 +3285,9 @@ int f2fs_pin_file_control(struct inode *inode, bool inc)
struct f2fs_inode_info *fi = F2FS_I(inode);
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+ if (IS_DEVICE_ALIASING(inode))
+ return -EINVAL;
+
if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
__func__, inode->i_ino, fi->i_gc_failures);
@@ -3294,6 +3318,9 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
if (f2fs_readonly(sbi->sb))
return -EROFS;
+ if (!pin && IS_DEVICE_ALIASING(inode))
+ return -EOPNOTSUPP;
+
ret = mnt_want_write_file(filp);
if (ret)
return ret;
@@ -4711,7 +4738,8 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
else
return 0;
- map.m_may_create = true;
+ if (!IS_DEVICE_ALIASING(inode))
+ map.m_may_create = true;
if (dio) {
map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
inode->i_write_hint);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index aef57172014f..f118e955ba88 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -367,6 +367,12 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
return false;
}
+ if ((fi->i_flags & F2FS_DEVICE_ALIAS_FL) && !f2fs_sb_has_device_alias(sbi)) {
+ f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
+ __func__, inode->i_ino);
+ return false;
+ }
+
return true;
}
@@ -818,8 +824,6 @@ void f2fs_evict_inode(struct inode *inode)
f2fs_bug_on(sbi, get_dirty_pages(inode));
f2fs_remove_dirty_inode(inode);
- f2fs_destroy_extent_tree(inode);
-
if (inode->i_nlink || is_bad_inode(inode))
goto no_delete;
@@ -874,6 +878,8 @@ void f2fs_evict_inode(struct inode *inode)
goto retry;
}
+ f2fs_destroy_extent_tree(inode);
+
if (err) {
f2fs_update_inode_page(inode);
if (dquot_initialize_needed(inode))
diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
index fee7ee45ceaa..bf64f4cc3522 100644
--- a/fs/f2fs/sysfs.c
+++ b/fs/f2fs/sysfs.c
@@ -1281,6 +1281,7 @@ F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
+F2FS_SB_FEATURE_RO_ATTR(device_alias, DEVICE_ALIAS);
static struct attribute *f2fs_sb_feat_attrs[] = {
ATTR_LIST(sb_encryption),
@@ -1297,6 +1298,7 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
ATTR_LIST(sb_casefold),
ATTR_LIST(sb_compression),
ATTR_LIST(sb_readonly),
+ ATTR_LIST(sb_device_alias),
NULL,
};
ATTRIBUTE_GROUPS(f2fs_sb_feat);
--
2.46.0.662.g92d0881bb0-googOn 2024/9/14 5:28, Daeho Jeong wrote:
> From: Daeho Jeong <daehojeong@google.com>
>
> F2FS should understand how the device aliasing file works and support
> deleting the file after use. A device aliasing file can be created by
> mkfs.f2fs tool and it can map the whole device with an extrent, not
> using node blocks. The file space should be pinned and normally used for
> read-only usages.
>
> Signed-off-by: Daeho Jeong <daehojeong@google.com>
> ---
> fs/f2fs/data.c | 5 +++++
> fs/f2fs/extent_cache.c | 10 ++++++++++
> fs/f2fs/f2fs.h | 5 +++++
> fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++----
> fs/f2fs/inode.c | 10 ++++++++--
> fs/f2fs/sysfs.c | 2 ++
> 6 files changed, 62 insertions(+), 6 deletions(-)
>
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 6457e5bca9c9..9ce92093ba1e 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -3423,6 +3423,11 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
>
> if (!f2fs_lookup_read_extent_cache_block(inode, index,
> &dn.data_blkaddr)) {
> + if (IS_DEVICE_ALIASING(inode)) {
> + err = -ENODATA;
> + goto out;
> + }
> +
> if (locked) {
> err = f2fs_reserve_block(&dn, index);
> goto out;
> diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
> index fd1fc06359ee..03883963b991 100644
> --- a/fs/f2fs/extent_cache.c
> +++ b/fs/f2fs/extent_cache.c
> @@ -401,6 +401,11 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage)
> if (atomic_read(&et->node_cnt) || !ei.len)
> goto skip;
>
> + if (IS_DEVICE_ALIASING(inode)) {
> + et->largest = ei;
> + goto skip;
> + }
> +
> en = __attach_extent_node(sbi, et, &ei, NULL,
> &et->root.rb_root.rb_node, true);
> if (en) {
> @@ -463,6 +468,11 @@ static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
> goto out;
> }
>
> + if (IS_DEVICE_ALIASING(inode)) {
> + ret = false;
> + goto out;
> + }
> +
> en = __lookup_extent_node(&et->root, et->cached_en, pgofs);
> if (!en)
> goto out;
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index ac19c61f0c3e..59179b9b3a83 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -208,6 +208,7 @@ struct f2fs_mount_info {
> #define F2FS_FEATURE_CASEFOLD 0x00001000
> #define F2FS_FEATURE_COMPRESSION 0x00002000
> #define F2FS_FEATURE_RO 0x00004000
> +#define F2FS_FEATURE_DEVICE_ALIAS 0x00008000
>
> #define __F2FS_HAS_FEATURE(raw_super, mask) \
> ((raw_super->feature & cpu_to_le32(mask)) != 0)
> @@ -3001,6 +3002,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> #define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
> #define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
> #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
> +#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */
>
> #define F2FS_QUOTA_DEFAULT_FL (F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL)
>
> @@ -3016,6 +3018,8 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> /* Flags that are appropriate for non-directories/regular files. */
> #define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
>
> +#define IS_DEVICE_ALIASING(inode) (F2FS_I(inode)->i_flags & F2FS_DEVICE_ALIAS_FL)
> +
> static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
> {
> if (S_ISDIR(mode))
> @@ -4478,6 +4482,7 @@ F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
> F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
> F2FS_FEATURE_FUNCS(compression, COMPRESSION);
> F2FS_FEATURE_FUNCS(readonly, RO);
> +F2FS_FEATURE_FUNCS(device_alias, DEVICE_ALIAS);
>
> #ifdef CONFIG_BLK_DEV_ZONED
> static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index 168f08507004..0f4af6b303ff 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -727,6 +727,11 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>
> trace_f2fs_truncate_blocks_enter(inode, from);
>
> + if (IS_DEVICE_ALIASING(inode) && from) {
> + err = -EINVAL;
> + goto out_err;
> + }
> +
> free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
>
> if (free_from >= max_file_blocks(inode))
> @@ -741,6 +746,21 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> goto out;
> }
>
> + if (IS_DEVICE_ALIASING(inode)) {
> + struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
> + struct extent_info ei = et->largest;
> + unsigned int i;
> +
> + for (i = 0; i < ei.len; i++)
> + f2fs_invalidate_blocks(sbi, ei.blk + i);
> +
> + dec_valid_block_count(sbi, inode, ei.len);
> + f2fs_update_time(sbi, REQ_TIME);
> +
> + f2fs_put_page(ipage, 1);
> + goto out;
> + }
> +
> if (f2fs_has_inline_data(inode)) {
> f2fs_truncate_inline_inode(inode, ipage, from);
> f2fs_put_page(ipage, 1);
> @@ -776,7 +796,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> /* lastly zero out the first data page */
> if (!err)
> err = truncate_partial_data_page(inode, from, truncate_page);
> -
> +out_err:
> trace_f2fs_truncate_blocks_exit(inode, err);
> return err;
> }
> @@ -994,7 +1014,8 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
> return -EPERM;
>
> if ((attr->ia_valid & ATTR_SIZE)) {
> - if (!f2fs_is_compress_backend_ready(inode))
> + if (!f2fs_is_compress_backend_ready(inode) ||
> + IS_DEVICE_ALIASING(inode))
> return -EOPNOTSUPP;
> if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
> !IS_ALIGNED(attr->ia_size,
> @@ -1855,7 +1876,7 @@ static long f2fs_fallocate(struct file *file, int mode,
> return -EIO;
> if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
> return -ENOSPC;
> - if (!f2fs_is_compress_backend_ready(inode))
> + if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
> return -EOPNOTSUPP;
>
> /* f2fs only support ->fallocate for regular file */
> @@ -3264,6 +3285,9 @@ int f2fs_pin_file_control(struct inode *inode, bool inc)
> struct f2fs_inode_info *fi = F2FS_I(inode);
> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>
> + if (IS_DEVICE_ALIASING(inode))
> + return -EINVAL;
> +
> if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
> f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
> __func__, inode->i_ino, fi->i_gc_failures);
> @@ -3294,6 +3318,9 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
> if (f2fs_readonly(sbi->sb))
> return -EROFS;
>
> + if (!pin && IS_DEVICE_ALIASING(inode))
> + return -EOPNOTSUPP;
> +
> ret = mnt_want_write_file(filp);
> if (ret)
> return ret;
> @@ -4711,7 +4738,8 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
> else
> return 0;
>
> - map.m_may_create = true;
> + if (!IS_DEVICE_ALIASING(inode))
> + map.m_may_create = true;
> if (dio) {
> map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
> inode->i_write_hint);
> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> index aef57172014f..f118e955ba88 100644
> --- a/fs/f2fs/inode.c
> +++ b/fs/f2fs/inode.c
> @@ -367,6 +367,12 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
> return false;
> }
>
> + if ((fi->i_flags & F2FS_DEVICE_ALIAS_FL) && !f2fs_sb_has_device_alias(sbi)) {
> + f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
> + __func__, inode->i_ino);
> + return false;
> + }
Do we need to do sanity check device_alias feature flag w/
sb.devs[].path format? and related inode?
> +
> return true;
> }
>
> @@ -818,8 +824,6 @@ void f2fs_evict_inode(struct inode *inode)
> f2fs_bug_on(sbi, get_dirty_pages(inode));
> f2fs_remove_dirty_inode(inode);
>
> - f2fs_destroy_extent_tree(inode);
For hardlink inode, it missed to call f2fs_destroy_extent_tree()?
Thanks,
> -
> if (inode->i_nlink || is_bad_inode(inode))
> goto no_delete;
>
> @@ -874,6 +878,8 @@ void f2fs_evict_inode(struct inode *inode)
> goto retry;
> }
>
> + f2fs_destroy_extent_tree(inode);
> +
> if (err) {
> f2fs_update_inode_page(inode);
> if (dquot_initialize_needed(inode))
> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> index fee7ee45ceaa..bf64f4cc3522 100644
> --- a/fs/f2fs/sysfs.c
> +++ b/fs/f2fs/sysfs.c
> @@ -1281,6 +1281,7 @@ F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
> F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
> F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
> F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
> +F2FS_SB_FEATURE_RO_ATTR(device_alias, DEVICE_ALIAS);
>
> static struct attribute *f2fs_sb_feat_attrs[] = {
> ATTR_LIST(sb_encryption),
> @@ -1297,6 +1298,7 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
> ATTR_LIST(sb_casefold),
> ATTR_LIST(sb_compression),
> ATTR_LIST(sb_readonly),
> + ATTR_LIST(sb_device_alias),
> NULL,
> };
> ATTRIBUTE_GROUPS(f2fs_sb_feat);
On Thu, Sep 19, 2024 at 6:14 AM Chao Yu <chao@kernel.org> wrote:
>
> On 2024/9/14 5:28, Daeho Jeong wrote:
> > From: Daeho Jeong <daehojeong@google.com>
> >
> > F2FS should understand how the device aliasing file works and support
> > deleting the file after use. A device aliasing file can be created by
> > mkfs.f2fs tool and it can map the whole device with an extrent, not
> > using node blocks. The file space should be pinned and normally used for
> > read-only usages.
> >
> > Signed-off-by: Daeho Jeong <daehojeong@google.com>
> > ---
> > fs/f2fs/data.c | 5 +++++
> > fs/f2fs/extent_cache.c | 10 ++++++++++
> > fs/f2fs/f2fs.h | 5 +++++
> > fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++----
> > fs/f2fs/inode.c | 10 ++++++++--
> > fs/f2fs/sysfs.c | 2 ++
> > 6 files changed, 62 insertions(+), 6 deletions(-)
> >
> > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> > index 6457e5bca9c9..9ce92093ba1e 100644
> > --- a/fs/f2fs/data.c
> > +++ b/fs/f2fs/data.c
> > @@ -3423,6 +3423,11 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
> >
> > if (!f2fs_lookup_read_extent_cache_block(inode, index,
> > &dn.data_blkaddr)) {
> > + if (IS_DEVICE_ALIASING(inode)) {
> > + err = -ENODATA;
> > + goto out;
> > + }
> > +
> > if (locked) {
> > err = f2fs_reserve_block(&dn, index);
> > goto out;
> > diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
> > index fd1fc06359ee..03883963b991 100644
> > --- a/fs/f2fs/extent_cache.c
> > +++ b/fs/f2fs/extent_cache.c
> > @@ -401,6 +401,11 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage)
> > if (atomic_read(&et->node_cnt) || !ei.len)
> > goto skip;
> >
> > + if (IS_DEVICE_ALIASING(inode)) {
> > + et->largest = ei;
> > + goto skip;
> > + }
> > +
> > en = __attach_extent_node(sbi, et, &ei, NULL,
> > &et->root.rb_root.rb_node, true);
> > if (en) {
> > @@ -463,6 +468,11 @@ static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
> > goto out;
> > }
> >
> > + if (IS_DEVICE_ALIASING(inode)) {
> > + ret = false;
> > + goto out;
> > + }
> > +
> > en = __lookup_extent_node(&et->root, et->cached_en, pgofs);
> > if (!en)
> > goto out;
> > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> > index ac19c61f0c3e..59179b9b3a83 100644
> > --- a/fs/f2fs/f2fs.h
> > +++ b/fs/f2fs/f2fs.h
> > @@ -208,6 +208,7 @@ struct f2fs_mount_info {
> > #define F2FS_FEATURE_CASEFOLD 0x00001000
> > #define F2FS_FEATURE_COMPRESSION 0x00002000
> > #define F2FS_FEATURE_RO 0x00004000
> > +#define F2FS_FEATURE_DEVICE_ALIAS 0x00008000
> >
> > #define __F2FS_HAS_FEATURE(raw_super, mask) \
> > ((raw_super->feature & cpu_to_le32(mask)) != 0)
> > @@ -3001,6 +3002,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> > #define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
> > #define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
> > #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
> > +#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */
> >
> > #define F2FS_QUOTA_DEFAULT_FL (F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL)
> >
> > @@ -3016,6 +3018,8 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> > /* Flags that are appropriate for non-directories/regular files. */
> > #define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
> >
> > +#define IS_DEVICE_ALIASING(inode) (F2FS_I(inode)->i_flags & F2FS_DEVICE_ALIAS_FL)
> > +
> > static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
> > {
> > if (S_ISDIR(mode))
> > @@ -4478,6 +4482,7 @@ F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
> > F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
> > F2FS_FEATURE_FUNCS(compression, COMPRESSION);
> > F2FS_FEATURE_FUNCS(readonly, RO);
> > +F2FS_FEATURE_FUNCS(device_alias, DEVICE_ALIAS);
> >
> > #ifdef CONFIG_BLK_DEV_ZONED
> > static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
> > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> > index 168f08507004..0f4af6b303ff 100644
> > --- a/fs/f2fs/file.c
> > +++ b/fs/f2fs/file.c
> > @@ -727,6 +727,11 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> >
> > trace_f2fs_truncate_blocks_enter(inode, from);
> >
> > + if (IS_DEVICE_ALIASING(inode) && from) {
> > + err = -EINVAL;
> > + goto out_err;
> > + }
> > +
> > free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
> >
> > if (free_from >= max_file_blocks(inode))
> > @@ -741,6 +746,21 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> > goto out;
> > }
> >
> > + if (IS_DEVICE_ALIASING(inode)) {
> > + struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
> > + struct extent_info ei = et->largest;
> > + unsigned int i;
> > +
> > + for (i = 0; i < ei.len; i++)
> > + f2fs_invalidate_blocks(sbi, ei.blk + i);
> > +
> > + dec_valid_block_count(sbi, inode, ei.len);
> > + f2fs_update_time(sbi, REQ_TIME);
> > +
> > + f2fs_put_page(ipage, 1);
> > + goto out;
> > + }
> > +
> > if (f2fs_has_inline_data(inode)) {
> > f2fs_truncate_inline_inode(inode, ipage, from);
> > f2fs_put_page(ipage, 1);
> > @@ -776,7 +796,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> > /* lastly zero out the first data page */
> > if (!err)
> > err = truncate_partial_data_page(inode, from, truncate_page);
> > -
> > +out_err:
> > trace_f2fs_truncate_blocks_exit(inode, err);
> > return err;
> > }
> > @@ -994,7 +1014,8 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
> > return -EPERM;
> >
> > if ((attr->ia_valid & ATTR_SIZE)) {
> > - if (!f2fs_is_compress_backend_ready(inode))
> > + if (!f2fs_is_compress_backend_ready(inode) ||
> > + IS_DEVICE_ALIASING(inode))
> > return -EOPNOTSUPP;
> > if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
> > !IS_ALIGNED(attr->ia_size,
> > @@ -1855,7 +1876,7 @@ static long f2fs_fallocate(struct file *file, int mode,
> > return -EIO;
> > if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
> > return -ENOSPC;
> > - if (!f2fs_is_compress_backend_ready(inode))
> > + if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
> > return -EOPNOTSUPP;
> >
> > /* f2fs only support ->fallocate for regular file */
> > @@ -3264,6 +3285,9 @@ int f2fs_pin_file_control(struct inode *inode, bool inc)
> > struct f2fs_inode_info *fi = F2FS_I(inode);
> > struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> >
> > + if (IS_DEVICE_ALIASING(inode))
> > + return -EINVAL;
> > +
> > if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
> > f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
> > __func__, inode->i_ino, fi->i_gc_failures);
> > @@ -3294,6 +3318,9 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
> > if (f2fs_readonly(sbi->sb))
> > return -EROFS;
> >
> > + if (!pin && IS_DEVICE_ALIASING(inode))
> > + return -EOPNOTSUPP;
> > +
> > ret = mnt_want_write_file(filp);
> > if (ret)
> > return ret;
> > @@ -4711,7 +4738,8 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
> > else
> > return 0;
> >
> > - map.m_may_create = true;
> > + if (!IS_DEVICE_ALIASING(inode))
> > + map.m_may_create = true;
> > if (dio) {
> > map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
> > inode->i_write_hint);
> > diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> > index aef57172014f..f118e955ba88 100644
> > --- a/fs/f2fs/inode.c
> > +++ b/fs/f2fs/inode.c
> > @@ -367,6 +367,12 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
> > return false;
> > }
> >
> > + if ((fi->i_flags & F2FS_DEVICE_ALIAS_FL) && !f2fs_sb_has_device_alias(sbi)) {
> > + f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
> > + __func__, inode->i_ino);
> > + return false;
> > + }
>
> Do we need to do sanity check device_alias feature flag w/
> sb.devs[].path format? and related inode?
Sorry, I am not sure I got your point. Could you elaborate it more?
>
> > +
> > return true;
> > }
> >
> > @@ -818,8 +824,6 @@ void f2fs_evict_inode(struct inode *inode)
> > f2fs_bug_on(sbi, get_dirty_pages(inode));
> > f2fs_remove_dirty_inode(inode);
> >
> > - f2fs_destroy_extent_tree(inode);
>
> For hardlink inode, it missed to call f2fs_destroy_extent_tree()?
Got it.
>
> Thanks,
>
> > -
> > if (inode->i_nlink || is_bad_inode(inode))
> > goto no_delete;
> >
> > @@ -874,6 +878,8 @@ void f2fs_evict_inode(struct inode *inode)
> > goto retry;
> > }
> >
> > + f2fs_destroy_extent_tree(inode);
> > +
> > if (err) {
> > f2fs_update_inode_page(inode);
> > if (dquot_initialize_needed(inode))
> > diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> > index fee7ee45ceaa..bf64f4cc3522 100644
> > --- a/fs/f2fs/sysfs.c
> > +++ b/fs/f2fs/sysfs.c
> > @@ -1281,6 +1281,7 @@ F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
> > F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
> > F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
> > F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
> > +F2FS_SB_FEATURE_RO_ATTR(device_alias, DEVICE_ALIAS);
> >
> > static struct attribute *f2fs_sb_feat_attrs[] = {
> > ATTR_LIST(sb_encryption),
> > @@ -1297,6 +1298,7 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
> > ATTR_LIST(sb_casefold),
> > ATTR_LIST(sb_compression),
> > ATTR_LIST(sb_readonly),
> > + ATTR_LIST(sb_device_alias),
> > NULL,
> > };
> > ATTRIBUTE_GROUPS(f2fs_sb_feat);
>
On 2024/9/20 23:38, Daeho Jeong wrote:
> On Thu, Sep 19, 2024 at 6:14 AM Chao Yu <chao@kernel.org> wrote:
>>
>> On 2024/9/14 5:28, Daeho Jeong wrote:
>>> From: Daeho Jeong <daehojeong@google.com>
>>>
>>> F2FS should understand how the device aliasing file works and support
>>> deleting the file after use. A device aliasing file can be created by
>>> mkfs.f2fs tool and it can map the whole device with an extrent, not
>>> using node blocks. The file space should be pinned and normally used for
>>> read-only usages.
>>>
>>> Signed-off-by: Daeho Jeong <daehojeong@google.com>
>>> ---
>>> fs/f2fs/data.c | 5 +++++
>>> fs/f2fs/extent_cache.c | 10 ++++++++++
>>> fs/f2fs/f2fs.h | 5 +++++
>>> fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++----
>>> fs/f2fs/inode.c | 10 ++++++++--
>>> fs/f2fs/sysfs.c | 2 ++
>>> 6 files changed, 62 insertions(+), 6 deletions(-)
>>>
>>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
>>> index 6457e5bca9c9..9ce92093ba1e 100644
>>> --- a/fs/f2fs/data.c
>>> +++ b/fs/f2fs/data.c
>>> @@ -3423,6 +3423,11 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
>>>
>>> if (!f2fs_lookup_read_extent_cache_block(inode, index,
>>> &dn.data_blkaddr)) {
>>> + if (IS_DEVICE_ALIASING(inode)) {
>>> + err = -ENODATA;
>>> + goto out;
>>> + }
>>> +
>>> if (locked) {
>>> err = f2fs_reserve_block(&dn, index);
>>> goto out;
>>> diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
>>> index fd1fc06359ee..03883963b991 100644
>>> --- a/fs/f2fs/extent_cache.c
>>> +++ b/fs/f2fs/extent_cache.c
>>> @@ -401,6 +401,11 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage)
>>> if (atomic_read(&et->node_cnt) || !ei.len)
>>> goto skip;
>>>
>>> + if (IS_DEVICE_ALIASING(inode)) {
>>> + et->largest = ei;
>>> + goto skip;
>>> + }
>>> +
>>> en = __attach_extent_node(sbi, et, &ei, NULL,
>>> &et->root.rb_root.rb_node, true);
>>> if (en) {
>>> @@ -463,6 +468,11 @@ static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
>>> goto out;
>>> }
>>>
>>> + if (IS_DEVICE_ALIASING(inode)) {
>>> + ret = false;
>>> + goto out;
>>> + }
>>> +
>>> en = __lookup_extent_node(&et->root, et->cached_en, pgofs);
>>> if (!en)
>>> goto out;
>>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
>>> index ac19c61f0c3e..59179b9b3a83 100644
>>> --- a/fs/f2fs/f2fs.h
>>> +++ b/fs/f2fs/f2fs.h
>>> @@ -208,6 +208,7 @@ struct f2fs_mount_info {
>>> #define F2FS_FEATURE_CASEFOLD 0x00001000
>>> #define F2FS_FEATURE_COMPRESSION 0x00002000
>>> #define F2FS_FEATURE_RO 0x00004000
>>> +#define F2FS_FEATURE_DEVICE_ALIAS 0x00008000
>>>
>>> #define __F2FS_HAS_FEATURE(raw_super, mask) \
>>> ((raw_super->feature & cpu_to_le32(mask)) != 0)
>>> @@ -3001,6 +3002,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
>>> #define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
>>> #define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
>>> #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
>>> +#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */
>>>
>>> #define F2FS_QUOTA_DEFAULT_FL (F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL)
>>>
>>> @@ -3016,6 +3018,8 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
>>> /* Flags that are appropriate for non-directories/regular files. */
>>> #define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
>>>
>>> +#define IS_DEVICE_ALIASING(inode) (F2FS_I(inode)->i_flags & F2FS_DEVICE_ALIAS_FL)
>>> +
>>> static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
>>> {
>>> if (S_ISDIR(mode))
>>> @@ -4478,6 +4482,7 @@ F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
>>> F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
>>> F2FS_FEATURE_FUNCS(compression, COMPRESSION);
>>> F2FS_FEATURE_FUNCS(readonly, RO);
>>> +F2FS_FEATURE_FUNCS(device_alias, DEVICE_ALIAS);
>>>
>>> #ifdef CONFIG_BLK_DEV_ZONED
>>> static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
>>> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
>>> index 168f08507004..0f4af6b303ff 100644
>>> --- a/fs/f2fs/file.c
>>> +++ b/fs/f2fs/file.c
>>> @@ -727,6 +727,11 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>>>
>>> trace_f2fs_truncate_blocks_enter(inode, from);
>>>
>>> + if (IS_DEVICE_ALIASING(inode) && from) {
>>> + err = -EINVAL;
>>> + goto out_err;
>>> + }
>>> +
>>> free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
>>>
>>> if (free_from >= max_file_blocks(inode))
>>> @@ -741,6 +746,21 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>>> goto out;
>>> }
>>>
>>> + if (IS_DEVICE_ALIASING(inode)) {
>>> + struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
>>> + struct extent_info ei = et->largest;
>>> + unsigned int i;
>>> +
>>> + for (i = 0; i < ei.len; i++)
>>> + f2fs_invalidate_blocks(sbi, ei.blk + i);
>>> +
>>> + dec_valid_block_count(sbi, inode, ei.len);
>>> + f2fs_update_time(sbi, REQ_TIME);
>>> +
>>> + f2fs_put_page(ipage, 1);
>>> + goto out;
>>> + }
>>> +
>>> if (f2fs_has_inline_data(inode)) {
>>> f2fs_truncate_inline_inode(inode, ipage, from);
>>> f2fs_put_page(ipage, 1);
>>> @@ -776,7 +796,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>>> /* lastly zero out the first data page */
>>> if (!err)
>>> err = truncate_partial_data_page(inode, from, truncate_page);
>>> -
>>> +out_err:
>>> trace_f2fs_truncate_blocks_exit(inode, err);
>>> return err;
>>> }
>>> @@ -994,7 +1014,8 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
>>> return -EPERM;
>>>
>>> if ((attr->ia_valid & ATTR_SIZE)) {
>>> - if (!f2fs_is_compress_backend_ready(inode))
>>> + if (!f2fs_is_compress_backend_ready(inode) ||
>>> + IS_DEVICE_ALIASING(inode))
>>> return -EOPNOTSUPP;
>>> if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
>>> !IS_ALIGNED(attr->ia_size,
>>> @@ -1855,7 +1876,7 @@ static long f2fs_fallocate(struct file *file, int mode,
>>> return -EIO;
>>> if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
>>> return -ENOSPC;
>>> - if (!f2fs_is_compress_backend_ready(inode))
>>> + if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
>>> return -EOPNOTSUPP;
>>>
>>> /* f2fs only support ->fallocate for regular file */
>>> @@ -3264,6 +3285,9 @@ int f2fs_pin_file_control(struct inode *inode, bool inc)
>>> struct f2fs_inode_info *fi = F2FS_I(inode);
>>> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>>>
>>> + if (IS_DEVICE_ALIASING(inode))
>>> + return -EINVAL;
>>> +
>>> if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
>>> f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
>>> __func__, inode->i_ino, fi->i_gc_failures);
>>> @@ -3294,6 +3318,9 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
>>> if (f2fs_readonly(sbi->sb))
>>> return -EROFS;
>>>
>>> + if (!pin && IS_DEVICE_ALIASING(inode))
>>> + return -EOPNOTSUPP;
>>> +
>>> ret = mnt_want_write_file(filp);
>>> if (ret)
>>> return ret;
>>> @@ -4711,7 +4738,8 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
>>> else
>>> return 0;
>>>
>>> - map.m_may_create = true;
>>> + if (!IS_DEVICE_ALIASING(inode))
>>> + map.m_may_create = true;
>>> if (dio) {
>>> map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
>>> inode->i_write_hint);
>>> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
>>> index aef57172014f..f118e955ba88 100644
>>> --- a/fs/f2fs/inode.c
>>> +++ b/fs/f2fs/inode.c
>>> @@ -367,6 +367,12 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
>>> return false;
>>> }
>>>
>>> + if ((fi->i_flags & F2FS_DEVICE_ALIAS_FL) && !f2fs_sb_has_device_alias(sbi)) {
>>> + f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
>>> + __func__, inode->i_ino);
>>> + return false;
>>> + }
>>
>> Do we need to do sanity check device_alias feature flag w/
>> sb.devs[].path format? and related inode?
>
> Sorry, I am not sure I got your point. Could you elaborate it more?
Oh, sorry, I misunderstand it. alias_filename won't be stored in sb.devs[].path,
please ignore it.
Another point is: what do you think of doing sanity check on extent_info of
device_alias inode?
we can check whether its extent points to whole region of target alias device or
not?
Thanks,
>
>>
>>> +
>>> return true;
>>> }
>>>
>>> @@ -818,8 +824,6 @@ void f2fs_evict_inode(struct inode *inode)
>>> f2fs_bug_on(sbi, get_dirty_pages(inode));
>>> f2fs_remove_dirty_inode(inode);
>>>
>>> - f2fs_destroy_extent_tree(inode);
>>
>> For hardlink inode, it missed to call f2fs_destroy_extent_tree()?
>
> Got it.
>
>>
>> Thanks,
>>
>>> -
>>> if (inode->i_nlink || is_bad_inode(inode))
>>> goto no_delete;
>>>
>>> @@ -874,6 +878,8 @@ void f2fs_evict_inode(struct inode *inode)
>>> goto retry;
>>> }
>>>
>>> + f2fs_destroy_extent_tree(inode);
>>> +
>>> if (err) {
>>> f2fs_update_inode_page(inode);
>>> if (dquot_initialize_needed(inode))
>>> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
>>> index fee7ee45ceaa..bf64f4cc3522 100644
>>> --- a/fs/f2fs/sysfs.c
>>> +++ b/fs/f2fs/sysfs.c
>>> @@ -1281,6 +1281,7 @@ F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
>>> F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
>>> F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
>>> F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
>>> +F2FS_SB_FEATURE_RO_ATTR(device_alias, DEVICE_ALIAS);
>>>
>>> static struct attribute *f2fs_sb_feat_attrs[] = {
>>> ATTR_LIST(sb_encryption),
>>> @@ -1297,6 +1298,7 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
>>> ATTR_LIST(sb_casefold),
>>> ATTR_LIST(sb_compression),
>>> ATTR_LIST(sb_readonly),
>>> + ATTR_LIST(sb_device_alias),
>>> NULL,
>>> };
>>> ATTRIBUTE_GROUPS(f2fs_sb_feat);
>>
On 09/23, Chao Yu wrote:
> On 2024/9/20 23:38, Daeho Jeong wrote:
> > On Thu, Sep 19, 2024 at 6:14 AM Chao Yu <chao@kernel.org> wrote:
> > >
> > > On 2024/9/14 5:28, Daeho Jeong wrote:
> > > > From: Daeho Jeong <daehojeong@google.com>
> > > >
> > > > F2FS should understand how the device aliasing file works and support
> > > > deleting the file after use. A device aliasing file can be created by
> > > > mkfs.f2fs tool and it can map the whole device with an extrent, not
> > > > using node blocks. The file space should be pinned and normally used for
> > > > read-only usages.
> > > >
> > > > Signed-off-by: Daeho Jeong <daehojeong@google.com>
> > > > ---
> > > > fs/f2fs/data.c | 5 +++++
> > > > fs/f2fs/extent_cache.c | 10 ++++++++++
> > > > fs/f2fs/f2fs.h | 5 +++++
> > > > fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++----
> > > > fs/f2fs/inode.c | 10 ++++++++--
> > > > fs/f2fs/sysfs.c | 2 ++
> > > > 6 files changed, 62 insertions(+), 6 deletions(-)
> > > >
> > > > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> > > > index 6457e5bca9c9..9ce92093ba1e 100644
> > > > --- a/fs/f2fs/data.c
> > > > +++ b/fs/f2fs/data.c
> > > > @@ -3423,6 +3423,11 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
> > > >
> > > > if (!f2fs_lookup_read_extent_cache_block(inode, index,
> > > > &dn.data_blkaddr)) {
> > > > + if (IS_DEVICE_ALIASING(inode)) {
> > > > + err = -ENODATA;
> > > > + goto out;
> > > > + }
> > > > +
> > > > if (locked) {
> > > > err = f2fs_reserve_block(&dn, index);
> > > > goto out;
> > > > diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
> > > > index fd1fc06359ee..03883963b991 100644
> > > > --- a/fs/f2fs/extent_cache.c
> > > > +++ b/fs/f2fs/extent_cache.c
> > > > @@ -401,6 +401,11 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage)
> > > > if (atomic_read(&et->node_cnt) || !ei.len)
> > > > goto skip;
> > > >
> > > > + if (IS_DEVICE_ALIASING(inode)) {
> > > > + et->largest = ei;
> > > > + goto skip;
> > > > + }
> > > > +
> > > > en = __attach_extent_node(sbi, et, &ei, NULL,
> > > > &et->root.rb_root.rb_node, true);
> > > > if (en) {
> > > > @@ -463,6 +468,11 @@ static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
> > > > goto out;
> > > > }
> > > >
> > > > + if (IS_DEVICE_ALIASING(inode)) {
> > > > + ret = false;
> > > > + goto out;
> > > > + }
> > > > +
> > > > en = __lookup_extent_node(&et->root, et->cached_en, pgofs);
> > > > if (!en)
> > > > goto out;
> > > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> > > > index ac19c61f0c3e..59179b9b3a83 100644
> > > > --- a/fs/f2fs/f2fs.h
> > > > +++ b/fs/f2fs/f2fs.h
> > > > @@ -208,6 +208,7 @@ struct f2fs_mount_info {
> > > > #define F2FS_FEATURE_CASEFOLD 0x00001000
> > > > #define F2FS_FEATURE_COMPRESSION 0x00002000
> > > > #define F2FS_FEATURE_RO 0x00004000
> > > > +#define F2FS_FEATURE_DEVICE_ALIAS 0x00008000
> > > >
> > > > #define __F2FS_HAS_FEATURE(raw_super, mask) \
> > > > ((raw_super->feature & cpu_to_le32(mask)) != 0)
> > > > @@ -3001,6 +3002,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> > > > #define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
> > > > #define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
> > > > #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
> > > > +#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */
> > > >
> > > > #define F2FS_QUOTA_DEFAULT_FL (F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL)
> > > >
> > > > @@ -3016,6 +3018,8 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
> > > > /* Flags that are appropriate for non-directories/regular files. */
> > > > #define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
> > > >
> > > > +#define IS_DEVICE_ALIASING(inode) (F2FS_I(inode)->i_flags & F2FS_DEVICE_ALIAS_FL)
> > > > +
> > > > static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
> > > > {
> > > > if (S_ISDIR(mode))
> > > > @@ -4478,6 +4482,7 @@ F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
> > > > F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
> > > > F2FS_FEATURE_FUNCS(compression, COMPRESSION);
> > > > F2FS_FEATURE_FUNCS(readonly, RO);
> > > > +F2FS_FEATURE_FUNCS(device_alias, DEVICE_ALIAS);
> > > >
> > > > #ifdef CONFIG_BLK_DEV_ZONED
> > > > static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
> > > > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> > > > index 168f08507004..0f4af6b303ff 100644
> > > > --- a/fs/f2fs/file.c
> > > > +++ b/fs/f2fs/file.c
> > > > @@ -727,6 +727,11 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> > > >
> > > > trace_f2fs_truncate_blocks_enter(inode, from);
> > > >
> > > > + if (IS_DEVICE_ALIASING(inode) && from) {
> > > > + err = -EINVAL;
> > > > + goto out_err;
> > > > + }
> > > > +
> > > > free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
> > > >
> > > > if (free_from >= max_file_blocks(inode))
> > > > @@ -741,6 +746,21 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> > > > goto out;
> > > > }
> > > >
> > > > + if (IS_DEVICE_ALIASING(inode)) {
> > > > + struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
> > > > + struct extent_info ei = et->largest;
> > > > + unsigned int i;
> > > > +
> > > > + for (i = 0; i < ei.len; i++)
> > > > + f2fs_invalidate_blocks(sbi, ei.blk + i);
> > > > +
> > > > + dec_valid_block_count(sbi, inode, ei.len);
> > > > + f2fs_update_time(sbi, REQ_TIME);
> > > > +
> > > > + f2fs_put_page(ipage, 1);
> > > > + goto out;
> > > > + }
> > > > +
> > > > if (f2fs_has_inline_data(inode)) {
> > > > f2fs_truncate_inline_inode(inode, ipage, from);
> > > > f2fs_put_page(ipage, 1);
> > > > @@ -776,7 +796,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
> > > > /* lastly zero out the first data page */
> > > > if (!err)
> > > > err = truncate_partial_data_page(inode, from, truncate_page);
> > > > -
> > > > +out_err:
> > > > trace_f2fs_truncate_blocks_exit(inode, err);
> > > > return err;
> > > > }
> > > > @@ -994,7 +1014,8 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
> > > > return -EPERM;
> > > >
> > > > if ((attr->ia_valid & ATTR_SIZE)) {
> > > > - if (!f2fs_is_compress_backend_ready(inode))
> > > > + if (!f2fs_is_compress_backend_ready(inode) ||
> > > > + IS_DEVICE_ALIASING(inode))
> > > > return -EOPNOTSUPP;
> > > > if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
> > > > !IS_ALIGNED(attr->ia_size,
> > > > @@ -1855,7 +1876,7 @@ static long f2fs_fallocate(struct file *file, int mode,
> > > > return -EIO;
> > > > if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
> > > > return -ENOSPC;
> > > > - if (!f2fs_is_compress_backend_ready(inode))
> > > > + if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
> > > > return -EOPNOTSUPP;
> > > >
> > > > /* f2fs only support ->fallocate for regular file */
> > > > @@ -3264,6 +3285,9 @@ int f2fs_pin_file_control(struct inode *inode, bool inc)
> > > > struct f2fs_inode_info *fi = F2FS_I(inode);
> > > > struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
> > > >
> > > > + if (IS_DEVICE_ALIASING(inode))
> > > > + return -EINVAL;
> > > > +
> > > > if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
> > > > f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
> > > > __func__, inode->i_ino, fi->i_gc_failures);
> > > > @@ -3294,6 +3318,9 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
> > > > if (f2fs_readonly(sbi->sb))
> > > > return -EROFS;
> > > >
> > > > + if (!pin && IS_DEVICE_ALIASING(inode))
> > > > + return -EOPNOTSUPP;
> > > > +
> > > > ret = mnt_want_write_file(filp);
> > > > if (ret)
> > > > return ret;
> > > > @@ -4711,7 +4738,8 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
> > > > else
> > > > return 0;
> > > >
> > > > - map.m_may_create = true;
> > > > + if (!IS_DEVICE_ALIASING(inode))
> > > > + map.m_may_create = true;
> > > > if (dio) {
> > > > map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
> > > > inode->i_write_hint);
> > > > diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> > > > index aef57172014f..f118e955ba88 100644
> > > > --- a/fs/f2fs/inode.c
> > > > +++ b/fs/f2fs/inode.c
> > > > @@ -367,6 +367,12 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
> > > > return false;
> > > > }
> > > >
> > > > + if ((fi->i_flags & F2FS_DEVICE_ALIAS_FL) && !f2fs_sb_has_device_alias(sbi)) {
> > > > + f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
> > > > + __func__, inode->i_ino);
> > > > + return false;
> > > > + }
> > >
> > > Do we need to do sanity check device_alias feature flag w/
> > > sb.devs[].path format? and related inode?
> >
> > Sorry, I am not sure I got your point. Could you elaborate it more?
>
> Oh, sorry, I misunderstand it. alias_filename won't be stored in sb.devs[].path,
> please ignore it.
>
> Another point is: what do you think of doing sanity check on extent_info of
> device_alias inode?
>
> we can check whether its extent points to whole region of target alias device or
> not?
Chao, I think we can add this later, as I'd like to queue this in the merge
window. Wdyt?
>
> Thanks,
>
> >
> > >
> > > > +
> > > > return true;
> > > > }
> > > >
> > > > @@ -818,8 +824,6 @@ void f2fs_evict_inode(struct inode *inode)
> > > > f2fs_bug_on(sbi, get_dirty_pages(inode));
> > > > f2fs_remove_dirty_inode(inode);
> > > >
> > > > - f2fs_destroy_extent_tree(inode);
> > >
> > > For hardlink inode, it missed to call f2fs_destroy_extent_tree()?
> >
> > Got it.
> >
> > >
> > > Thanks,
> > >
> > > > -
> > > > if (inode->i_nlink || is_bad_inode(inode))
> > > > goto no_delete;
> > > >
> > > > @@ -874,6 +878,8 @@ void f2fs_evict_inode(struct inode *inode)
> > > > goto retry;
> > > > }
> > > >
> > > > + f2fs_destroy_extent_tree(inode);
> > > > +
> > > > if (err) {
> > > > f2fs_update_inode_page(inode);
> > > > if (dquot_initialize_needed(inode))
> > > > diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
> > > > index fee7ee45ceaa..bf64f4cc3522 100644
> > > > --- a/fs/f2fs/sysfs.c
> > > > +++ b/fs/f2fs/sysfs.c
> > > > @@ -1281,6 +1281,7 @@ F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
> > > > F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
> > > > F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
> > > > F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
> > > > +F2FS_SB_FEATURE_RO_ATTR(device_alias, DEVICE_ALIAS);
> > > >
> > > > static struct attribute *f2fs_sb_feat_attrs[] = {
> > > > ATTR_LIST(sb_encryption),
> > > > @@ -1297,6 +1298,7 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
> > > > ATTR_LIST(sb_casefold),
> > > > ATTR_LIST(sb_compression),
> > > > ATTR_LIST(sb_readonly),
> > > > + ATTR_LIST(sb_device_alias),
> > > > NULL,
> > > > };
> > > > ATTRIBUTE_GROUPS(f2fs_sb_feat);
> > >
>
On 2024/9/23 23:14, Jaegeuk Kim wrote:
> On 09/23, Chao Yu wrote:
>> On 2024/9/20 23:38, Daeho Jeong wrote:
>>> On Thu, Sep 19, 2024 at 6:14 AM Chao Yu <chao@kernel.org> wrote:
>>>>
>>>> On 2024/9/14 5:28, Daeho Jeong wrote:
>>>>> From: Daeho Jeong <daehojeong@google.com>
>>>>>
>>>>> F2FS should understand how the device aliasing file works and support
>>>>> deleting the file after use. A device aliasing file can be created by
>>>>> mkfs.f2fs tool and it can map the whole device with an extrent, not
>>>>> using node blocks. The file space should be pinned and normally used for
>>>>> read-only usages.
>>>>>
>>>>> Signed-off-by: Daeho Jeong <daehojeong@google.com>
>>>>> ---
>>>>> fs/f2fs/data.c | 5 +++++
>>>>> fs/f2fs/extent_cache.c | 10 ++++++++++
>>>>> fs/f2fs/f2fs.h | 5 +++++
>>>>> fs/f2fs/file.c | 36 ++++++++++++++++++++++++++++++++----
>>>>> fs/f2fs/inode.c | 10 ++++++++--
>>>>> fs/f2fs/sysfs.c | 2 ++
>>>>> 6 files changed, 62 insertions(+), 6 deletions(-)
>>>>>
>>>>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
>>>>> index 6457e5bca9c9..9ce92093ba1e 100644
>>>>> --- a/fs/f2fs/data.c
>>>>> +++ b/fs/f2fs/data.c
>>>>> @@ -3423,6 +3423,11 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
>>>>>
>>>>> if (!f2fs_lookup_read_extent_cache_block(inode, index,
>>>>> &dn.data_blkaddr)) {
>>>>> + if (IS_DEVICE_ALIASING(inode)) {
>>>>> + err = -ENODATA;
>>>>> + goto out;
>>>>> + }
>>>>> +
>>>>> if (locked) {
>>>>> err = f2fs_reserve_block(&dn, index);
>>>>> goto out;
>>>>> diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
>>>>> index fd1fc06359ee..03883963b991 100644
>>>>> --- a/fs/f2fs/extent_cache.c
>>>>> +++ b/fs/f2fs/extent_cache.c
>>>>> @@ -401,6 +401,11 @@ void f2fs_init_read_extent_tree(struct inode *inode, struct page *ipage)
>>>>> if (atomic_read(&et->node_cnt) || !ei.len)
>>>>> goto skip;
>>>>>
>>>>> + if (IS_DEVICE_ALIASING(inode)) {
>>>>> + et->largest = ei;
>>>>> + goto skip;
>>>>> + }
>>>>> +
>>>>> en = __attach_extent_node(sbi, et, &ei, NULL,
>>>>> &et->root.rb_root.rb_node, true);
>>>>> if (en) {
>>>>> @@ -463,6 +468,11 @@ static bool __lookup_extent_tree(struct inode *inode, pgoff_t pgofs,
>>>>> goto out;
>>>>> }
>>>>>
>>>>> + if (IS_DEVICE_ALIASING(inode)) {
>>>>> + ret = false;
>>>>> + goto out;
>>>>> + }
>>>>> +
>>>>> en = __lookup_extent_node(&et->root, et->cached_en, pgofs);
>>>>> if (!en)
>>>>> goto out;
>>>>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
>>>>> index ac19c61f0c3e..59179b9b3a83 100644
>>>>> --- a/fs/f2fs/f2fs.h
>>>>> +++ b/fs/f2fs/f2fs.h
>>>>> @@ -208,6 +208,7 @@ struct f2fs_mount_info {
>>>>> #define F2FS_FEATURE_CASEFOLD 0x00001000
>>>>> #define F2FS_FEATURE_COMPRESSION 0x00002000
>>>>> #define F2FS_FEATURE_RO 0x00004000
>>>>> +#define F2FS_FEATURE_DEVICE_ALIAS 0x00008000
>>>>>
>>>>> #define __F2FS_HAS_FEATURE(raw_super, mask) \
>>>>> ((raw_super->feature & cpu_to_le32(mask)) != 0)
>>>>> @@ -3001,6 +3002,7 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
>>>>> #define F2FS_DIRSYNC_FL 0x00010000 /* dirsync behaviour (directories only) */
>>>>> #define F2FS_PROJINHERIT_FL 0x20000000 /* Create with parents projid */
>>>>> #define F2FS_CASEFOLD_FL 0x40000000 /* Casefolded file */
>>>>> +#define F2FS_DEVICE_ALIAS_FL 0x80000000 /* File for aliasing a device */
>>>>>
>>>>> #define F2FS_QUOTA_DEFAULT_FL (F2FS_NOATIME_FL | F2FS_IMMUTABLE_FL)
>>>>>
>>>>> @@ -3016,6 +3018,8 @@ static inline void f2fs_change_bit(unsigned int nr, char *addr)
>>>>> /* Flags that are appropriate for non-directories/regular files. */
>>>>> #define F2FS_OTHER_FLMASK (F2FS_NODUMP_FL | F2FS_NOATIME_FL)
>>>>>
>>>>> +#define IS_DEVICE_ALIASING(inode) (F2FS_I(inode)->i_flags & F2FS_DEVICE_ALIAS_FL)
>>>>> +
>>>>> static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
>>>>> {
>>>>> if (S_ISDIR(mode))
>>>>> @@ -4478,6 +4482,7 @@ F2FS_FEATURE_FUNCS(sb_chksum, SB_CHKSUM);
>>>>> F2FS_FEATURE_FUNCS(casefold, CASEFOLD);
>>>>> F2FS_FEATURE_FUNCS(compression, COMPRESSION);
>>>>> F2FS_FEATURE_FUNCS(readonly, RO);
>>>>> +F2FS_FEATURE_FUNCS(device_alias, DEVICE_ALIAS);
>>>>>
>>>>> #ifdef CONFIG_BLK_DEV_ZONED
>>>>> static inline bool f2fs_blkz_is_seq(struct f2fs_sb_info *sbi, int devi,
>>>>> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
>>>>> index 168f08507004..0f4af6b303ff 100644
>>>>> --- a/fs/f2fs/file.c
>>>>> +++ b/fs/f2fs/file.c
>>>>> @@ -727,6 +727,11 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>>>>>
>>>>> trace_f2fs_truncate_blocks_enter(inode, from);
>>>>>
>>>>> + if (IS_DEVICE_ALIASING(inode) && from) {
>>>>> + err = -EINVAL;
>>>>> + goto out_err;
>>>>> + }
>>>>> +
>>>>> free_from = (pgoff_t)F2FS_BLK_ALIGN(from);
>>>>>
>>>>> if (free_from >= max_file_blocks(inode))
>>>>> @@ -741,6 +746,21 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>>>>> goto out;
>>>>> }
>>>>>
>>>>> + if (IS_DEVICE_ALIASING(inode)) {
>>>>> + struct extent_tree *et = F2FS_I(inode)->extent_tree[EX_READ];
>>>>> + struct extent_info ei = et->largest;
>>>>> + unsigned int i;
>>>>> +
>>>>> + for (i = 0; i < ei.len; i++)
>>>>> + f2fs_invalidate_blocks(sbi, ei.blk + i);
>>>>> +
>>>>> + dec_valid_block_count(sbi, inode, ei.len);
>>>>> + f2fs_update_time(sbi, REQ_TIME);
>>>>> +
>>>>> + f2fs_put_page(ipage, 1);
>>>>> + goto out;
>>>>> + }
>>>>> +
>>>>> if (f2fs_has_inline_data(inode)) {
>>>>> f2fs_truncate_inline_inode(inode, ipage, from);
>>>>> f2fs_put_page(ipage, 1);
>>>>> @@ -776,7 +796,7 @@ int f2fs_do_truncate_blocks(struct inode *inode, u64 from, bool lock)
>>>>> /* lastly zero out the first data page */
>>>>> if (!err)
>>>>> err = truncate_partial_data_page(inode, from, truncate_page);
>>>>> -
>>>>> +out_err:
>>>>> trace_f2fs_truncate_blocks_exit(inode, err);
>>>>> return err;
>>>>> }
>>>>> @@ -994,7 +1014,8 @@ int f2fs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
>>>>> return -EPERM;
>>>>>
>>>>> if ((attr->ia_valid & ATTR_SIZE)) {
>>>>> - if (!f2fs_is_compress_backend_ready(inode))
>>>>> + if (!f2fs_is_compress_backend_ready(inode) ||
>>>>> + IS_DEVICE_ALIASING(inode))
>>>>> return -EOPNOTSUPP;
>>>>> if (is_inode_flag_set(inode, FI_COMPRESS_RELEASED) &&
>>>>> !IS_ALIGNED(attr->ia_size,
>>>>> @@ -1855,7 +1876,7 @@ static long f2fs_fallocate(struct file *file, int mode,
>>>>> return -EIO;
>>>>> if (!f2fs_is_checkpoint_ready(F2FS_I_SB(inode)))
>>>>> return -ENOSPC;
>>>>> - if (!f2fs_is_compress_backend_ready(inode))
>>>>> + if (!f2fs_is_compress_backend_ready(inode) || IS_DEVICE_ALIASING(inode))
>>>>> return -EOPNOTSUPP;
>>>>>
>>>>> /* f2fs only support ->fallocate for regular file */
>>>>> @@ -3264,6 +3285,9 @@ int f2fs_pin_file_control(struct inode *inode, bool inc)
>>>>> struct f2fs_inode_info *fi = F2FS_I(inode);
>>>>> struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
>>>>>
>>>>> + if (IS_DEVICE_ALIASING(inode))
>>>>> + return -EINVAL;
>>>>> +
>>>>> if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
>>>>> f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
>>>>> __func__, inode->i_ino, fi->i_gc_failures);
>>>>> @@ -3294,6 +3318,9 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
>>>>> if (f2fs_readonly(sbi->sb))
>>>>> return -EROFS;
>>>>>
>>>>> + if (!pin && IS_DEVICE_ALIASING(inode))
>>>>> + return -EOPNOTSUPP;
>>>>> +
>>>>> ret = mnt_want_write_file(filp);
>>>>> if (ret)
>>>>> return ret;
>>>>> @@ -4711,7 +4738,8 @@ static int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *iter,
>>>>> else
>>>>> return 0;
>>>>>
>>>>> - map.m_may_create = true;
>>>>> + if (!IS_DEVICE_ALIASING(inode))
>>>>> + map.m_may_create = true;
>>>>> if (dio) {
>>>>> map.m_seg_type = f2fs_rw_hint_to_seg_type(sbi,
>>>>> inode->i_write_hint);
>>>>> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
>>>>> index aef57172014f..f118e955ba88 100644
>>>>> --- a/fs/f2fs/inode.c
>>>>> +++ b/fs/f2fs/inode.c
>>>>> @@ -367,6 +367,12 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
>>>>> return false;
>>>>> }
>>>>>
>>>>> + if ((fi->i_flags & F2FS_DEVICE_ALIAS_FL) && !f2fs_sb_has_device_alias(sbi)) {
>>>>> + f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
>>>>> + __func__, inode->i_ino);
>>>>> + return false;
>>>>> + }
>>>>
>>>> Do we need to do sanity check device_alias feature flag w/
>>>> sb.devs[].path format? and related inode?
>>>
>>> Sorry, I am not sure I got your point. Could you elaborate it more?
>>
>> Oh, sorry, I misunderstand it. alias_filename won't be stored in sb.devs[].path,
>> please ignore it.
>>
>> Another point is: what do you think of doing sanity check on extent_info of
>> device_alias inode?
>>
>> we can check whether its extent points to whole region of target alias device or
>> not?
>
> Chao, I think we can add this later, as I'd like to queue this in the merge
> window. Wdyt?
Sure.
Thanks,
>
>>
>> Thanks,
>>
>>>
>>>>
>>>>> +
>>>>> return true;
>>>>> }
>>>>>
>>>>> @@ -818,8 +824,6 @@ void f2fs_evict_inode(struct inode *inode)
>>>>> f2fs_bug_on(sbi, get_dirty_pages(inode));
>>>>> f2fs_remove_dirty_inode(inode);
>>>>>
>>>>> - f2fs_destroy_extent_tree(inode);
>>>>
>>>> For hardlink inode, it missed to call f2fs_destroy_extent_tree()?
>>>
>>> Got it.
>>>
>>>>
>>>> Thanks,
>>>>
>>>>> -
>>>>> if (inode->i_nlink || is_bad_inode(inode))
>>>>> goto no_delete;
>>>>>
>>>>> @@ -874,6 +878,8 @@ void f2fs_evict_inode(struct inode *inode)
>>>>> goto retry;
>>>>> }
>>>>>
>>>>> + f2fs_destroy_extent_tree(inode);
>>>>> +
>>>>> if (err) {
>>>>> f2fs_update_inode_page(inode);
>>>>> if (dquot_initialize_needed(inode))
>>>>> diff --git a/fs/f2fs/sysfs.c b/fs/f2fs/sysfs.c
>>>>> index fee7ee45ceaa..bf64f4cc3522 100644
>>>>> --- a/fs/f2fs/sysfs.c
>>>>> +++ b/fs/f2fs/sysfs.c
>>>>> @@ -1281,6 +1281,7 @@ F2FS_SB_FEATURE_RO_ATTR(sb_checksum, SB_CHKSUM);
>>>>> F2FS_SB_FEATURE_RO_ATTR(casefold, CASEFOLD);
>>>>> F2FS_SB_FEATURE_RO_ATTR(compression, COMPRESSION);
>>>>> F2FS_SB_FEATURE_RO_ATTR(readonly, RO);
>>>>> +F2FS_SB_FEATURE_RO_ATTR(device_alias, DEVICE_ALIAS);
>>>>>
>>>>> static struct attribute *f2fs_sb_feat_attrs[] = {
>>>>> ATTR_LIST(sb_encryption),
>>>>> @@ -1297,6 +1298,7 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
>>>>> ATTR_LIST(sb_casefold),
>>>>> ATTR_LIST(sb_compression),
>>>>> ATTR_LIST(sb_readonly),
>>>>> + ATTR_LIST(sb_device_alias),
>>>>> NULL,
>>>>> };
>>>>> ATTRIBUTE_GROUPS(f2fs_sb_feat);
>>>>
>>
© 2016 - 2024 Red Hat, Inc.