Commit c6d09b66 authored by Dave Chinner's avatar Dave Chinner Committed by Dave Chinner
Browse files

xfs: introduce a xfssyncd workqueue 



All of the work xfssyncd does is background functionality. There is
no need for a thread per filesystem to do this work - it can al be
managed by a global workqueue now they manage concurrency
effectively.

Introduce a new gglobal xfssyncd workqueue, and convert the periodic
work to use this new functionality. To do this, use a delayed work
construct to schedule the next running of the periodic sync work
for the filesystem. When the sync work is complete, queue a new
delayed work for the next running of the sync work.

For laptop mode, we wait on completion for the sync works, so ensure
that the sync work queuing interface can flush and wait for work to
complete to enable the work queue infrastructure to replace the
current sequence number and wakeup that is used.

Because the sync work does non-trivial amounts of work, mark the
new work queue as CPU intensive.

Signed-off-by: default avatarDave Chinner <dchinner@redhat.com>
Reviewed-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarAlex Elder <aelder@sgi.com>
parent e828776a

fs/xfs/linux-2.6/xfs_super.c

+17 −13
Original line number Diff line number Diff line
@@ -1191,22 +1191,12 @@ xfs_fs_sync_fs( 
		return -error;



	if (laptop_mode) {

		int	prev_sync_seq = mp->m_sync_seq;



		/*

		 * The disk must be active because we're syncing.

		 * We schedule xfssyncd now (now that the disk is

		 * active) instead of later (when it might not be).

		 */

		wake_up_process(mp->m_sync_task);

		/*

		 * We have to wait for the sync iteration to complete.

		 * If we don't, the disk activity caused by the sync

		 * will come after the sync is completed, and that

		 * triggers another sync from laptop mode.

		 */

		wait_event(mp->m_wait_single_sync_task,

				mp->m_sync_seq != prev_sync_seq);

		flush_delayed_work_sync(&mp->m_sync_work);

	}



	return 0;
@@ -1492,7 +1482,6 @@ xfs_fs_fill_super( 
	atomic_set(&mp->m_active_trans, 0);

	INIT_LIST_HEAD(&mp->m_sync_list);

	spin_lock_init(&mp->m_sync_lock);

	init_waitqueue_head(&mp->m_wait_single_sync_task);



	mp->m_super = sb;

	sb->s_fs_info = mp;
@@ -1833,13 +1822,27 @@ init_xfs_fs(void) 
	if (error)

		goto out_cleanup_procfs;



	/*

	 * max_active is set to 8 to give enough concurency to allow

	 * multiple work operations on each CPU to run. This allows multiple

	 * filesystems to be running sync work concurrently, and scales with

	 * the number of CPUs in the system.

	 */

	xfs_syncd_wq = alloc_workqueue("xfssyncd", WQ_CPU_INTENSIVE, 8);

	if (!xfs_syncd_wq) {

		error = -ENOMEM;

		goto out_sysctl_unregister;

	}



	vfs_initquota();



	error = register_filesystem(&xfs_fs_type);

	if (error)

		goto out_sysctl_unregister;

		goto out_destroy_xfs_syncd;

	return 0;



 out_destroy_xfs_syncd:

	destroy_workqueue(xfs_syncd_wq);

 out_sysctl_unregister:

	xfs_sysctl_unregister();

 out_cleanup_procfs:
@@ -1861,6 +1864,7 @@ exit_xfs_fs(void) 
{

	vfs_exitquota();

	unregister_filesystem(&xfs_fs_type);

	destroy_workqueue(xfs_syncd_wq);

	xfs_sysctl_unregister();

	xfs_cleanup_procfs();

	xfs_buf_terminate();

fs/xfs/linux-2.6/xfs_sync.c

+43 −45
Original line number Diff line number Diff line
@@ -39,6 +39,8 @@ 
#include <linux/kthread.h>

#include <linux/freezer.h>



struct workqueue_struct	*xfs_syncd_wq;	/* sync workqueue */



/*

 * The inode lookup is done in batches to keep the amount of lock traffic and

 * radix tree lookups to a minimum. The batch size is a trade off between
@@ -489,32 +491,6 @@ xfs_flush_inodes( 
	xfs_log_force(ip->i_mount, XFS_LOG_SYNC);

}



/*

 * Every sync period we need to unpin all items, reclaim inodes and sync

 * disk quotas.  We might need to cover the log to indicate that the

 * filesystem is idle and not frozen.

 */

STATIC void

xfs_sync_worker(

	struct xfs_mount *mp,

	void		*unused)

{

	int		error;



	if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {

		/* dgc: errors ignored here */

		if (mp->m_super->s_frozen == SB_UNFROZEN &&

		    xfs_log_need_covered(mp))

			error = xfs_fs_log_dummy(mp);

		else

			xfs_log_force(mp, 0);

		xfs_reclaim_inodes(mp, 0);

		error = xfs_qm_sync(mp, SYNC_TRYLOCK);

	}

	mp->m_sync_seq++;

	wake_up(&mp->m_wait_single_sync_task);

}



STATIC int

xfssyncd(

	void			*arg)
@@ -528,34 +504,19 @@ xfssyncd( 
	timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);

	for (;;) {

		if (list_empty(&mp->m_sync_list))

			timeleft = schedule_timeout_interruptible(timeleft);

			schedule_timeout_interruptible(timeleft);

		/* swsusp */

		try_to_freeze();

		if (kthread_should_stop() && list_empty(&mp->m_sync_list))

			break;



		spin_lock(&mp->m_sync_lock);

		/*

		 * We can get woken by laptop mode, to do a sync -

		 * that's the (only!) case where the list would be

		 * empty with time remaining.

		 */

		if (!timeleft || list_empty(&mp->m_sync_list)) {

			if (!timeleft)

				timeleft = xfs_syncd_centisecs *

							msecs_to_jiffies(10);

			INIT_LIST_HEAD(&mp->m_sync_work.w_list);

			list_add_tail(&mp->m_sync_work.w_list,

					&mp->m_sync_list);

		}

		list_splice_init(&mp->m_sync_list, &tmp);

		spin_unlock(&mp->m_sync_lock);



		list_for_each_entry_safe(work, n, &tmp, w_list) {

			(*work->w_syncer)(mp, work->w_data);

			list_del(&work->w_list);

			if (work == &mp->m_sync_work)

				continue;

			if (work->w_completion)

				complete(work->w_completion);

			kmem_free(work);
@@ -565,13 +526,49 @@ xfssyncd( 
	return 0;

}



static void

xfs_syncd_queue_sync(

	struct xfs_mount        *mp)

{

	queue_delayed_work(xfs_syncd_wq, &mp->m_sync_work,

				msecs_to_jiffies(xfs_syncd_centisecs * 10));

}



/*

 * Every sync period we need to unpin all items, reclaim inodes and sync

 * disk quotas.  We might need to cover the log to indicate that the

 * filesystem is idle and not frozen.

 */

STATIC void

xfs_sync_worker(

	struct work_struct *work)

{

	struct xfs_mount *mp = container_of(to_delayed_work(work),

					struct xfs_mount, m_sync_work);

	int		error;



	if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {

		/* dgc: errors ignored here */

		if (mp->m_super->s_frozen == SB_UNFROZEN &&

		    xfs_log_need_covered(mp))

			error = xfs_fs_log_dummy(mp);

		else

			xfs_log_force(mp, 0);

		xfs_reclaim_inodes(mp, 0);

		error = xfs_qm_sync(mp, SYNC_TRYLOCK);

	}



	/* queue us up again */

	xfs_syncd_queue_sync(mp);

}



int

xfs_syncd_init(

	struct xfs_mount	*mp)

{

	mp->m_sync_work.w_syncer = xfs_sync_worker;

	mp->m_sync_work.w_mount = mp;

	mp->m_sync_work.w_completion = NULL;

	INIT_DELAYED_WORK(&mp->m_sync_work, xfs_sync_worker);

	xfs_syncd_queue_sync(mp);



	mp->m_sync_task = kthread_run(xfssyncd, mp, "xfssyncd/%s", mp->m_fsname);

	if (IS_ERR(mp->m_sync_task))

		return -PTR_ERR(mp->m_sync_task);
@@ -582,6 +579,7 @@ void 
xfs_syncd_stop(

	struct xfs_mount	*mp)

{

	cancel_delayed_work_sync(&mp->m_sync_work);

	kthread_stop(mp->m_sync_task);

}

fs/xfs/linux-2.6/xfs_sync.h

+2 −0
Original line number Diff line number Diff line
@@ -32,6 +32,8 @@ typedef struct xfs_sync_work { 
#define SYNC_WAIT		0x0001	/* wait for i/o to complete */

#define SYNC_TRYLOCK		0x0002  /* only try to lock inodes */



extern struct workqueue_struct	*xfs_syncd_wq;	/* sync workqueue */



int xfs_syncd_init(struct xfs_mount *mp);

void xfs_syncd_stop(struct xfs_mount *mp);

fs/xfs/xfs_mount.h

+1 −3
Original line number Diff line number Diff line
@@ -203,12 +203,10 @@ typedef struct xfs_mount { 
	struct mutex		m_icsb_mutex;	/* balancer sync lock */

#endif

	struct xfs_mru_cache	*m_filestream;  /* per-mount filestream data */

	struct delayed_work	m_sync_work;	/* background sync work */

	struct task_struct	*m_sync_task;	/* generalised sync thread */

	xfs_sync_work_t		m_sync_work;	/* work item for VFS_SYNC */

	struct list_head	m_sync_list;	/* sync thread work item list */

	spinlock_t		m_sync_lock;	/* work item list lock */

	int			m_sync_seq;	/* sync thread generation no. */

	wait_queue_head_t	m_wait_single_sync_task;

	__int64_t		m_update_flags;	/* sb flags we need to update

						   on the next remount,rw */

	struct shrinker		m_inode_shrink;	/* inode reclaim shrinker */

CRA Git | Maintained and supported by SUSTech CRA and CCSE