Re: [PATCH 1/2] f2fs: add sysfs support for controlling the gc_thread

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Jeon,

On 07/31/2013 10:33 PM, Namjae Jeon wrote:

> From: Namjae Jeon <namjae.jeon@xxxxxxxxxxx>
> 
> Add sysfs entries to control the timing parameters for
> f2fs gc thread.
> 
> Various Sysfs options introduced are:
> gc_min_sleep_time: Min Sleep time for GC in ms
> gc_max_sleep_time: Max Sleep time for GC in ms
> gc_no_gc_sleep_time: Default Sleep time for GC in ms
> 
> Signed-off-by: Namjae Jeon <namjae.jeon@xxxxxxxxxxx>
> Signed-off-by: Pankaj Kumar <pankaj.km@xxxxxxxxxxx>
> ---
>  Documentation/ABI/testing/sysfs-fs-f2fs |   22 ++++++
>  Documentation/filesystems/f2fs.txt      |   26 +++++++
>  fs/f2fs/f2fs.h                          |    4 +
>  fs/f2fs/gc.c                            |   17 +++--
>  fs/f2fs/gc.h                            |   33 ++++----
>  fs/f2fs/super.c                         |  124 +++++++++++++++++++++++++++++++
>  6 files changed, 206 insertions(+), 20 deletions(-)
>  create mode 100644 Documentation/ABI/testing/sysfs-fs-f2fs
> 
> diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
> new file mode 100644
> index 0000000..5f44095
> --- /dev/null
> +++ b/Documentation/ABI/testing/sysfs-fs-f2fs
> @@ -0,0 +1,22 @@
> +What:		/sys/fs/f2fs/<disk>/gc_max_sleep_time
> +Date:		July 2013
> +Contact:	"Namjae Jeon" <namjae.jeon@xxxxxxxxxxx>
> +Description:
> +		 Controls the maximun sleep time for gc_thread. Time
> +		 is in milliseconds.
> +
> +What:		/sys/fs/f2fs/<disk>/gc_min_sleep_time
> +Date:		July 2013
> +Contact:	"Namjae Jeon" <namjae.jeon@xxxxxxxxxxx>
> +Description:
> +		 Controls the minimum sleep time for gc_thread. Time
> +		 is in milliseconds.
> +
> +What:		/sys/fs/f2fs/<disk>/gc_no_gc_sleep_time
> +Date:		July 2013
> +Contact:	"Namjae Jeon" <namjae.jeon@xxxxxxxxxxx>
> +Description:
> +		 Controls the default sleep time for gc_thread. Time
> +		 is in milliseconds.
> +
> +
> diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
> index 0500c19..2e9e873 100644
> --- a/Documentation/filesystems/f2fs.txt
> +++ b/Documentation/filesystems/f2fs.txt
> @@ -133,6 +133,32 @@ f2fs. Each file shows the whole f2fs information.
>   - current memory footprint consumed by f2fs.
>  
>  ================================================================================
> +SYSFS ENTRIES
> +================================================================================
> +
> +Information about mounted f2fs file systems can be found in
> +/sys/fs/f2fs.  Each mounted filesystem will have a directory in
> +/sys/fs/f2fs based on its device name (i.e., /sys/fs/f2fs/sda).
> +The files in each per-device directory are shown in table below.
> +
> +Files in /sys/fs/f2fs/<devname>
> +(see also Documentation/ABI/testing/sysfs-fs-f2fs)
> +..............................................................................
> + File                         Content
> +
> + gc_max_sleep_time            This tuning parameter controls the maximum sleep
> +                              time for the garbage collection thread. Time is
> +                              in milliseconds.
> +
> + gc_min_sleep_time            This tuning parameter controls the minimum sleep
> +                              time for the garbage collection thread. Time is
> +                              in milliseconds.
> +
> + gc_no_gc_sleep_time          This tuning parameter controls the default sleep
> +                              time for the garbage collection thread. Time is
> +                              in milliseconds.
> +
> +================================================================================
>  USAGE
>  ================================================================================
>  
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 78777cd..63813be 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -430,6 +430,10 @@ struct f2fs_sb_info {
>  #endif
>  	unsigned int last_victim[2];		/* last victim segment # */
>  	spinlock_t stat_lock;			/* lock for stat operations */
> +
> +	/* For sysfs suppport */
> +	struct kobject s_kobj;
> +	struct completion s_kobj_unregister;

What is this completion used for? Or it's an ahead design? I do not find synchronization
routines use it. Am I missing something?


>  };
>  
>  /*
> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
> index 35f9b1a..60d4f67 100644
> --- a/fs/f2fs/gc.c
> +++ b/fs/f2fs/gc.c
> @@ -29,10 +29,11 @@ static struct kmem_cache *winode_slab;
>  static int gc_thread_func(void *data)
>  {
>  	struct f2fs_sb_info *sbi = data;
> +	struct f2fs_gc_kthread *gc_th = sbi->gc_thread;
>  	wait_queue_head_t *wq = &sbi->gc_thread->gc_wait_queue_head;
>  	long wait_ms;
>  
> -	wait_ms = GC_THREAD_MIN_SLEEP_TIME;
> +	wait_ms = gc_th->min_sleep_time;
>  
>  	do {
>  		if (try_to_freeze())
> @@ -45,7 +46,7 @@ static int gc_thread_func(void *data)
>  			break;
>  
>  		if (sbi->sb->s_writers.frozen >= SB_FREEZE_WRITE) {
> -			wait_ms = GC_THREAD_MAX_SLEEP_TIME;
> +			wait_ms = increase_sleep_time(gc_th, wait_ms);
>  			continue;
>  		}
>  
> @@ -66,15 +67,15 @@ static int gc_thread_func(void *data)
>  			continue;
>  
>  		if (!is_idle(sbi)) {
> -			wait_ms = increase_sleep_time(wait_ms);
> +			wait_ms = increase_sleep_time(gc_th, wait_ms);
>  			mutex_unlock(&sbi->gc_mutex);
>  			continue;
>  		}
>  
>  		if (has_enough_invalid_blocks(sbi))
> -			wait_ms = decrease_sleep_time(wait_ms);
> +			wait_ms = decrease_sleep_time(gc_th, wait_ms);
>  		else
> -			wait_ms = increase_sleep_time(wait_ms);
> +			wait_ms = increase_sleep_time(gc_th, wait_ms);
>  
>  #ifdef CONFIG_F2FS_STAT_FS
>  		sbi->bg_gc++;
> @@ -82,7 +83,7 @@ static int gc_thread_func(void *data)
>  
>  		/* if return value is not zero, no victim was selected */
>  		if (f2fs_gc(sbi))
> -			wait_ms = GC_THREAD_NOGC_SLEEP_TIME;
> +			wait_ms = gc_th->no_gc_sleep_time;
>  	} while (!kthread_should_stop());
>  	return 0;
>  }
> @@ -101,6 +102,10 @@ int start_gc_thread(struct f2fs_sb_info *sbi)
>  		goto out;
>  	}
>  
> +	gc_th->min_sleep_time = DEF_GC_THREAD_MIN_SLEEP_TIME;
> +	gc_th->max_sleep_time = DEF_GC_THREAD_MAX_SLEEP_TIME;
> +	gc_th->no_gc_sleep_time = DEF_GC_THREAD_NOGC_SLEEP_TIME;
> +
>  	sbi->gc_thread = gc_th;
>  	init_waitqueue_head(&sbi->gc_thread->gc_wait_queue_head);
>  	sbi->gc_thread->f2fs_gc_task = kthread_run(gc_thread_func, sbi,
> diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
> index 2c6a6bd..f4bf44c 100644
> --- a/fs/f2fs/gc.h
> +++ b/fs/f2fs/gc.h
> @@ -13,9 +13,9 @@
>  						 * whether IO subsystem is idle
>  						 * or not
>  						 */
> -#define GC_THREAD_MIN_SLEEP_TIME	30000	/* milliseconds */
> -#define GC_THREAD_MAX_SLEEP_TIME	60000
> -#define GC_THREAD_NOGC_SLEEP_TIME	300000	/* wait 5 min */
> +#define DEF_GC_THREAD_MIN_SLEEP_TIME	30000	/* milliseconds */
> +#define DEF_GC_THREAD_MAX_SLEEP_TIME	60000
> +#define DEF_GC_THREAD_NOGC_SLEEP_TIME	300000	/* wait 5 min */
>  #define LIMIT_INVALID_BLOCK	40 /* percentage over total user space */
>  #define LIMIT_FREE_BLOCK	40 /* percentage over invalid + free space */
>  
> @@ -25,6 +25,11 @@
>  struct f2fs_gc_kthread {
>  	struct task_struct *f2fs_gc_task;
>  	wait_queue_head_t gc_wait_queue_head;
> +
> +	/* for gc sleep time */
> +	unsigned int min_sleep_time;
> +	unsigned int max_sleep_time;
> +	unsigned int no_gc_sleep_time;

Though these attributes are used for gc thread, and in current design gc_thread is always
singleton per f2fs_sb, but thare're in fact f2fs sb infos. So I think it's to attach
these to f2fs_sb_info. What's your opinion?

Thanks,
Gu

>  };
>  
>  struct inode_entry {
> @@ -56,25 +61,25 @@ static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi)
>  	return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100;
>  }
>  
> -static inline long increase_sleep_time(long wait)
> +static inline long increase_sleep_time(struct f2fs_gc_kthread *gc_th, long wait)
>  {
> -	if (wait == GC_THREAD_NOGC_SLEEP_TIME)
> +	if (wait == gc_th->no_gc_sleep_time)
>  		return wait;
>  
> -	wait += GC_THREAD_MIN_SLEEP_TIME;
> -	if (wait > GC_THREAD_MAX_SLEEP_TIME)
> -		wait = GC_THREAD_MAX_SLEEP_TIME;
> +	wait += gc_th->min_sleep_time;
> +	if (wait > gc_th->max_sleep_time)
> +		wait = gc_th->max_sleep_time;
>  	return wait;
>  }
>  
> -static inline long decrease_sleep_time(long wait)
> +static inline long decrease_sleep_time(struct f2fs_gc_kthread *gc_th, long wait)
>  {
> -	if (wait == GC_THREAD_NOGC_SLEEP_TIME)
> -		wait = GC_THREAD_MAX_SLEEP_TIME;
> +	if (wait == gc_th->no_gc_sleep_time)
> +		wait = gc_th->max_sleep_time;
>  
> -	wait -= GC_THREAD_MIN_SLEEP_TIME;
> -	if (wait <= GC_THREAD_MIN_SLEEP_TIME)
> -		wait = GC_THREAD_MIN_SLEEP_TIME;
> +	wait -= gc_th->min_sleep_time;
> +	if (wait <= gc_th->min_sleep_time)
> +		wait = gc_th->min_sleep_time;
>  	return wait;
>  }
>  
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index 70dbb31..30de280 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -23,17 +23,21 @@
>  #include <linux/exportfs.h>
>  #include <linux/blkdev.h>
>  #include <linux/f2fs_fs.h>
> +#include <linux/kobject.h>
> +#include <linux/sysfs.h>
>  
>  #include "f2fs.h"
>  #include "node.h"
>  #include "segment.h"
>  #include "xattr.h"
> +#include "gc.h"
>  
>  #define CREATE_TRACE_POINTS
>  #include <trace/events/f2fs.h>
>  
>  static struct proc_dir_entry *f2fs_proc_root;
>  static struct kmem_cache *f2fs_inode_cachep;
> +static struct kset *f2fs_kset;
>  
>  enum {
>  	Opt_gc_background,
> @@ -59,6 +63,114 @@ static match_table_t f2fs_tokens = {
>  	{Opt_err, NULL},
>  };
>  
> +/*Sysfs support for F2fs */
> +struct f2fs_attr {
> +	struct attribute attr;
> +	ssize_t (*show)(struct f2fs_attr *, struct f2fs_sb_info *, char *);
> +	ssize_t (*store)(struct f2fs_attr *, struct f2fs_sb_info *,
> +			 const char *, size_t);
> +	int offset;
> +};
> +
> +static ssize_t f2fs_sbi_show(struct f2fs_attr *a,
> +			   struct f2fs_sb_info *sbi, char *buf)
> +{
> +	struct f2fs_gc_kthread *gc_kth = sbi->gc_thread;
> +	unsigned int *ui;
> +
> +	if (!gc_kth)
> +		return -EFAULT;
> +
> +	ui = (unsigned int *) (((char *)gc_kth) + a->offset);
> +
> +	return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
> +}
> +
> +static ssize_t f2fs_sbi_store(struct f2fs_attr *a,
> +			    struct f2fs_sb_info *sbi,
> +			    const char *buf, size_t count)
> +{
> +	struct f2fs_gc_kthread *gc_kth = sbi->gc_thread;
> +	unsigned long t;
> +	unsigned int *ui;
> +	ssize_t ret;
> +
> +	if (!gc_kth)
> +		return -EFAULT;
> +
> +	ui = (unsigned int *) (((char *)gc_kth) + a->offset);
> +
> +	ret = kstrtoul(skip_spaces(buf), 0, &t);
> +	if (ret < 0)
> +		return ret;
> +	*ui = t;
> +	return count;
> +}
> +
> +static ssize_t f2fs_attr_show(struct kobject *kobj,
> +				struct attribute *attr, char *buf)
> +{
> +	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
> +								s_kobj);
> +	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
> +
> +	return a->show ? a->show(a, sbi, buf) : 0;
> +}
> +
> +static ssize_t f2fs_attr_store(struct kobject *kobj, struct attribute *attr,
> +						const char *buf, size_t len)
> +{
> +	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
> +									s_kobj);
> +	struct f2fs_attr *a = container_of(attr, struct f2fs_attr, attr);
> +
> +	return a->store ? a->store(a, sbi, buf, len) : 0;
> +}
> +
> +static void f2fs_sb_release(struct kobject *kobj)
> +{
> +	struct f2fs_sb_info *sbi = container_of(kobj, struct f2fs_sb_info,
> +								s_kobj);
> +	complete(&sbi->s_kobj_unregister);
> +}
> +
> +#define F2FS_ATTR_OFFSET(_name, _mode, _show, _store, _elname) \
> +static struct f2fs_attr f2fs_attr_##_name = {			\
> +	.attr = {.name = __stringify(_name), .mode = _mode },	\
> +	.show	= _show,					\
> +	.store	= _store,					\
> +	.offset = offsetof(struct f2fs_gc_kthread, _elname),	\
> +}
> +
> +#define F2FS_ATTR(name, mode, show, store) \
> +static struct f2fs_attr f2fs_attr_##name = __ATTR(name, mode, show, store)
> +
> +#define F2FS_RW_ATTR(name, elname)	\
> +	F2FS_ATTR_OFFSET(name, 0644, f2fs_sbi_show, f2fs_sbi_store, elname)
> +
> +F2FS_RW_ATTR(gc_min_sleep_time, min_sleep_time);
> +F2FS_RW_ATTR(gc_max_sleep_time, max_sleep_time);
> +F2FS_RW_ATTR(gc_no_gc_sleep_time, no_gc_sleep_time);
> +
> +#define ATTR_LIST(name) (&f2fs_attr_##name.attr)
> +static struct attribute *f2fs_attrs[] = {
> +	ATTR_LIST(gc_min_sleep_time),
> +	ATTR_LIST(gc_max_sleep_time),
> +	ATTR_LIST(gc_no_gc_sleep_time),
> +	NULL,
> +};
> +
> +static const struct sysfs_ops f2fs_attr_ops = {
> +	.show   = f2fs_attr_show,
> +	.store  = f2fs_attr_store,
> +};
> +
> +static struct kobj_type f2fs_ktype = {
> +	.default_attrs  = f2fs_attrs,
> +	.sysfs_ops      = &f2fs_attr_ops,
> +	.release        = f2fs_sb_release,
> +};
> +
>  void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...)
>  {
>  	struct va_format vaf;
> @@ -243,6 +355,7 @@ static void f2fs_put_super(struct super_block *sb)
>  	destroy_segment_manager(sbi);
>  
>  	kfree(sbi->ckpt);
> +	kobject_del(&sbi->s_kobj);
>  
>  	sb->s_fs_info = NULL;
>  	brelse(sbi->raw_super_buf);
> @@ -818,6 +931,13 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)
>  					"the device does not support discard");
>  	}
>  
> +	sbi->s_kobj.kset = f2fs_kset;
> +	init_completion(&sbi->s_kobj_unregister);
> +	err = kobject_init_and_add(&sbi->s_kobj, &f2fs_ktype, NULL,
> +							"%s", sb->s_id);
> +	if (err)
> +		goto fail;
> +
>  	return 0;
>  fail:
>  	stop_gc_thread(sbi);
> @@ -892,6 +1012,9 @@ static int __init init_f2fs_fs(void)
>  	err = create_checkpoint_caches();
>  	if (err)
>  		goto fail;
> +	f2fs_kset = kset_create_and_add("f2fs", NULL, fs_kobj);
> +	if (!f2fs_kset)
> +		goto fail;
>  	err = register_filesystem(&f2fs_fs_type);
>  	if (err)
>  		goto fail;
> @@ -910,6 +1033,7 @@ static void __exit exit_f2fs_fs(void)
>  	destroy_gc_caches();
>  	destroy_node_manager_caches();
>  	destroy_inodecache();
> +	kset_unregister(f2fs_kset);
>  }
>  
>  module_init(init_f2fs_fs)


--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Linux Ext4 Filesystem]     [Union Filesystem]     [Filesystem Testing]     [Ceph Users]     [Ecryptfs]     [AutoFS]     [Kernel Newbies]     [Share Photos]     [Security]     [Netfilter]     [Bugtraq]     [Yosemite News]     [MIPS Linux]     [ARM Linux]     [Linux Security]     [Linux Cachefs]     [Reiser Filesystem]     [Linux RAID]     [Samba]     [Device Mapper]     [CEPH Development]
  Powered by Linux