* [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl @ 2020-10-30 4:10 Daeho Jeong 2020-10-30 4:10 ` [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl Daeho Jeong 2020-10-30 6:11 ` [f2fs-dev] [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl Chao Yu 0 siblings, 2 replies; 11+ messages in thread From: Daeho Jeong @ 2020-10-30 4:10 UTC (permalink / raw) To: linux-kernel, linux-f2fs-devel, kernel-team; +Cc: Daeho Jeong From: Daeho Jeong <daehojeong@google.com> Added a new F2FS_IOC_GET_COMPRESS_OPTION ioctl to get file compression option of a file. struct f2fs_comp_option { u8 algorithm; => compression algorithm => 0:lzo, 1:lz4, 2:zstd, 3:lzorle u8 log_cluster_size; => log scale cluster size => 2 ~ 8 }; struct f2fs_comp_option option; ioctl(fd, F2FS_IOC_GET_COMPRESS_OPTION, &option); Signed-off-by: Daeho Jeong <daehojeong@google.com> --- v7: changed inode_lock() to inode_lock_shared(). v4: changed commit message. v3: changed the error number more specific. v2: added ioctl description. --- fs/f2fs/f2fs.h | 7 +++++++ fs/f2fs/file.c | 30 ++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+) diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index 53fe2853579c..a33c90cf979b 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -433,6 +433,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, _IOR(F2FS_IOCTL_MAGIC, 19, __u64) #define F2FS_IOC_SEC_TRIM_FILE _IOW(F2FS_IOCTL_MAGIC, 20, \ struct f2fs_sectrim_range) +#define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ + struct f2fs_comp_option) /* * should be same as XFS_IOC_GOINGDOWN. @@ -481,6 +483,11 @@ struct f2fs_sectrim_range { u64 flags; }; +struct f2fs_comp_option { + u8 algorithm; + u8 log_cluster_size; +}; + /* for inline stuff */ #define DEF_INLINE_RESERVED_SIZE 1 static inline int get_extra_isize(struct inode *inode); diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index ef5a844de53f..bd52df84219d 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -3936,6 +3936,33 @@ static int f2fs_sec_trim_file(struct file *filp, unsigned long arg) return ret; } +static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) +{ + struct inode *inode = file_inode(filp); + struct f2fs_comp_option option; + + if (!f2fs_sb_has_compression(F2FS_I_SB(inode))) + return -EOPNOTSUPP; + + inode_lock_shared(inode); + + if (!f2fs_compressed_file(inode)) { + inode_unlock_shared(inode); + return -ENODATA; + } + + option.algorithm = F2FS_I(inode)->i_compress_algorithm; + option.log_cluster_size = F2FS_I(inode)->i_log_cluster_size; + + inode_unlock_shared(inode); + + if (copy_to_user((struct f2fs_comp_option __user *)arg, &option, + sizeof(option))) + return -EFAULT; + + return 0; +} + long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) @@ -4024,6 +4051,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) return f2fs_reserve_compress_blocks(filp, arg); case F2FS_IOC_SEC_TRIM_FILE: return f2fs_sec_trim_file(filp, arg); + case F2FS_IOC_GET_COMPRESS_OPTION: + return f2fs_ioc_get_compress_option(filp, arg); default: return -ENOTTY; } @@ -4194,6 +4223,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) case F2FS_IOC_RELEASE_COMPRESS_BLOCKS: case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: case F2FS_IOC_SEC_TRIM_FILE: + case F2FS_IOC_GET_COMPRESS_OPTION: break; default: return -ENOIOCTLCMD; -- 2.29.1.341.ge80a0c044ae-goog ^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-10-30 4:10 [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl Daeho Jeong @ 2020-10-30 4:10 ` Daeho Jeong 2020-10-30 6:13 ` [f2fs-dev] " Chao Yu 2020-12-03 2:49 ` Chao Yu 2020-10-30 6:11 ` [f2fs-dev] [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl Chao Yu 1 sibling, 2 replies; 11+ messages in thread From: Daeho Jeong @ 2020-10-30 4:10 UTC (permalink / raw) To: linux-kernel, linux-f2fs-devel, kernel-team; +Cc: Daeho Jeong From: Daeho Jeong <daehojeong@google.com> Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file compression option of a file. struct f2fs_comp_option { u8 algorithm; => compression algorithm => 0:lzo, 1:lz4, 2:zstd, 3:lzorle u8 log_cluster_size; => log scale cluster size => 2 ~ 8 }; struct f2fs_comp_option option; option.algorithm = 1; option.log_cluster_size = 7; ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); Signed-off-by: Daeho Jeong <daehojeong@google.com> --- v6: changed the function name of checking compression algorithm validity. v5: allowed to set algorithm which is not currently enabled by kernel. v4: changed commit message. v3: changed the error number more specific. folded in fix for build breakage reported by kernel test robot <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. v2: added ioctl description. --- fs/f2fs/compress.c | 5 +++++ fs/f2fs/f2fs.h | 7 ++++++ fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 66 insertions(+) diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c index 7895186cc765..b0144670d320 100644 --- a/fs/f2fs/compress.c +++ b/fs/f2fs/compress.c @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; } +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) +{ + return f2fs_cops[algorithm] != NULL; +} + static mempool_t *compress_page_pool; static int num_compress_pages = 512; module_param(num_compress_pages, uint, 0444); diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index a33c90cf979b..70a8a2196888 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, struct f2fs_sectrim_range) #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ struct f2fs_comp_option) +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ + struct f2fs_comp_option) /* * should be same as XFS_IOC_GOINGDOWN. @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); void f2fs_compress_write_end_io(struct bio *bio, struct page *page); bool f2fs_is_compress_backend_ready(struct inode *inode); +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); int f2fs_init_compress_mempool(void); void f2fs_destroy_compress_mempool(void); void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) /* not support compression */ return false; } +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) +{ + return false; +} static inline struct page *f2fs_compress_control_page(struct page *page) { WARN_ON_ONCE(1); diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index bd52df84219d..be56702e4939 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) return 0; } +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) +{ + struct inode *inode = file_inode(filp); + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); + struct f2fs_comp_option option; + int ret = 0; + + if (!f2fs_sb_has_compression(sbi)) + return -EOPNOTSUPP; + + if (!(filp->f_mode & FMODE_WRITE)) + return -EBADF; + + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, + sizeof(option))) + return -EFAULT; + + if (!f2fs_compressed_file(inode) || + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || + option.algorithm >= COMPRESS_MAX) + return -EINVAL; + + file_start_write(filp); + inode_lock(inode); + + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { + ret = -EBUSY; + goto out; + } + + if (inode->i_size != 0) { + ret = -EFBIG; + goto out; + } + + F2FS_I(inode)->i_compress_algorithm = option.algorithm; + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; + f2fs_mark_inode_dirty_sync(inode, true); + + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) + f2fs_warn(sbi, "compression algorithm is successfully set, " + "but current kernel doesn't support this algorithm."); +out: + inode_unlock(inode); + file_end_write(filp); + + return ret; +} + long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) return f2fs_sec_trim_file(filp, arg); case F2FS_IOC_GET_COMPRESS_OPTION: return f2fs_ioc_get_compress_option(filp, arg); + case F2FS_IOC_SET_COMPRESS_OPTION: + return f2fs_ioc_set_compress_option(filp, arg); default: return -ENOTTY; } @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: case F2FS_IOC_SEC_TRIM_FILE: case F2FS_IOC_GET_COMPRESS_OPTION: + case F2FS_IOC_SET_COMPRESS_OPTION: break; default: return -ENOIOCTLCMD; -- 2.29.1.341.ge80a0c044ae-goog ^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-10-30 4:10 ` [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl Daeho Jeong @ 2020-10-30 6:13 ` Chao Yu 2020-11-01 23:42 ` Daeho Jeong 2020-12-03 2:49 ` Chao Yu 1 sibling, 1 reply; 11+ messages in thread From: Chao Yu @ 2020-10-30 6:13 UTC (permalink / raw) To: Daeho Jeong, linux-kernel, linux-f2fs-devel, kernel-team; +Cc: Daeho Jeong Daeho, If there is no change, we are used to not resend the patch with updated version. Thanks, On 2020/10/30 12:10, Daeho Jeong wrote: > From: Daeho Jeong <daehojeong@google.com> > > Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file > compression option of a file. > > struct f2fs_comp_option { > u8 algorithm; => compression algorithm > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > u8 log_cluster_size; => log scale cluster size > => 2 ~ 8 > }; > > struct f2fs_comp_option option; > > option.algorithm = 1; > option.log_cluster_size = 7; > > ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); > > Signed-off-by: Daeho Jeong <daehojeong@google.com> > --- > > v6: changed the function name of checking compression algorithm validity. > v5: allowed to set algorithm which is not currently enabled by kernel. > v4: changed commit message. > v3: changed the error number more specific. > folded in fix for build breakage reported by kernel test robot > <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. > v2: added ioctl description. > --- > fs/f2fs/compress.c | 5 +++++ > fs/f2fs/f2fs.h | 7 ++++++ > fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 66 insertions(+) > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > index 7895186cc765..b0144670d320 100644 > --- a/fs/f2fs/compress.c > +++ b/fs/f2fs/compress.c > @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > } > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > +{ > + return f2fs_cops[algorithm] != NULL; > +} > + > static mempool_t *compress_page_pool; > static int num_compress_pages = 512; > module_param(num_compress_pages, uint, 0444); > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > index a33c90cf979b..70a8a2196888 100644 > --- a/fs/f2fs/f2fs.h > +++ b/fs/f2fs/f2fs.h > @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > struct f2fs_sectrim_range) > #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ > struct f2fs_comp_option) > +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ > + struct f2fs_comp_option) > > /* > * should be same as XFS_IOC_GOINGDOWN. > @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > bool f2fs_is_compress_backend_ready(struct inode *inode); > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > int f2fs_init_compress_mempool(void); > void f2fs_destroy_compress_mempool(void); > void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); > @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > /* not support compression */ > return false; > } > +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > +{ > + return false; > +} > static inline struct page *f2fs_compress_control_page(struct page *page) > { > WARN_ON_ONCE(1); > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > index bd52df84219d..be56702e4939 100644 > --- a/fs/f2fs/file.c > +++ b/fs/f2fs/file.c > @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) > return 0; > } > > +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > +{ > + struct inode *inode = file_inode(filp); > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > + struct f2fs_comp_option option; > + int ret = 0; > + > + if (!f2fs_sb_has_compression(sbi)) > + return -EOPNOTSUPP; > + > + if (!(filp->f_mode & FMODE_WRITE)) > + return -EBADF; > + > + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, > + sizeof(option))) > + return -EFAULT; > + > + if (!f2fs_compressed_file(inode) || > + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || > + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || > + option.algorithm >= COMPRESS_MAX) > + return -EINVAL; > + > + file_start_write(filp); > + inode_lock(inode); > + > + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { > + ret = -EBUSY; > + goto out; > + } > + > + if (inode->i_size != 0) { > + ret = -EFBIG; > + goto out; > + } > + > + F2FS_I(inode)->i_compress_algorithm = option.algorithm; > + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; > + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > + f2fs_mark_inode_dirty_sync(inode, true); > + > + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > + f2fs_warn(sbi, "compression algorithm is successfully set, " > + "but current kernel doesn't support this algorithm."); > +out: > + inode_unlock(inode); > + file_end_write(filp); > + > + return ret; > +} > + > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > { > if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) > @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > return f2fs_sec_trim_file(filp, arg); > case F2FS_IOC_GET_COMPRESS_OPTION: > return f2fs_ioc_get_compress_option(filp, arg); > + case F2FS_IOC_SET_COMPRESS_OPTION: > + return f2fs_ioc_set_compress_option(filp, arg); > default: > return -ENOTTY; > } > @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: > case F2FS_IOC_SEC_TRIM_FILE: > case F2FS_IOC_GET_COMPRESS_OPTION: > + case F2FS_IOC_SET_COMPRESS_OPTION: > break; > default: > return -ENOIOCTLCMD; > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-10-30 6:13 ` [f2fs-dev] " Chao Yu @ 2020-11-01 23:42 ` Daeho Jeong 2020-11-02 2:07 ` Chao Yu 0 siblings, 1 reply; 11+ messages in thread From: Daeho Jeong @ 2020-11-01 23:42 UTC (permalink / raw) To: Chao Yu; +Cc: linux-kernel, linux-f2fs-devel, kernel-team, Daeho Jeong Oh, even if those are patchset, then I have to send just changed ones? Got it. 2020년 10월 30일 (금) 오후 3:13, Chao Yu <yuchao0@huawei.com>님이 작성: > > Daeho, > > If there is no change, we are used to not resend the patch with updated > version. > > Thanks, > > On 2020/10/30 12:10, Daeho Jeong wrote: > > From: Daeho Jeong <daehojeong@google.com> > > > > Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file > > compression option of a file. > > > > struct f2fs_comp_option { > > u8 algorithm; => compression algorithm > > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > > u8 log_cluster_size; => log scale cluster size > > => 2 ~ 8 > > }; > > > > struct f2fs_comp_option option; > > > > option.algorithm = 1; > > option.log_cluster_size = 7; > > > > ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); > > > > Signed-off-by: Daeho Jeong <daehojeong@google.com> > > --- > > > > v6: changed the function name of checking compression algorithm validity. > > v5: allowed to set algorithm which is not currently enabled by kernel. > > v4: changed commit message. > > v3: changed the error number more specific. > > folded in fix for build breakage reported by kernel test robot > > <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. > > v2: added ioctl description. > > --- > > fs/f2fs/compress.c | 5 +++++ > > fs/f2fs/f2fs.h | 7 ++++++ > > fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ > > 3 files changed, 66 insertions(+) > > > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > > index 7895186cc765..b0144670d320 100644 > > --- a/fs/f2fs/compress.c > > +++ b/fs/f2fs/compress.c > > @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > > } > > > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > +{ > > + return f2fs_cops[algorithm] != NULL; > > +} > > + > > static mempool_t *compress_page_pool; > > static int num_compress_pages = 512; > > module_param(num_compress_pages, uint, 0444); > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > > index a33c90cf979b..70a8a2196888 100644 > > --- a/fs/f2fs/f2fs.h > > +++ b/fs/f2fs/f2fs.h > > @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > > struct f2fs_sectrim_range) > > #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ > > struct f2fs_comp_option) > > +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ > > + struct f2fs_comp_option) > > > > /* > > * should be same as XFS_IOC_GOINGDOWN. > > @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > > bool f2fs_is_compress_backend_ready(struct inode *inode); > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > > int f2fs_init_compress_mempool(void); > > void f2fs_destroy_compress_mempool(void); > > void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); > > @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > > /* not support compression */ > > return false; > > } > > +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > +{ > > + return false; > > +} > > static inline struct page *f2fs_compress_control_page(struct page *page) > > { > > WARN_ON_ONCE(1); > > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > > index bd52df84219d..be56702e4939 100644 > > --- a/fs/f2fs/file.c > > +++ b/fs/f2fs/file.c > > @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) > > return 0; > > } > > > > +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > > +{ > > + struct inode *inode = file_inode(filp); > > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > > + struct f2fs_comp_option option; > > + int ret = 0; > > + > > + if (!f2fs_sb_has_compression(sbi)) > > + return -EOPNOTSUPP; > > + > > + if (!(filp->f_mode & FMODE_WRITE)) > > + return -EBADF; > > + > > + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, > > + sizeof(option))) > > + return -EFAULT; > > + > > + if (!f2fs_compressed_file(inode) || > > + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || > > + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || > > + option.algorithm >= COMPRESS_MAX) > > + return -EINVAL; > > + > > + file_start_write(filp); > > + inode_lock(inode); > > + > > + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { > > + ret = -EBUSY; > > + goto out; > > + } > > + > > + if (inode->i_size != 0) { > > + ret = -EFBIG; > > + goto out; > > + } > > + > > + F2FS_I(inode)->i_compress_algorithm = option.algorithm; > > + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; > > + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > > + f2fs_mark_inode_dirty_sync(inode, true); > > + > > + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > > + f2fs_warn(sbi, "compression algorithm is successfully set, " > > + "but current kernel doesn't support this algorithm."); > > +out: > > + inode_unlock(inode); > > + file_end_write(filp); > > + > > + return ret; > > +} > > + > > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > { > > if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) > > @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > return f2fs_sec_trim_file(filp, arg); > > case F2FS_IOC_GET_COMPRESS_OPTION: > > return f2fs_ioc_get_compress_option(filp, arg); > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > + return f2fs_ioc_set_compress_option(filp, arg); > > default: > > return -ENOTTY; > > } > > @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > > case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: > > case F2FS_IOC_SEC_TRIM_FILE: > > case F2FS_IOC_GET_COMPRESS_OPTION: > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > break; > > default: > > return -ENOIOCTLCMD; > > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-11-01 23:42 ` Daeho Jeong @ 2020-11-02 2:07 ` Chao Yu 0 siblings, 0 replies; 11+ messages in thread From: Chao Yu @ 2020-11-02 2:07 UTC (permalink / raw) To: Daeho Jeong; +Cc: linux-kernel, linux-f2fs-devel, kernel-team, Daeho Jeong On 2020/11/2 7:42, Daeho Jeong wrote: > Oh, even if those are patchset, then I have to send just changed ones? There is no strict constraint condition, and I'm okay with both ways, however, I prefer the way just sending changed one because IMO it can help to save review time on those unchanged patches. :P Thanks, > Got it. > > 2020년 10월 30일 (금) 오후 3:13, Chao Yu <yuchao0@huawei.com>님이 작성: >> >> Daeho, >> >> If there is no change, we are used to not resend the patch with updated >> version. >> >> Thanks, >> >> On 2020/10/30 12:10, Daeho Jeong wrote: >>> From: Daeho Jeong <daehojeong@google.com> >>> >>> Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file >>> compression option of a file. >>> >>> struct f2fs_comp_option { >>> u8 algorithm; => compression algorithm >>> => 0:lzo, 1:lz4, 2:zstd, 3:lzorle >>> u8 log_cluster_size; => log scale cluster size >>> => 2 ~ 8 >>> }; >>> >>> struct f2fs_comp_option option; >>> >>> option.algorithm = 1; >>> option.log_cluster_size = 7; >>> >>> ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); >>> >>> Signed-off-by: Daeho Jeong <daehojeong@google.com> >>> --- >>> >>> v6: changed the function name of checking compression algorithm validity. >>> v5: allowed to set algorithm which is not currently enabled by kernel. >>> v4: changed commit message. >>> v3: changed the error number more specific. >>> folded in fix for build breakage reported by kernel test robot >>> <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. >>> v2: added ioctl description. >>> --- >>> fs/f2fs/compress.c | 5 +++++ >>> fs/f2fs/f2fs.h | 7 ++++++ >>> fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ >>> 3 files changed, 66 insertions(+) >>> >>> diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c >>> index 7895186cc765..b0144670d320 100644 >>> --- a/fs/f2fs/compress.c >>> +++ b/fs/f2fs/compress.c >>> @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) >>> return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; >>> } >>> >>> +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) >>> +{ >>> + return f2fs_cops[algorithm] != NULL; >>> +} >>> + >>> static mempool_t *compress_page_pool; >>> static int num_compress_pages = 512; >>> module_param(num_compress_pages, uint, 0444); >>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h >>> index a33c90cf979b..70a8a2196888 100644 >>> --- a/fs/f2fs/f2fs.h >>> +++ b/fs/f2fs/f2fs.h >>> @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, >>> struct f2fs_sectrim_range) >>> #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ >>> struct f2fs_comp_option) >>> +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ >>> + struct f2fs_comp_option) >>> >>> /* >>> * should be same as XFS_IOC_GOINGDOWN. >>> @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, >>> int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); >>> void f2fs_compress_write_end_io(struct bio *bio, struct page *page); >>> bool f2fs_is_compress_backend_ready(struct inode *inode); >>> +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); >>> int f2fs_init_compress_mempool(void); >>> void f2fs_destroy_compress_mempool(void); >>> void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); >>> @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) >>> /* not support compression */ >>> return false; >>> } >>> +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) >>> +{ >>> + return false; >>> +} >>> static inline struct page *f2fs_compress_control_page(struct page *page) >>> { >>> WARN_ON_ONCE(1); >>> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c >>> index bd52df84219d..be56702e4939 100644 >>> --- a/fs/f2fs/file.c >>> +++ b/fs/f2fs/file.c >>> @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) >>> return 0; >>> } >>> >>> +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) >>> +{ >>> + struct inode *inode = file_inode(filp); >>> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); >>> + struct f2fs_comp_option option; >>> + int ret = 0; >>> + >>> + if (!f2fs_sb_has_compression(sbi)) >>> + return -EOPNOTSUPP; >>> + >>> + if (!(filp->f_mode & FMODE_WRITE)) >>> + return -EBADF; >>> + >>> + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, >>> + sizeof(option))) >>> + return -EFAULT; >>> + >>> + if (!f2fs_compressed_file(inode) || >>> + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || >>> + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || >>> + option.algorithm >= COMPRESS_MAX) >>> + return -EINVAL; >>> + >>> + file_start_write(filp); >>> + inode_lock(inode); >>> + >>> + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { >>> + ret = -EBUSY; >>> + goto out; >>> + } >>> + >>> + if (inode->i_size != 0) { >>> + ret = -EFBIG; >>> + goto out; >>> + } >>> + >>> + F2FS_I(inode)->i_compress_algorithm = option.algorithm; >>> + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; >>> + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; >>> + f2fs_mark_inode_dirty_sync(inode, true); >>> + >>> + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) >>> + f2fs_warn(sbi, "compression algorithm is successfully set, " >>> + "but current kernel doesn't support this algorithm."); >>> +out: >>> + inode_unlock(inode); >>> + file_end_write(filp); >>> + >>> + return ret; >>> +} >>> + >>> long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >>> { >>> if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) >>> @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >>> return f2fs_sec_trim_file(filp, arg); >>> case F2FS_IOC_GET_COMPRESS_OPTION: >>> return f2fs_ioc_get_compress_option(filp, arg); >>> + case F2FS_IOC_SET_COMPRESS_OPTION: >>> + return f2fs_ioc_set_compress_option(filp, arg); >>> default: >>> return -ENOTTY; >>> } >>> @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) >>> case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: >>> case F2FS_IOC_SEC_TRIM_FILE: >>> case F2FS_IOC_GET_COMPRESS_OPTION: >>> + case F2FS_IOC_SET_COMPRESS_OPTION: >>> break; >>> default: >>> return -ENOIOCTLCMD; >>> > . > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-10-30 4:10 ` [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl Daeho Jeong 2020-10-30 6:13 ` [f2fs-dev] " Chao Yu @ 2020-12-03 2:49 ` Chao Yu 2020-12-03 4:13 ` Daeho Jeong 2020-12-03 5:40 ` Jaegeuk Kim 1 sibling, 2 replies; 11+ messages in thread From: Chao Yu @ 2020-12-03 2:49 UTC (permalink / raw) To: Daeho Jeong, jaegeuk Cc: linux-kernel, linux-f2fs-devel, kernel-team, Daeho Jeong Jaegeuk, not sure, is it too late to merge this cleanup into original patch? From a5c63ec58e0cda6eb5d186b46942eea46422b7a9 Mon Sep 17 00:00:00 2001 From: Chao Yu <yuchao0@huawei.com> Date: Thu, 3 Dec 2020 10:04:26 +0800 Subject: [PATCH] f2fs: remove f2fs_is_compress_algorithm_valid() for cleanup No logic changes. Signed-off-by: Chao Yu <yuchao0@huawei.com> --- fs/f2fs/compress.c | 5 ----- fs/f2fs/f2fs.h | 5 ----- fs/f2fs/file.c | 2 +- 3 files changed, 1 insertion(+), 11 deletions(-) diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c index dfadbc78946c..869b047a4801 100644 --- a/fs/f2fs/compress.c +++ b/fs/f2fs/compress.c @@ -574,11 +574,6 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; } -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) -{ - return f2fs_cops[algorithm] != NULL; -} - static mempool_t *compress_page_pool; static int num_compress_pages = 512; module_param(num_compress_pages, uint, 0444); diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h index b70c8d553439..17b45c2d2b04 100644 --- a/fs/f2fs/f2fs.h +++ b/fs/f2fs/f2fs.h @@ -3882,7 +3882,6 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); void f2fs_compress_write_end_io(struct bio *bio, struct page *page); bool f2fs_is_compress_backend_ready(struct inode *inode); -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); int f2fs_init_compress_mempool(void); void f2fs_destroy_compress_mempool(void); void f2fs_do_decompress_pages(struct decompress_io_ctx *dic, bool verity); @@ -3927,10 +3926,6 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) /* not support compression */ return false; } -static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) -{ - return false; -} static inline struct page *f2fs_compress_control_page(struct page *page) { WARN_ON_ONCE(1); diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c index 300355fe25f0..0453b441228d 100644 --- a/fs/f2fs/file.c +++ b/fs/f2fs/file.c @@ -4016,7 +4016,7 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; f2fs_mark_inode_dirty_sync(inode, true); - if (!f2fs_is_compress_algorithm_valid(option.algorithm)) + if (!f2fs_is_compress_backend_ready(inode)) f2fs_warn(sbi, "compression algorithm is successfully set, " "but current kernel doesn't support this algorithm."); out: -- 2.26.2 On 2020/10/30 12:10, Daeho Jeong wrote: > From: Daeho Jeong <daehojeong@google.com> > > Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file > compression option of a file. > > struct f2fs_comp_option { > u8 algorithm; => compression algorithm > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > u8 log_cluster_size; => log scale cluster size > => 2 ~ 8 > }; > > struct f2fs_comp_option option; > > option.algorithm = 1; > option.log_cluster_size = 7; > > ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); > > Signed-off-by: Daeho Jeong <daehojeong@google.com> > --- > > v6: changed the function name of checking compression algorithm validity. > v5: allowed to set algorithm which is not currently enabled by kernel. > v4: changed commit message. > v3: changed the error number more specific. > folded in fix for build breakage reported by kernel test robot > <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. > v2: added ioctl description. > --- > fs/f2fs/compress.c | 5 +++++ > fs/f2fs/f2fs.h | 7 ++++++ > fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ > 3 files changed, 66 insertions(+) > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > index 7895186cc765..b0144670d320 100644 > --- a/fs/f2fs/compress.c > +++ b/fs/f2fs/compress.c > @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > } > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > +{ > + return f2fs_cops[algorithm] != NULL; > +} > + > static mempool_t *compress_page_pool; > static int num_compress_pages = 512; > module_param(num_compress_pages, uint, 0444); > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > index a33c90cf979b..70a8a2196888 100644 > --- a/fs/f2fs/f2fs.h > +++ b/fs/f2fs/f2fs.h > @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > struct f2fs_sectrim_range) > #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ > struct f2fs_comp_option) > +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ > + struct f2fs_comp_option) > > /* > * should be same as XFS_IOC_GOINGDOWN. > @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > bool f2fs_is_compress_backend_ready(struct inode *inode); > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > int f2fs_init_compress_mempool(void); > void f2fs_destroy_compress_mempool(void); > void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); > @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > /* not support compression */ > return false; > } > +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > +{ > + return false; > +} > static inline struct page *f2fs_compress_control_page(struct page *page) > { > WARN_ON_ONCE(1); > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > index bd52df84219d..be56702e4939 100644 > --- a/fs/f2fs/file.c > +++ b/fs/f2fs/file.c > @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) > return 0; > } > > +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > +{ > + struct inode *inode = file_inode(filp); > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > + struct f2fs_comp_option option; > + int ret = 0; > + > + if (!f2fs_sb_has_compression(sbi)) > + return -EOPNOTSUPP; > + > + if (!(filp->f_mode & FMODE_WRITE)) > + return -EBADF; > + > + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, > + sizeof(option))) > + return -EFAULT; > + > + if (!f2fs_compressed_file(inode) || > + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || > + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || > + option.algorithm >= COMPRESS_MAX) > + return -EINVAL; > + > + file_start_write(filp); > + inode_lock(inode); > + > + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { > + ret = -EBUSY; > + goto out; > + } > + > + if (inode->i_size != 0) { > + ret = -EFBIG; > + goto out; > + } > + > + F2FS_I(inode)->i_compress_algorithm = option.algorithm; > + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; > + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > + f2fs_mark_inode_dirty_sync(inode, true); > + > + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > + f2fs_warn(sbi, "compression algorithm is successfully set, " > + "but current kernel doesn't support this algorithm."); > +out: > + inode_unlock(inode); > + file_end_write(filp); > + > + return ret; > +} > + > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > { > if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) > @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > return f2fs_sec_trim_file(filp, arg); > case F2FS_IOC_GET_COMPRESS_OPTION: > return f2fs_ioc_get_compress_option(filp, arg); > + case F2FS_IOC_SET_COMPRESS_OPTION: > + return f2fs_ioc_set_compress_option(filp, arg); > default: > return -ENOTTY; > } > @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: > case F2FS_IOC_SEC_TRIM_FILE: > case F2FS_IOC_GET_COMPRESS_OPTION: > + case F2FS_IOC_SET_COMPRESS_OPTION: > break; > default: > return -ENOIOCTLCMD; > ^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-12-03 2:49 ` Chao Yu @ 2020-12-03 4:13 ` Daeho Jeong 2020-12-03 5:40 ` Jaegeuk Kim 1 sibling, 0 replies; 11+ messages in thread From: Daeho Jeong @ 2020-12-03 4:13 UTC (permalink / raw) To: Chao Yu Cc: Jaegeuk Kim, linux-kernel, linux-f2fs-devel, kernel-team, Daeho Jeong Oh, by the control logic changed in the previous patch, we don't need to use f2fs_is_compress_algorithm_valid() anymore. Looks good~ 2020년 12월 3일 (목) 오전 11:49, Chao Yu <yuchao0@huawei.com>님이 작성: > > Jaegeuk, not sure, is it too late to merge this cleanup into original patch? > > From a5c63ec58e0cda6eb5d186b46942eea46422b7a9 Mon Sep 17 00:00:00 2001 > From: Chao Yu <yuchao0@huawei.com> > Date: Thu, 3 Dec 2020 10:04:26 +0800 > Subject: [PATCH] f2fs: remove f2fs_is_compress_algorithm_valid() for cleanup > > No logic changes. > > Signed-off-by: Chao Yu <yuchao0@huawei.com> > --- > fs/f2fs/compress.c | 5 ----- > fs/f2fs/f2fs.h | 5 ----- > fs/f2fs/file.c | 2 +- > 3 files changed, 1 insertion(+), 11 deletions(-) > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > index dfadbc78946c..869b047a4801 100644 > --- a/fs/f2fs/compress.c > +++ b/fs/f2fs/compress.c > @@ -574,11 +574,6 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > } > > -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > -{ > - return f2fs_cops[algorithm] != NULL; > -} > - > static mempool_t *compress_page_pool; > static int num_compress_pages = 512; > module_param(num_compress_pages, uint, 0444); > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > index b70c8d553439..17b45c2d2b04 100644 > --- a/fs/f2fs/f2fs.h > +++ b/fs/f2fs/f2fs.h > @@ -3882,7 +3882,6 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > bool f2fs_is_compress_backend_ready(struct inode *inode); > -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > int f2fs_init_compress_mempool(void); > void f2fs_destroy_compress_mempool(void); > void f2fs_do_decompress_pages(struct decompress_io_ctx *dic, bool verity); > @@ -3927,10 +3926,6 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > /* not support compression */ > return false; > } > -static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > -{ > - return false; > -} > static inline struct page *f2fs_compress_control_page(struct page *page) > { > WARN_ON_ONCE(1); > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > index 300355fe25f0..0453b441228d 100644 > --- a/fs/f2fs/file.c > +++ b/fs/f2fs/file.c > @@ -4016,7 +4016,7 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > f2fs_mark_inode_dirty_sync(inode, true); > > - if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > + if (!f2fs_is_compress_backend_ready(inode)) > f2fs_warn(sbi, "compression algorithm is successfully set, " > "but current kernel doesn't support this algorithm."); > out: > -- > 2.26.2 > > > > > > On 2020/10/30 12:10, Daeho Jeong wrote: > > From: Daeho Jeong <daehojeong@google.com> > > > > Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file > > compression option of a file. > > > > struct f2fs_comp_option { > > u8 algorithm; => compression algorithm > > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > > u8 log_cluster_size; => log scale cluster size > > => 2 ~ 8 > > }; > > > > struct f2fs_comp_option option; > > > > option.algorithm = 1; > > option.log_cluster_size = 7; > > > > ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); > > > > Signed-off-by: Daeho Jeong <daehojeong@google.com> > > --- > > > > v6: changed the function name of checking compression algorithm validity. > > v5: allowed to set algorithm which is not currently enabled by kernel. > > v4: changed commit message. > > v3: changed the error number more specific. > > folded in fix for build breakage reported by kernel test robot > > <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. > > v2: added ioctl description. > > --- > > fs/f2fs/compress.c | 5 +++++ > > fs/f2fs/f2fs.h | 7 ++++++ > > fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ > > 3 files changed, 66 insertions(+) > > > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > > index 7895186cc765..b0144670d320 100644 > > --- a/fs/f2fs/compress.c > > +++ b/fs/f2fs/compress.c > > @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > > } > > > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > +{ > > + return f2fs_cops[algorithm] != NULL; > > +} > > + > > static mempool_t *compress_page_pool; > > static int num_compress_pages = 512; > > module_param(num_compress_pages, uint, 0444); > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > > index a33c90cf979b..70a8a2196888 100644 > > --- a/fs/f2fs/f2fs.h > > +++ b/fs/f2fs/f2fs.h > > @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > > struct f2fs_sectrim_range) > > #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ > > struct f2fs_comp_option) > > +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ > > + struct f2fs_comp_option) > > > > /* > > * should be same as XFS_IOC_GOINGDOWN. > > @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > > bool f2fs_is_compress_backend_ready(struct inode *inode); > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > > int f2fs_init_compress_mempool(void); > > void f2fs_destroy_compress_mempool(void); > > void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); > > @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > > /* not support compression */ > > return false; > > } > > +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > +{ > > + return false; > > +} > > static inline struct page *f2fs_compress_control_page(struct page *page) > > { > > WARN_ON_ONCE(1); > > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > > index bd52df84219d..be56702e4939 100644 > > --- a/fs/f2fs/file.c > > +++ b/fs/f2fs/file.c > > @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) > > return 0; > > } > > > > +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > > +{ > > + struct inode *inode = file_inode(filp); > > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > > + struct f2fs_comp_option option; > > + int ret = 0; > > + > > + if (!f2fs_sb_has_compression(sbi)) > > + return -EOPNOTSUPP; > > + > > + if (!(filp->f_mode & FMODE_WRITE)) > > + return -EBADF; > > + > > + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, > > + sizeof(option))) > > + return -EFAULT; > > + > > + if (!f2fs_compressed_file(inode) || > > + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || > > + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || > > + option.algorithm >= COMPRESS_MAX) > > + return -EINVAL; > > + > > + file_start_write(filp); > > + inode_lock(inode); > > + > > + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { > > + ret = -EBUSY; > > + goto out; > > + } > > + > > + if (inode->i_size != 0) { > > + ret = -EFBIG; > > + goto out; > > + } > > + > > + F2FS_I(inode)->i_compress_algorithm = option.algorithm; > > + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; > > + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > > + f2fs_mark_inode_dirty_sync(inode, true); > > + > > + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > > + f2fs_warn(sbi, "compression algorithm is successfully set, " > > + "but current kernel doesn't support this algorithm."); > > +out: > > + inode_unlock(inode); > > + file_end_write(filp); > > + > > + return ret; > > +} > > + > > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > { > > if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) > > @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > return f2fs_sec_trim_file(filp, arg); > > case F2FS_IOC_GET_COMPRESS_OPTION: > > return f2fs_ioc_get_compress_option(filp, arg); > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > + return f2fs_ioc_set_compress_option(filp, arg); > > default: > > return -ENOTTY; > > } > > @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > > case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: > > case F2FS_IOC_SEC_TRIM_FILE: > > case F2FS_IOC_GET_COMPRESS_OPTION: > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > break; > > default: > > return -ENOIOCTLCMD; > > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-12-03 2:49 ` Chao Yu 2020-12-03 4:13 ` Daeho Jeong @ 2020-12-03 5:40 ` Jaegeuk Kim 2020-12-03 6:08 ` Jaegeuk Kim 1 sibling, 1 reply; 11+ messages in thread From: Jaegeuk Kim @ 2020-12-03 5:40 UTC (permalink / raw) To: Chao Yu Cc: Daeho Jeong, linux-kernel, linux-f2fs-devel, kernel-team, Daeho Jeong On 12/03, Chao Yu wrote: > Jaegeuk, not sure, is it too late to merge this cleanup into original patch? Let me merge this on top of tree. Thanks. :) > > From a5c63ec58e0cda6eb5d186b46942eea46422b7a9 Mon Sep 17 00:00:00 2001 > From: Chao Yu <yuchao0@huawei.com> > Date: Thu, 3 Dec 2020 10:04:26 +0800 > Subject: [PATCH] f2fs: remove f2fs_is_compress_algorithm_valid() for cleanup > > No logic changes. > > Signed-off-by: Chao Yu <yuchao0@huawei.com> > --- > fs/f2fs/compress.c | 5 ----- > fs/f2fs/f2fs.h | 5 ----- > fs/f2fs/file.c | 2 +- > 3 files changed, 1 insertion(+), 11 deletions(-) > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > index dfadbc78946c..869b047a4801 100644 > --- a/fs/f2fs/compress.c > +++ b/fs/f2fs/compress.c > @@ -574,11 +574,6 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > } > > -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > -{ > - return f2fs_cops[algorithm] != NULL; > -} > - > static mempool_t *compress_page_pool; > static int num_compress_pages = 512; > module_param(num_compress_pages, uint, 0444); > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > index b70c8d553439..17b45c2d2b04 100644 > --- a/fs/f2fs/f2fs.h > +++ b/fs/f2fs/f2fs.h > @@ -3882,7 +3882,6 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > bool f2fs_is_compress_backend_ready(struct inode *inode); > -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > int f2fs_init_compress_mempool(void); > void f2fs_destroy_compress_mempool(void); > void f2fs_do_decompress_pages(struct decompress_io_ctx *dic, bool verity); > @@ -3927,10 +3926,6 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > /* not support compression */ > return false; > } > -static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > -{ > - return false; > -} > static inline struct page *f2fs_compress_control_page(struct page *page) > { > WARN_ON_ONCE(1); > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > index 300355fe25f0..0453b441228d 100644 > --- a/fs/f2fs/file.c > +++ b/fs/f2fs/file.c > @@ -4016,7 +4016,7 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > f2fs_mark_inode_dirty_sync(inode, true); > > - if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > + if (!f2fs_is_compress_backend_ready(inode)) > f2fs_warn(sbi, "compression algorithm is successfully set, " > "but current kernel doesn't support this algorithm."); > out: > -- > 2.26.2 > > > > > > On 2020/10/30 12:10, Daeho Jeong wrote: > > From: Daeho Jeong <daehojeong@google.com> > > > > Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file > > compression option of a file. > > > > struct f2fs_comp_option { > > u8 algorithm; => compression algorithm > > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > > u8 log_cluster_size; => log scale cluster size > > => 2 ~ 8 > > }; > > > > struct f2fs_comp_option option; > > > > option.algorithm = 1; > > option.log_cluster_size = 7; > > > > ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); > > > > Signed-off-by: Daeho Jeong <daehojeong@google.com> > > --- > > > > v6: changed the function name of checking compression algorithm validity. > > v5: allowed to set algorithm which is not currently enabled by kernel. > > v4: changed commit message. > > v3: changed the error number more specific. > > folded in fix for build breakage reported by kernel test robot > > <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. > > v2: added ioctl description. > > --- > > fs/f2fs/compress.c | 5 +++++ > > fs/f2fs/f2fs.h | 7 ++++++ > > fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ > > 3 files changed, 66 insertions(+) > > > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > > index 7895186cc765..b0144670d320 100644 > > --- a/fs/f2fs/compress.c > > +++ b/fs/f2fs/compress.c > > @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > > } > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > +{ > > + return f2fs_cops[algorithm] != NULL; > > +} > > + > > static mempool_t *compress_page_pool; > > static int num_compress_pages = 512; > > module_param(num_compress_pages, uint, 0444); > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > > index a33c90cf979b..70a8a2196888 100644 > > --- a/fs/f2fs/f2fs.h > > +++ b/fs/f2fs/f2fs.h > > @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > > struct f2fs_sectrim_range) > > #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ > > struct f2fs_comp_option) > > +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ > > + struct f2fs_comp_option) > > /* > > * should be same as XFS_IOC_GOINGDOWN. > > @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > > bool f2fs_is_compress_backend_ready(struct inode *inode); > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > > int f2fs_init_compress_mempool(void); > > void f2fs_destroy_compress_mempool(void); > > void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); > > @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > > /* not support compression */ > > return false; > > } > > +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > +{ > > + return false; > > +} > > static inline struct page *f2fs_compress_control_page(struct page *page) > > { > > WARN_ON_ONCE(1); > > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > > index bd52df84219d..be56702e4939 100644 > > --- a/fs/f2fs/file.c > > +++ b/fs/f2fs/file.c > > @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) > > return 0; > > } > > +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > > +{ > > + struct inode *inode = file_inode(filp); > > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > > + struct f2fs_comp_option option; > > + int ret = 0; > > + > > + if (!f2fs_sb_has_compression(sbi)) > > + return -EOPNOTSUPP; > > + > > + if (!(filp->f_mode & FMODE_WRITE)) > > + return -EBADF; > > + > > + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, > > + sizeof(option))) > > + return -EFAULT; > > + > > + if (!f2fs_compressed_file(inode) || > > + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || > > + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || > > + option.algorithm >= COMPRESS_MAX) > > + return -EINVAL; > > + > > + file_start_write(filp); > > + inode_lock(inode); > > + > > + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { > > + ret = -EBUSY; > > + goto out; > > + } > > + > > + if (inode->i_size != 0) { > > + ret = -EFBIG; > > + goto out; > > + } > > + > > + F2FS_I(inode)->i_compress_algorithm = option.algorithm; > > + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; > > + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > > + f2fs_mark_inode_dirty_sync(inode, true); > > + > > + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > > + f2fs_warn(sbi, "compression algorithm is successfully set, " > > + "but current kernel doesn't support this algorithm."); > > +out: > > + inode_unlock(inode); > > + file_end_write(filp); > > + > > + return ret; > > +} > > + > > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > { > > if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) > > @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > return f2fs_sec_trim_file(filp, arg); > > case F2FS_IOC_GET_COMPRESS_OPTION: > > return f2fs_ioc_get_compress_option(filp, arg); > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > + return f2fs_ioc_set_compress_option(filp, arg); > > default: > > return -ENOTTY; > > } > > @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > > case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: > > case F2FS_IOC_SEC_TRIM_FILE: > > case F2FS_IOC_GET_COMPRESS_OPTION: > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > break; > > default: > > return -ENOIOCTLCMD; > > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-12-03 5:40 ` Jaegeuk Kim @ 2020-12-03 6:08 ` Jaegeuk Kim 2020-12-03 6:21 ` Chao Yu 0 siblings, 1 reply; 11+ messages in thread From: Jaegeuk Kim @ 2020-12-03 6:08 UTC (permalink / raw) To: Chao Yu; +Cc: Daeho Jeong, kernel-team, linux-kernel, linux-f2fs-devel On 12/02, Jaegeuk Kim wrote: > On 12/03, Chao Yu wrote: > > Jaegeuk, not sure, is it too late to merge this cleanup into original patch? > > Let me merge this on top of tree. Thanks. :) I integrated this into the original patch since I had to revise this commit. :( ("f2fs: avoid race condition for shinker count") > > > > > From a5c63ec58e0cda6eb5d186b46942eea46422b7a9 Mon Sep 17 00:00:00 2001 > > From: Chao Yu <yuchao0@huawei.com> > > Date: Thu, 3 Dec 2020 10:04:26 +0800 > > Subject: [PATCH] f2fs: remove f2fs_is_compress_algorithm_valid() for cleanup > > > > No logic changes. > > > > Signed-off-by: Chao Yu <yuchao0@huawei.com> > > --- > > fs/f2fs/compress.c | 5 ----- > > fs/f2fs/f2fs.h | 5 ----- > > fs/f2fs/file.c | 2 +- > > 3 files changed, 1 insertion(+), 11 deletions(-) > > > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > > index dfadbc78946c..869b047a4801 100644 > > --- a/fs/f2fs/compress.c > > +++ b/fs/f2fs/compress.c > > @@ -574,11 +574,6 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > > } > > > > -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > -{ > > - return f2fs_cops[algorithm] != NULL; > > -} > > - > > static mempool_t *compress_page_pool; > > static int num_compress_pages = 512; > > module_param(num_compress_pages, uint, 0444); > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > > index b70c8d553439..17b45c2d2b04 100644 > > --- a/fs/f2fs/f2fs.h > > +++ b/fs/f2fs/f2fs.h > > @@ -3882,7 +3882,6 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > > bool f2fs_is_compress_backend_ready(struct inode *inode); > > -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > > int f2fs_init_compress_mempool(void); > > void f2fs_destroy_compress_mempool(void); > > void f2fs_do_decompress_pages(struct decompress_io_ctx *dic, bool verity); > > @@ -3927,10 +3926,6 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > > /* not support compression */ > > return false; > > } > > -static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > -{ > > - return false; > > -} > > static inline struct page *f2fs_compress_control_page(struct page *page) > > { > > WARN_ON_ONCE(1); > > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > > index 300355fe25f0..0453b441228d 100644 > > --- a/fs/f2fs/file.c > > +++ b/fs/f2fs/file.c > > @@ -4016,7 +4016,7 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > > F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > > f2fs_mark_inode_dirty_sync(inode, true); > > > > - if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > > + if (!f2fs_is_compress_backend_ready(inode)) > > f2fs_warn(sbi, "compression algorithm is successfully set, " > > "but current kernel doesn't support this algorithm."); > > out: > > -- > > 2.26.2 > > > > > > > > > > > > On 2020/10/30 12:10, Daeho Jeong wrote: > > > From: Daeho Jeong <daehojeong@google.com> > > > > > > Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file > > > compression option of a file. > > > > > > struct f2fs_comp_option { > > > u8 algorithm; => compression algorithm > > > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > > > u8 log_cluster_size; => log scale cluster size > > > => 2 ~ 8 > > > }; > > > > > > struct f2fs_comp_option option; > > > > > > option.algorithm = 1; > > > option.log_cluster_size = 7; > > > > > > ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); > > > > > > Signed-off-by: Daeho Jeong <daehojeong@google.com> > > > --- > > > > > > v6: changed the function name of checking compression algorithm validity. > > > v5: allowed to set algorithm which is not currently enabled by kernel. > > > v4: changed commit message. > > > v3: changed the error number more specific. > > > folded in fix for build breakage reported by kernel test robot > > > <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. > > > v2: added ioctl description. > > > --- > > > fs/f2fs/compress.c | 5 +++++ > > > fs/f2fs/f2fs.h | 7 ++++++ > > > fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ > > > 3 files changed, 66 insertions(+) > > > > > > diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c > > > index 7895186cc765..b0144670d320 100644 > > > --- a/fs/f2fs/compress.c > > > +++ b/fs/f2fs/compress.c > > > @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) > > > return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; > > > } > > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > > +{ > > > + return f2fs_cops[algorithm] != NULL; > > > +} > > > + > > > static mempool_t *compress_page_pool; > > > static int num_compress_pages = 512; > > > module_param(num_compress_pages, uint, 0444); > > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > > > index a33c90cf979b..70a8a2196888 100644 > > > --- a/fs/f2fs/f2fs.h > > > +++ b/fs/f2fs/f2fs.h > > > @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > > > struct f2fs_sectrim_range) > > > #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ > > > struct f2fs_comp_option) > > > +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ > > > + struct f2fs_comp_option) > > > /* > > > * should be same as XFS_IOC_GOINGDOWN. > > > @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, > > > int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); > > > void f2fs_compress_write_end_io(struct bio *bio, struct page *page); > > > bool f2fs_is_compress_backend_ready(struct inode *inode); > > > +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); > > > int f2fs_init_compress_mempool(void); > > > void f2fs_destroy_compress_mempool(void); > > > void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); > > > @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) > > > /* not support compression */ > > > return false; > > > } > > > +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) > > > +{ > > > + return false; > > > +} > > > static inline struct page *f2fs_compress_control_page(struct page *page) > > > { > > > WARN_ON_ONCE(1); > > > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > > > index bd52df84219d..be56702e4939 100644 > > > --- a/fs/f2fs/file.c > > > +++ b/fs/f2fs/file.c > > > @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) > > > return 0; > > > } > > > +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) > > > +{ > > > + struct inode *inode = file_inode(filp); > > > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > > > + struct f2fs_comp_option option; > > > + int ret = 0; > > > + > > > + if (!f2fs_sb_has_compression(sbi)) > > > + return -EOPNOTSUPP; > > > + > > > + if (!(filp->f_mode & FMODE_WRITE)) > > > + return -EBADF; > > > + > > > + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, > > > + sizeof(option))) > > > + return -EFAULT; > > > + > > > + if (!f2fs_compressed_file(inode) || > > > + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || > > > + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || > > > + option.algorithm >= COMPRESS_MAX) > > > + return -EINVAL; > > > + > > > + file_start_write(filp); > > > + inode_lock(inode); > > > + > > > + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { > > > + ret = -EBUSY; > > > + goto out; > > > + } > > > + > > > + if (inode->i_size != 0) { > > > + ret = -EFBIG; > > > + goto out; > > > + } > > > + > > > + F2FS_I(inode)->i_compress_algorithm = option.algorithm; > > > + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; > > > + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; > > > + f2fs_mark_inode_dirty_sync(inode, true); > > > + > > > + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) > > > + f2fs_warn(sbi, "compression algorithm is successfully set, " > > > + "but current kernel doesn't support this algorithm."); > > > +out: > > > + inode_unlock(inode); > > > + file_end_write(filp); > > > + > > > + return ret; > > > +} > > > + > > > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > > { > > > if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) > > > @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > > > return f2fs_sec_trim_file(filp, arg); > > > case F2FS_IOC_GET_COMPRESS_OPTION: > > > return f2fs_ioc_get_compress_option(filp, arg); > > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > > + return f2fs_ioc_set_compress_option(filp, arg); > > > default: > > > return -ENOTTY; > > > } > > > @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > > > case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: > > > case F2FS_IOC_SEC_TRIM_FILE: > > > case F2FS_IOC_GET_COMPRESS_OPTION: > > > + case F2FS_IOC_SET_COMPRESS_OPTION: > > > break; > > > default: > > > return -ENOIOCTLCMD; > > > > > > _______________________________________________ > Linux-f2fs-devel mailing list > Linux-f2fs-devel@lists.sourceforge.net > https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl 2020-12-03 6:08 ` Jaegeuk Kim @ 2020-12-03 6:21 ` Chao Yu 0 siblings, 0 replies; 11+ messages in thread From: Chao Yu @ 2020-12-03 6:21 UTC (permalink / raw) To: Jaegeuk Kim; +Cc: Daeho Jeong, kernel-team, linux-kernel, linux-f2fs-devel On 2020/12/3 14:08, Jaegeuk Kim wrote: > On 12/02, Jaegeuk Kim wrote: >> On 12/03, Chao Yu wrote: >>> Jaegeuk, not sure, is it too late to merge this cleanup into original patch? >> >> Let me merge this on top of tree. Thanks. :) > > I integrated this into the original patch since I had to revise this commit. :( > ("f2fs: avoid race condition for shinker count") It's fine to me. :) Thanks, > >> >>> >>> From a5c63ec58e0cda6eb5d186b46942eea46422b7a9 Mon Sep 17 00:00:00 2001 >>> From: Chao Yu <yuchao0@huawei.com> >>> Date: Thu, 3 Dec 2020 10:04:26 +0800 >>> Subject: [PATCH] f2fs: remove f2fs_is_compress_algorithm_valid() for cleanup >>> >>> No logic changes. >>> >>> Signed-off-by: Chao Yu <yuchao0@huawei.com> >>> --- >>> fs/f2fs/compress.c | 5 ----- >>> fs/f2fs/f2fs.h | 5 ----- >>> fs/f2fs/file.c | 2 +- >>> 3 files changed, 1 insertion(+), 11 deletions(-) >>> >>> diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c >>> index dfadbc78946c..869b047a4801 100644 >>> --- a/fs/f2fs/compress.c >>> +++ b/fs/f2fs/compress.c >>> @@ -574,11 +574,6 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) >>> return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; >>> } >>> >>> -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) >>> -{ >>> - return f2fs_cops[algorithm] != NULL; >>> -} >>> - >>> static mempool_t *compress_page_pool; >>> static int num_compress_pages = 512; >>> module_param(num_compress_pages, uint, 0444); >>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h >>> index b70c8d553439..17b45c2d2b04 100644 >>> --- a/fs/f2fs/f2fs.h >>> +++ b/fs/f2fs/f2fs.h >>> @@ -3882,7 +3882,6 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, >>> int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); >>> void f2fs_compress_write_end_io(struct bio *bio, struct page *page); >>> bool f2fs_is_compress_backend_ready(struct inode *inode); >>> -bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); >>> int f2fs_init_compress_mempool(void); >>> void f2fs_destroy_compress_mempool(void); >>> void f2fs_do_decompress_pages(struct decompress_io_ctx *dic, bool verity); >>> @@ -3927,10 +3926,6 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) >>> /* not support compression */ >>> return false; >>> } >>> -static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) >>> -{ >>> - return false; >>> -} >>> static inline struct page *f2fs_compress_control_page(struct page *page) >>> { >>> WARN_ON_ONCE(1); >>> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c >>> index 300355fe25f0..0453b441228d 100644 >>> --- a/fs/f2fs/file.c >>> +++ b/fs/f2fs/file.c >>> @@ -4016,7 +4016,7 @@ static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) >>> F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; >>> f2fs_mark_inode_dirty_sync(inode, true); >>> >>> - if (!f2fs_is_compress_algorithm_valid(option.algorithm)) >>> + if (!f2fs_is_compress_backend_ready(inode)) >>> f2fs_warn(sbi, "compression algorithm is successfully set, " >>> "but current kernel doesn't support this algorithm."); >>> out: >>> -- >>> 2.26.2 >>> >>> >>> >>> >>> >>> On 2020/10/30 12:10, Daeho Jeong wrote: >>>> From: Daeho Jeong <daehojeong@google.com> >>>> >>>> Added a new F2FS_IOC_SET_COMPRESS_OPTION ioctl to change file >>>> compression option of a file. >>>> >>>> struct f2fs_comp_option { >>>> u8 algorithm; => compression algorithm >>>> => 0:lzo, 1:lz4, 2:zstd, 3:lzorle >>>> u8 log_cluster_size; => log scale cluster size >>>> => 2 ~ 8 >>>> }; >>>> >>>> struct f2fs_comp_option option; >>>> >>>> option.algorithm = 1; >>>> option.log_cluster_size = 7; >>>> >>>> ioctl(fd, F2FS_IOC_SET_COMPRESS_OPTION, &option); >>>> >>>> Signed-off-by: Daeho Jeong <daehojeong@google.com> >>>> --- >>>> >>>> v6: changed the function name of checking compression algorithm validity. >>>> v5: allowed to set algorithm which is not currently enabled by kernel. >>>> v4: changed commit message. >>>> v3: changed the error number more specific. >>>> folded in fix for build breakage reported by kernel test robot >>>> <lkp@intel.com> and Dan Carpenter <dan.carpenter@oracle.com>. >>>> v2: added ioctl description. >>>> --- >>>> fs/f2fs/compress.c | 5 +++++ >>>> fs/f2fs/f2fs.h | 7 ++++++ >>>> fs/f2fs/file.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++ >>>> 3 files changed, 66 insertions(+) >>>> >>>> diff --git a/fs/f2fs/compress.c b/fs/f2fs/compress.c >>>> index 7895186cc765..b0144670d320 100644 >>>> --- a/fs/f2fs/compress.c >>>> +++ b/fs/f2fs/compress.c >>>> @@ -514,6 +514,11 @@ bool f2fs_is_compress_backend_ready(struct inode *inode) >>>> return f2fs_cops[F2FS_I(inode)->i_compress_algorithm]; >>>> } >>>> +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) >>>> +{ >>>> + return f2fs_cops[algorithm] != NULL; >>>> +} >>>> + >>>> static mempool_t *compress_page_pool; >>>> static int num_compress_pages = 512; >>>> module_param(num_compress_pages, uint, 0444); >>>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h >>>> index a33c90cf979b..70a8a2196888 100644 >>>> --- a/fs/f2fs/f2fs.h >>>> +++ b/fs/f2fs/f2fs.h >>>> @@ -435,6 +435,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, >>>> struct f2fs_sectrim_range) >>>> #define F2FS_IOC_GET_COMPRESS_OPTION _IOR(F2FS_IOCTL_MAGIC, 21, \ >>>> struct f2fs_comp_option) >>>> +#define F2FS_IOC_SET_COMPRESS_OPTION _IOW(F2FS_IOCTL_MAGIC, 22, \ >>>> + struct f2fs_comp_option) >>>> /* >>>> * should be same as XFS_IOC_GOINGDOWN. >>>> @@ -3915,6 +3917,7 @@ bool f2fs_compress_write_end(struct inode *inode, void *fsdata, >>>> int f2fs_truncate_partial_cluster(struct inode *inode, u64 from, bool lock); >>>> void f2fs_compress_write_end_io(struct bio *bio, struct page *page); >>>> bool f2fs_is_compress_backend_ready(struct inode *inode); >>>> +bool f2fs_is_compress_algorithm_valid(unsigned char algorithm); >>>> int f2fs_init_compress_mempool(void); >>>> void f2fs_destroy_compress_mempool(void); >>>> void f2fs_decompress_pages(struct bio *bio, struct page *page, bool verity); >>>> @@ -3945,6 +3948,10 @@ static inline bool f2fs_is_compress_backend_ready(struct inode *inode) >>>> /* not support compression */ >>>> return false; >>>> } >>>> +static inline bool f2fs_is_compress_algorithm_valid(unsigned char algorithm) >>>> +{ >>>> + return false; >>>> +} >>>> static inline struct page *f2fs_compress_control_page(struct page *page) >>>> { >>>> WARN_ON_ONCE(1); >>>> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c >>>> index bd52df84219d..be56702e4939 100644 >>>> --- a/fs/f2fs/file.c >>>> +++ b/fs/f2fs/file.c >>>> @@ -3963,6 +3963,57 @@ static int f2fs_ioc_get_compress_option(struct file *filp, unsigned long arg) >>>> return 0; >>>> } >>>> +static int f2fs_ioc_set_compress_option(struct file *filp, unsigned long arg) >>>> +{ >>>> + struct inode *inode = file_inode(filp); >>>> + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); >>>> + struct f2fs_comp_option option; >>>> + int ret = 0; >>>> + >>>> + if (!f2fs_sb_has_compression(sbi)) >>>> + return -EOPNOTSUPP; >>>> + >>>> + if (!(filp->f_mode & FMODE_WRITE)) >>>> + return -EBADF; >>>> + >>>> + if (copy_from_user(&option, (struct f2fs_comp_option __user *)arg, >>>> + sizeof(option))) >>>> + return -EFAULT; >>>> + >>>> + if (!f2fs_compressed_file(inode) || >>>> + option.log_cluster_size < MIN_COMPRESS_LOG_SIZE || >>>> + option.log_cluster_size > MAX_COMPRESS_LOG_SIZE || >>>> + option.algorithm >= COMPRESS_MAX) >>>> + return -EINVAL; >>>> + >>>> + file_start_write(filp); >>>> + inode_lock(inode); >>>> + >>>> + if (f2fs_is_mmap_file(inode) || get_dirty_pages(inode)) { >>>> + ret = -EBUSY; >>>> + goto out; >>>> + } >>>> + >>>> + if (inode->i_size != 0) { >>>> + ret = -EFBIG; >>>> + goto out; >>>> + } >>>> + >>>> + F2FS_I(inode)->i_compress_algorithm = option.algorithm; >>>> + F2FS_I(inode)->i_log_cluster_size = option.log_cluster_size; >>>> + F2FS_I(inode)->i_cluster_size = 1 << option.log_cluster_size; >>>> + f2fs_mark_inode_dirty_sync(inode, true); >>>> + >>>> + if (!f2fs_is_compress_algorithm_valid(option.algorithm)) >>>> + f2fs_warn(sbi, "compression algorithm is successfully set, " >>>> + "but current kernel doesn't support this algorithm."); >>>> +out: >>>> + inode_unlock(inode); >>>> + file_end_write(filp); >>>> + >>>> + return ret; >>>> +} >>>> + >>>> long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >>>> { >>>> if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp))))) >>>> @@ -4053,6 +4104,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) >>>> return f2fs_sec_trim_file(filp, arg); >>>> case F2FS_IOC_GET_COMPRESS_OPTION: >>>> return f2fs_ioc_get_compress_option(filp, arg); >>>> + case F2FS_IOC_SET_COMPRESS_OPTION: >>>> + return f2fs_ioc_set_compress_option(filp, arg); >>>> default: >>>> return -ENOTTY; >>>> } >>>> @@ -4224,6 +4277,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) >>>> case F2FS_IOC_RESERVE_COMPRESS_BLOCKS: >>>> case F2FS_IOC_SEC_TRIM_FILE: >>>> case F2FS_IOC_GET_COMPRESS_OPTION: >>>> + case F2FS_IOC_SET_COMPRESS_OPTION: >>>> break; >>>> default: >>>> return -ENOIOCTLCMD; >>>> >> >> >> _______________________________________________ >> Linux-f2fs-devel mailing list >> Linux-f2fs-devel@lists.sourceforge.net >> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel > . > ^ permalink raw reply [flat|nested] 11+ messages in thread
* Re: [f2fs-dev] [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl 2020-10-30 4:10 [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl Daeho Jeong 2020-10-30 4:10 ` [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl Daeho Jeong @ 2020-10-30 6:11 ` Chao Yu 1 sibling, 0 replies; 11+ messages in thread From: Chao Yu @ 2020-10-30 6:11 UTC (permalink / raw) To: Daeho Jeong, linux-kernel, linux-f2fs-devel, kernel-team; +Cc: Daeho Jeong On 2020/10/30 12:10, Daeho Jeong wrote: > From: Daeho Jeong <daehojeong@google.com> > > Added a new F2FS_IOC_GET_COMPRESS_OPTION ioctl to get file compression > option of a file. > > struct f2fs_comp_option { > u8 algorithm; => compression algorithm > => 0:lzo, 1:lz4, 2:zstd, 3:lzorle > u8 log_cluster_size; => log scale cluster size > => 2 ~ 8 > }; > > struct f2fs_comp_option option; > > ioctl(fd, F2FS_IOC_GET_COMPRESS_OPTION, &option); > > Signed-off-by: Daeho Jeong <daehojeong@google.com> Reviewed-by: Chao Yu <yuchao0@huawei.com> Thanks, ^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2020-12-03 6:21 UTC | newest] Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2020-10-30 4:10 [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl Daeho Jeong 2020-10-30 4:10 ` [PATCH v7 2/2] f2fs: add F2FS_IOC_SET_COMPRESS_OPTION ioctl Daeho Jeong 2020-10-30 6:13 ` [f2fs-dev] " Chao Yu 2020-11-01 23:42 ` Daeho Jeong 2020-11-02 2:07 ` Chao Yu 2020-12-03 2:49 ` Chao Yu 2020-12-03 4:13 ` Daeho Jeong 2020-12-03 5:40 ` Jaegeuk Kim 2020-12-03 6:08 ` Jaegeuk Kim 2020-12-03 6:21 ` Chao Yu 2020-10-30 6:11 ` [f2fs-dev] [PATCH v7 1/2] f2fs: add F2FS_IOC_GET_COMPRESS_OPTION ioctl Chao Yu
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).