mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 11:19:37 +00:00
![Christoph Lameter](/assets/img/avatar_default.png)
Add PF_SWAPWRITE to control a processes permission to write to swap. - Use PF_SWAPWRITE in may_write_to_queue() instead of checking for kswapd and pdflush - Set PF_SWAPWRITE flag for kswapd and pdflush Signed-off-by: Christoph Lameter <clameter@sgi.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
241 lines
6.2 KiB
C
241 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 | 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);
|