From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1427160AbdDVBNs (ORCPT ); Fri, 21 Apr 2017 21:13:48 -0400 Received: from szxga01-in.huawei.com ([45.249.212.187]:5783 "EHLO dggrg01-dlp.huawei.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1425059AbdDVBMI (ORCPT ); Fri, 21 Apr 2017 21:12:08 -0400 Subject: Re: [PATCH 1/3] f2fs: add ioctl to flush data from faster device to cold area To: Jaegeuk Kim , , , References: <20170419014520.12536-1-jaegeuk@kernel.org> From: Chao Yu Message-ID: Date: Sat, 22 Apr 2017 09:11:56 +0800 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:45.0) Gecko/20100101 Thunderbird/45.0 MIME-Version: 1.0 In-Reply-To: <20170419014520.12536-1-jaegeuk@kernel.org> Content-Type: text/plain; charset="windows-1252" Content-Transfer-Encoding: 7bit X-Originating-IP: [10.134.22.195] X-CFilter-Loop: Reflected X-Mirapoint-Virus-RAPID-Raw: score=unknown(0), refid=str=0001.0A090206.58FAADE1.001F,ss=1,re=0.000,recu=0.000,reip=0.000,cl=1,cld=1,fgs=0, ip=0.0.0.0, so=2014-11-16 11:51:01, dmn=2013-03-21 17:37:32 X-Mirapoint-Loop-Id: 77544021a9647d5e8c729ca6b63f5104 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 2017/4/19 9:45, Jaegeuk Kim wrote: > This patch adds an ioctl to flush data in faster device to cold area. User can > give device number and number of segments to move. It doesn't move it if there > is only one device. > > The parameter looks like: > > struct f2fs_flush_device { > u32 dev_num; /* device number to flush */ > u32 segments; /* # of segments to flush */ > }; > > Signed-off-by: Jaegeuk Kim > --- > fs/f2fs/f2fs.h | 12 ++++++++-- > fs/f2fs/file.c | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++-- > fs/f2fs/gc.c | 19 +++++++++++----- > fs/f2fs/segment.c | 14 ++++++++---- > fs/f2fs/segment.h | 4 +++- > 5 files changed, 102 insertions(+), 14 deletions(-) > > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h > index 562db8989a4e..c28e8e7d6a5f 100644 > --- a/fs/f2fs/f2fs.h > +++ b/fs/f2fs/f2fs.h > @@ -280,6 +280,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, > #define F2FS_IOC_DEFRAGMENT _IO(F2FS_IOCTL_MAGIC, 8) > #define F2FS_IOC_MOVE_RANGE _IOWR(F2FS_IOCTL_MAGIC, 9, \ > struct f2fs_move_range) > +#define F2FS_IOC_FLUSH_DEVICE _IOW(F2FS_IOCTL_MAGIC, 10, \ > + struct f2fs_flush_device) > > #define F2FS_IOC_SET_ENCRYPTION_POLICY FS_IOC_SET_ENCRYPTION_POLICY > #define F2FS_IOC_GET_ENCRYPTION_POLICY FS_IOC_GET_ENCRYPTION_POLICY > @@ -316,6 +318,11 @@ struct f2fs_move_range { > u64 len; /* size to move */ > }; > > +struct f2fs_flush_device { > + u32 dev_num; /* device number to flush */ > + u32 segments; /* # of segments to flush */ > +}; > + > /* > * For INODE and NODE manager > */ > @@ -941,7 +948,7 @@ struct f2fs_sb_info { > int bg_gc; /* background gc calls */ > unsigned int ndirty_inode[NR_INODE_TYPE]; /* # of dirty inodes */ > #endif > - unsigned int last_victim[2]; /* last victim segment # */ > + unsigned int last_victim[4]; /* last victim segment # */ unsigned int last_victim[MAX_GC_POLICY]; > spinlock_t stat_lock; /* lock for stat operations */ > > /* For sysfs suppport */ > @@ -2323,7 +2330,8 @@ int f2fs_migrate_page(struct address_space *mapping, struct page *newpage, > int start_gc_thread(struct f2fs_sb_info *sbi); > void stop_gc_thread(struct f2fs_sb_info *sbi); > block_t start_bidx_of_node(unsigned int node_ofs, struct inode *inode); > -int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background); > +int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background, > + unsigned int segno); > void build_gc_manager(struct f2fs_sb_info *sbi); > > /* > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c > index 0ac833dd2634..561ecb46007b 100644 > --- a/fs/f2fs/file.c > +++ b/fs/f2fs/file.c > @@ -1855,7 +1855,7 @@ static int f2fs_ioc_gc(struct file *filp, unsigned long arg) > mutex_lock(&sbi->gc_mutex); > } > > - ret = f2fs_gc(sbi, sync, true); > + ret = f2fs_gc(sbi, sync, true, NULL_SEGNO); > out: > mnt_drop_write_file(filp); > return ret; > @@ -2211,6 +2211,67 @@ static int f2fs_ioc_move_range(struct file *filp, unsigned long arg) > return err; > } > > +static int f2fs_ioc_flush_device(struct file *filp, unsigned long arg) > +{ > + struct inode *inode = file_inode(filp); > + struct f2fs_sb_info *sbi = F2FS_I_SB(inode); > + unsigned int start_segno = 0, end_segno = 0; > + unsigned int dev_start_segno = 0, dev_end_segno = 0; > + struct f2fs_flush_device range; > + int ret; > + > + if (!capable(CAP_SYS_ADMIN)) > + return -EPERM; > + > + if (f2fs_readonly(sbi->sb)) > + return -EROFS; > + > + if (copy_from_user(&range, (struct f2fs_flush_device __user *)arg, > + sizeof(range))) > + return -EFAULT; > + > + if (sbi->s_ndevs <= 1 || sbi->s_ndevs - 1 <= range.dev_num) { > + f2fs_msg(sbi->sb, KERN_WARNING, "Can't flush %u in %d\n", > + range.dev_num, sbi->s_ndevs); > + return -EINVAL; > + } > + > + ret = mnt_want_write_file(filp); > + if (ret) > + return ret; > + > + if (range.dev_num != 0) > + dev_start_segno = GET_SEGNO(sbi, FDEV(range.dev_num).start_blk); > + dev_end_segno = GET_SEGNO(sbi, FDEV(range.dev_num).end_blk); > + > + start_segno = sbi->last_victim[FLUSH_DEVICE]; > + if (start_segno < dev_start_segno || start_segno >= dev_end_segno) > + start_segno = dev_start_segno; > + end_segno = min(start_segno + range.segments, dev_end_segno); > + > + while (start_segno < end_segno) { > + if (!mutex_trylock(&sbi->gc_mutex)) { > + ret = -EBUSY; > + goto out; > + } > + sbi->last_victim[GC_CB] = end_segno + 1; > + sbi->last_victim[GC_GREEDY] = end_segno + 1; > + sbi->last_victim[ALLOC_NEXT] = end_segno + 1; > + ret = f2fs_gc(sbi, true, true, start_segno); > + sbi->last_victim[ALLOC_NEXT] = 0; Better to update it under gc_mutex lock to avoid contention. > + if (ret == -EAGAIN) > + ret = 0; > + else if (ret < 0) > + break; > + start_segno++; > + } > + sbi->last_victim[FLUSH_DEVICE] = start_segno; Ditto. > +out: > + mnt_drop_write_file(filp); > + return ret; > +} > + > + > long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > { > switch (cmd) { > @@ -2248,6 +2309,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > return f2fs_ioc_defragment(filp, arg); > case F2FS_IOC_MOVE_RANGE: > return f2fs_ioc_move_range(filp, arg); > + case F2FS_IOC_FLUSH_DEVICE: > + return f2fs_ioc_flush_device(filp, arg); > default: > return -ENOTTY; > } > @@ -2315,8 +2378,8 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) > case F2FS_IOC_GARBAGE_COLLECT: > case F2FS_IOC_WRITE_CHECKPOINT: > case F2FS_IOC_DEFRAGMENT: > - break; > case F2FS_IOC_MOVE_RANGE: > + case F2FS_IOC_FLUSH_DEVICE: > break; > default: > return -ENOIOCTLCMD; > diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c > index 9172112d6246..d988c1aaf132 100644 > --- a/fs/f2fs/gc.c > +++ b/fs/f2fs/gc.c > @@ -84,7 +84,7 @@ static int gc_thread_func(void *data) > stat_inc_bggc_count(sbi); > > /* if return value is not zero, no victim was selected */ > - if (f2fs_gc(sbi, test_opt(sbi, FORCE_FG_GC), true)) > + if (f2fs_gc(sbi, test_opt(sbi, FORCE_FG_GC), true, NULL_SEGNO)) > wait_ms = gc_th->no_gc_sleep_time; > > trace_f2fs_background_gc(sbi->sb, wait_ms, > @@ -308,6 +308,14 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi, > p.min_segno = NULL_SEGNO; > p.min_cost = get_max_cost(sbi, &p); > > + if (*result != NULL_SEGNO) { > + if (IS_DATASEG(get_seg_entry(sbi, *result)->type) && > + get_valid_blocks(sbi, *result, false) && > + !sec_usage_check(sbi, GET_SEC_FROM_SEG(sbi, *result))) > + p.min_segno = *result; > + goto out; > + } > + > if (p.max_search == 0) > goto out; > > @@ -912,7 +920,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > * - mutex_lock(sentry_lock) - change_curseg() > * - lock_page(sum_page) > */ > - > if (type == SUM_TYPE_NODE) > gc_node_segment(sbi, sum->entries, segno, gc_type); > else > @@ -939,9 +946,9 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > return sec_freed; > } > > -int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background) > +int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, > + bool background, unsigned int segno) > { > - unsigned int segno; > int gc_type = sync ? FG_GC : BG_GC; > int sec_freed = 0; > int ret = -EINVAL; > @@ -990,8 +997,10 @@ int f2fs_gc(struct f2fs_sb_info *sbi, bool sync, bool background) > sbi->cur_victim_sec = NULL_SEGNO; > > if (!sync) { > - if (has_not_enough_free_secs(sbi, sec_freed, 0)) > + if (has_not_enough_free_secs(sbi, sec_freed, 0)) { > + segno = NULL_SEGNO; > goto gc_more; > + } > > if (gc_type == FG_GC) > ret = write_checkpoint(sbi, &cpc); > diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c > index 58cfbe3d4dc7..88489d3156ab 100644 > --- a/fs/f2fs/segment.c > +++ b/fs/f2fs/segment.c > @@ -401,7 +401,7 @@ void f2fs_balance_fs(struct f2fs_sb_info *sbi, bool need) > */ > if (has_not_enough_free_secs(sbi, 0, 0)) { > mutex_lock(&sbi->gc_mutex); > - f2fs_gc(sbi, false, false); > + f2fs_gc(sbi, false, false, NULL_SEGNO); > } > } > > @@ -1566,6 +1566,8 @@ static unsigned int __get_next_segno(struct f2fs_sb_info *sbi, int type) > if (type == CURSEG_HOT_DATA || IS_NODESEG(type)) > return 0; > > + if (sbi->last_victim[ALLOC_NEXT]) > + return sbi->last_victim[ALLOC_NEXT]; > return CURSEG_I(sbi, type)->segno; > } > > @@ -1663,12 +1665,15 @@ static int get_ssr_segment(struct f2fs_sb_info *sbi, int type) > { > struct curseg_info *curseg = CURSEG_I(sbi, type); > const struct victim_selection *v_ops = DIRTY_I(sbi)->v_ops; > + unsigned segno = 0; > int i, cnt; > bool reversed = false; > > /* need_SSR() already forces to do this */ > - if (v_ops->get_victim(sbi, &(curseg)->next_segno, BG_GC, type, SSR)) > + if (v_ops->get_victim(sbi, &segno, BG_GC, type, SSR)) { > + curseg->next_segno = segno; > return 1; > + } > > /* For node segments, let's do SSR more intensively */ > if (IS_NODESEG(type)) { > @@ -1692,9 +1697,10 @@ static int get_ssr_segment(struct f2fs_sb_info *sbi, int type) > for (; cnt-- > 0; reversed ? i-- : i++) { > if (i == type) > continue; > - if (v_ops->get_victim(sbi, &(curseg)->next_segno, > - BG_GC, i, SSR)) > + if (v_ops->get_victim(sbi, &segno, BG_GC, i, SSR)) { > + curseg->next_segno = segno; > return 1; > + } > } > return 0; > } > diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h > index 5f6ef163aa8f..1d35f8d298cd 100644 > --- a/fs/f2fs/segment.h > +++ b/fs/f2fs/segment.h > @@ -138,7 +138,9 @@ enum { > */ > enum { > GC_CB = 0, > - GC_GREEDY > + GC_GREEDY, > + ALLOC_NEXT, > + FLUSH_DEVICE, add MAX_GC_POLICY here? Thanks, > }; > > /* >