mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 10:04:12 +08:00
28a42b9ea7
This patch keeps pdflush daemons on the same cpuset as their parent, the kthread daemon. Some large NUMA configurations put as much as they can of kernel threads and other classic Unix load in what's called a bootcpuset, keeping the rest of the system free for dedicated jobs. This effort is thwarted by pdflush, which dynamically destroys and recreates pdflush daemons depending on load. It's easy enough to force the originally created pdflush deamons into the bootcpuset, at system boottime. But the pdflush threads created later were allowed to run freely across the system, due to the necessary line in their startup kthread(): set_cpus_allowed(current, CPU_MASK_ALL); By simply coding pdflush to start its threads with the cpus_allowed restrictions of its cpuset (inherited from kthread, its parent) we can ensure that dynamically created pdflush threads are also kept in the bootcpuset. On systems w/o cpusets, or w/o a bootcpuset implementation, the following will have no affect, leaving pdflush to run on any CPU, as before. Signed-off-by: Paul Jackson <pj@sgi.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
242 lines
6.2 KiB
C
242 lines
6.2 KiB
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;
|
|
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);
|