[net-next-2.6.git] / mm / pdflush.c

/*
 * mm/pdflush.c - worker threads for writing back filesystem data
 *
 * Copyright (C) 2002, Linus Torvalds.
 *
 * 09Apr2002	akpm@zip.com.au
 *		Initial version
 * 29Feb2004	kaos@sgi.com
 *		Move worker thread creation to kthread to avoid chewing
 *		up stack space with nested calls to kernel_thread.
 */

#include <linux/sched.h>
#include <linux/list.h>
#include <linux/signal.h>
#include <linux/spinlock.h>
#include <linux/gfp.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>		// Needed by writeback.h
#include <linux/writeback.h>	// Prototypes pdflush_operation()
#include <linux/kthread.h>
#include <linux/cpuset.h>


/*
 * Minimum and maximum number of pdflush instances
 */
#define MIN_PDFLUSH_THREADS	2
#define MAX_PDFLUSH_THREADS	8

static void start_one_pdflush_thread(void);


/*
 * The pdflush threads are worker threads for writing back dirty data.
 * Ideally, we'd like one thread per active disk spindle.  But the disk
 * topology is very hard to divine at this level.   Instead, we take
 * care in various places to prevent more than one pdflush thread from
 * performing writeback against a single filesystem.  pdflush threads
 * have the PF_FLUSHER flag set in current->flags to aid in this.
 */

/*
 * All the pdflush threads.  Protected by pdflush_lock
 */
static LIST_HEAD(pdflush_list);
static DEFINE_SPINLOCK(pdflush_lock);

/*
 * The count of currently-running pdflush threads.  Protected
 * by pdflush_lock.
 *
 * Readable by sysctl, but not writable.  Published to userspace at
 * /proc/sys/vm/nr_pdflush_threads.
 */
int nr_pdflush_threads = 0;

/*
 * The time at which the pdflush thread pool last went empty
 */
static unsigned long last_empty_jifs;

/*
 * The pdflush thread.
 *
 * Thread pool management algorithm:
 * 
 * - The minimum and maximum number of pdflush instances are bound
 *   by MIN_PDFLUSH_THREADS and MAX_PDFLUSH_THREADS.
 * 
 * - If there have been no idle pdflush instances for 1 second, create
 *   a new one.
 * 
 * - If the least-recently-went-to-sleep pdflush thread has been asleep
 *   for more than one second, terminate a thread.
 */

/*
 * A structure for passing work to a pdflush thread.  Also for passing
 * state information between pdflush threads.  Protected by pdflush_lock.
 */
struct pdflush_work {
	struct task_struct *who;	/* The thread */
	void (*fn)(unsigned long);	/* A callback function */
	unsigned long arg0;		/* An argument to the callback */
	struct list_head list;		/* On pdflush_list, when idle */
	unsigned long when_i_went_to_sleep;
};

static int __pdflush(struct pdflush_work *my_work)
{
	current->flags |= PF_FLUSHER | PF_SWAPWRITE;
	my_work->fn = NULL;
	my_work->who = current;
	INIT_LIST_HEAD(&my_work->list);

	spin_lock_irq(&pdflush_lock);
	nr_pdflush_threads++;
	for ( ; ; ) {
		struct pdflush_work *pdf;

		set_current_state(TASK_INTERRUPTIBLE);
		list_move(&my_work->list, &pdflush_list);
		my_work->when_i_went_to_sleep = jiffies;
		spin_unlock_irq(&pdflush_lock);

		schedule();
		if (try_to_freeze()) {
			spin_lock_irq(&pdflush_lock);
			continue;
		}

		spin_lock_irq(&pdflush_lock);
		if (!list_empty(&my_work->list)) {
			printk("pdflush: bogus wakeup!\n");
			my_work->fn = NULL;
			continue;
		}
		if (my_work->fn == NULL) {
			printk("pdflush: NULL work function\n");
			continue;
		}
		spin_unlock_irq(&pdflush_lock);

		(*my_work->fn)(my_work->arg0);

		/*
		 * Thread creation: For how long have there been zero
		 * available threads?
		 */
		if (jiffies - last_empty_jifs > 1 * HZ) {
			/* unlocked list_empty() test is OK here */
			if (list_empty(&pdflush_list)) {
				/* unlocked test is OK here */
				if (nr_pdflush_threads < MAX_PDFLUSH_THREADS)
					start_one_pdflush_thread();
			}
		}

		spin_lock_irq(&pdflush_lock);
		my_work->fn = NULL;

		/*
		 * Thread destruction: For how long has the sleepiest
		 * thread slept?
		 */
		if (list_empty(&pdflush_list))
			continue;
		if (nr_pdflush_threads <= MIN_PDFLUSH_THREADS)
			continue;
		pdf = list_entry(pdflush_list.prev, struct pdflush_work, list);
		if (jiffies - pdf->when_i_went_to_sleep > 1 * HZ) {
			/* Limit exit rate */
			pdf->when_i_went_to_sleep = jiffies;
			break;					/* exeunt */
		}
	}
	nr_pdflush_threads--;
	spin_unlock_irq(&pdflush_lock);
	return 0;
}

/*
 * Of course, my_work wants to be just a local in __pdflush().  It is
 * separated out in this manner to hopefully prevent the compiler from
 * performing unfortunate optimisations against the auto variables.  Because
 * these are visible to other tasks and CPUs.  (No problem has actually
 * been observed.  This is just paranoia).
 */
static int pdflush(void *dummy)
{
	struct pdflush_work my_work;
	cpumask_t cpus_allowed;

	/*
	 * pdflush can spend a lot of time doing encryption via dm-crypt.  We
	 * don't want to do that at keventd's priority.
	 */
	set_user_nice(current, 0);

	/*
	 * Some configs put our parent kthread in a limited cpuset,
	 * which kthread() overrides, forcing cpus_allowed == CPU_MASK_ALL.
	 * Our needs are more modest - cut back to our cpusets cpus_allowed.
	 * This is needed as pdflush's are dynamically created and destroyed.
	 * The boottime pdflush's are easily placed w/o these 2 lines.
	 */
	cpus_allowed = cpuset_cpus_allowed(current);
	set_cpus_allowed(current, cpus_allowed);

	return __pdflush(&my_work);
}

/*
 * Attempt to wake up a pdflush thread, and get it to do some work for you.
 * Returns zero if it indeed managed to find a worker thread, and passed your
 * payload to it.
 */
int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0)
{
	unsigned long flags;
	int ret = 0;

	if (fn == NULL)
		BUG();		/* Hard to diagnose if it's deferred */

	spin_lock_irqsave(&pdflush_lock, flags);
	if (list_empty(&pdflush_list)) {
		spin_unlock_irqrestore(&pdflush_lock, flags);
		ret = -1;
	} else {
		struct pdflush_work *pdf;

		pdf = list_entry(pdflush_list.next, struct pdflush_work, list);
		list_del_init(&pdf->list);
		if (list_empty(&pdflush_list))
			last_empty_jifs = jiffies;
		pdf->fn = fn;
		pdf->arg0 = arg0;
		wake_up_process(pdf->who);
		spin_unlock_irqrestore(&pdflush_lock, flags);
	}
	return ret;
}

static void start_one_pdflush_thread(void)
{
	kthread_run(pdflush, NULL, "pdflush");
}

static int __init pdflush_init(void)
{
	int i;

	for (i = 0; i < MIN_PDFLUSH_THREADS; i++)
		start_one_pdflush_thread();
	return 0;
}

module_init(pdflush_init);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* mm/pdflush.c - worker threads for writing back filesystem data
	3	*
	4	* Copyright (C) 2002, Linus Torvalds.
	5	*
	6	* 09Apr2002 akpm@zip.com.au
	7	* Initial version
	8	* 29Feb2004 kaos@sgi.com
	9	* Move worker thread creation to kthread to avoid chewing
	10	* up stack space with nested calls to kernel_thread.
	11	*/
	12
	13	#include <linux/sched.h>
	14	#include <linux/list.h>
	15	#include <linux/signal.h>
	16	#include <linux/spinlock.h>
	17	#include <linux/gfp.h>
	18	#include <linux/init.h>
	19	#include <linux/module.h>
	20	#include <linux/fs.h> // Needed by writeback.h
	21	#include <linux/writeback.h> // Prototypes pdflush_operation()
	22	#include <linux/kthread.h>
28a42b9e	23	#include <linux/cpuset.h>
1da177e4 LT	24
	25
	26	/*
	27	* Minimum and maximum number of pdflush instances
	28	*/
	29	#define MIN_PDFLUSH_THREADS 2
	30	#define MAX_PDFLUSH_THREADS 8
	31
	32	static void start_one_pdflush_thread(void);
	33
	34
	35	/*
	36	* The pdflush threads are worker threads for writing back dirty data.
	37	* Ideally, we'd like one thread per active disk spindle. But the disk
	38	* topology is very hard to divine at this level. Instead, we take
	39	* care in various places to prevent more than one pdflush thread from
	40	* performing writeback against a single filesystem. pdflush threads
	41	* have the PF_FLUSHER flag set in current->flags to aid in this.
	42	*/
	43
	44	/*
	45	* All the pdflush threads. Protected by pdflush_lock
	46	*/
	47	static LIST_HEAD(pdflush_list);
	48	static DEFINE_SPINLOCK(pdflush_lock);
	49
	50	/*
	51	* The count of currently-running pdflush threads. Protected
	52	* by pdflush_lock.
	53	*
	54	* Readable by sysctl, but not writable. Published to userspace at
	55	* /proc/sys/vm/nr_pdflush_threads.
	56	*/
	57	int nr_pdflush_threads = 0;
	58
	59	/*
	60	* The time at which the pdflush thread pool last went empty
	61	*/
	62	static unsigned long last_empty_jifs;
	63
	64	/*
	65	* The pdflush thread.
	66	*
	67	* Thread pool management algorithm:
	68	*
	69	* - The minimum and maximum number of pdflush instances are bound
	70	* by MIN_PDFLUSH_THREADS and MAX_PDFLUSH_THREADS.
	71	*
	72	* - If there have been no idle pdflush instances for 1 second, create
	73	* a new one.
	74	*
	75	* - If the least-recently-went-to-sleep pdflush thread has been asleep
	76	* for more than one second, terminate a thread.
	77	*/
	78
	79	/*
	80	* A structure for passing work to a pdflush thread. Also for passing
	81	* state information between pdflush threads. Protected by pdflush_lock.
	82	*/
	83	struct pdflush_work {
	84	struct task_struct who; / The thread */
	85	void (fn)(unsigned long); / A callback function */
	86	unsigned long arg0; /* An argument to the callback */
	87	struct list_head list; /* On pdflush_list, when idle */
88	unsigned long when_i_went_to_sleep;
89	};
90
91	static int __pdflush(struct pdflush_work *my_work)
92	{
930d9152	93	current->flags \|= PF_FLUSHER \| PF_SWAPWRITE;
1da177e4 LT	94	my_work->fn = NULL;
	95	my_work->who = current;
	96	INIT_LIST_HEAD(&my_work->list);
	97
	98	spin_lock_irq(&pdflush_lock);
	99	nr_pdflush_threads++;
	100	for ( ; ; ) {
	101	struct pdflush_work *pdf;
	102
	103	set_current_state(TASK_INTERRUPTIBLE);
	104	list_move(&my_work->list, &pdflush_list);
	105	my_work->when_i_went_to_sleep = jiffies;
	106	spin_unlock_irq(&pdflush_lock);
	107
	108	schedule();
3e1d1d28	109	if (try_to_freeze()) {
1da177e4 LT	110	spin_lock_irq(&pdflush_lock);
	111	continue;
	112	}
	113
	114	spin_lock_irq(&pdflush_lock);
	115	if (!list_empty(&my_work->list)) {
	116	printk("pdflush: bogus wakeup!\n");
	117	my_work->fn = NULL;
	118	continue;
	119	}
	120	if (my_work->fn == NULL) {
	121	printk("pdflush: NULL work function\n");
	122	continue;
	123	}
	124	spin_unlock_irq(&pdflush_lock);
	125
	126	(*my_work->fn)(my_work->arg0);
	127
	128	/*
	129	* Thread creation: For how long have there been zero
	130	* available threads?
	131	*/
	132	if (jiffies - last_empty_jifs > 1 * HZ) {
	133	/* unlocked list_empty() test is OK here */
	134	if (list_empty(&pdflush_list)) {
	135	/* unlocked test is OK here */
	136	if (nr_pdflush_threads < MAX_PDFLUSH_THREADS)
	137	start_one_pdflush_thread();
	138	}
	139	}
	140
	141	spin_lock_irq(&pdflush_lock);
	142	my_work->fn = NULL;
	143
	144	/*
	145	* Thread destruction: For how long has the sleepiest
	146	* thread slept?
	147	*/
	148	if (list_empty(&pdflush_list))
	149	continue;
	150	if (nr_pdflush_threads <= MIN_PDFLUSH_THREADS)
	151	continue;
	152	pdf = list_entry(pdflush_list.prev, struct pdflush_work, list);
	153	if (jiffies - pdf->when_i_went_to_sleep > 1 * HZ) {
	154	/* Limit exit rate */
	155	pdf->when_i_went_to_sleep = jiffies;
	156	break; /* exeunt */
	157	}
	158	}
	159	nr_pdflush_threads--;
	160	spin_unlock_irq(&pdflush_lock);
	161	return 0;
	162	}
	163
	164	/*
	165	* Of course, my_work wants to be just a local in __pdflush(). It is
	166	* separated out in this manner to hopefully prevent the compiler from
	167	* performing unfortunate optimisations against the auto variables. Because
	168	* these are visible to other tasks and CPUs. (No problem has actually
	169	* been observed. This is just paranoia).
	170	*/
	171	static int pdflush(void *dummy)
	172	{
	173	struct pdflush_work my_work;
28a42b9e	174	cpumask_t cpus_allowed;
1da177e4 LT	175
	176	/*
	177	* pdflush can spend a lot of time doing encryption via dm-crypt. We
	178	* don't want to do that at keventd's priority.
	179	*/
	180	set_user_nice(current, 0);
28a42b9e PJ	181
	182	/*
	183	* Some configs put our parent kthread in a limited cpuset,
	184	* which kthread() overrides, forcing cpus_allowed == CPU_MASK_ALL.
	185	* Our needs are more modest - cut back to our cpusets cpus_allowed.
	186	* This is needed as pdflush's are dynamically created and destroyed.
	187	* The boottime pdflush's are easily placed w/o these 2 lines.
	188	*/
	189	cpus_allowed = cpuset_cpus_allowed(current);
	190	set_cpus_allowed(current, cpus_allowed);
	191
1da177e4 LT	192	return __pdflush(&my_work);
	193	}
	194
	195	/*
	196	* Attempt to wake up a pdflush thread, and get it to do some work for you.
	197	* Returns zero if it indeed managed to find a worker thread, and passed your
	198	* payload to it.
	199	*/
	200	int pdflush_operation(void (*fn)(unsigned long), unsigned long arg0)
	201	{
	202	unsigned long flags;
	203	int ret = 0;
	204
	205	if (fn == NULL)
	206	BUG(); /* Hard to diagnose if it's deferred */
	207
	208	spin_lock_irqsave(&pdflush_lock, flags);
	209	if (list_empty(&pdflush_list)) {
	210	spin_unlock_irqrestore(&pdflush_lock, flags);
	211	ret = -1;
	212	} else {
	213	struct pdflush_work *pdf;
	214
	215	pdf = list_entry(pdflush_list.next, struct pdflush_work, list);
	216	list_del_init(&pdf->list);
	217	if (list_empty(&pdflush_list))
	218	last_empty_jifs = jiffies;
	219	pdf->fn = fn;
	220	pdf->arg0 = arg0;
	221	wake_up_process(pdf->who);
	222	spin_unlock_irqrestore(&pdflush_lock, flags);
	223	}
	224	return ret;
	225	}
	226
	227	static void start_one_pdflush_thread(void)
	228	{
	229	kthread_run(pdflush, NULL, "pdflush");
	230	}
	231
	232	static int __init pdflush_init(void)
	233	{
	234	int i;
	235
	236	for (i = 0; i < MIN_PDFLUSH_THREADS; i++)
	237	start_one_pdflush_thread();
	238	return 0;
	239	}
	240
	241	module_init(pdflush_init);