mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-22 17:01:14 +00:00
![Rafael J. Wysocki](/assets/img/avatar_default.png)
Currently, the freezer treats all tasks as freezable, except for the kernel threads that explicitly set the PF_NOFREEZE flag for themselves. This approach is problematic, since it requires every kernel thread to either set PF_NOFREEZE explicitly, or call try_to_freeze(), even if it doesn't care for the freezing of tasks at all. It seems better to only require the kernel threads that want to or need to be frozen to use some freezer-related code and to remove any freezer-related code from the other (nonfreezable) kernel threads, which is done in this patch. The patch causes all kernel threads to be nonfreezable by default (ie. to have PF_NOFREEZE set by default) and introduces the set_freezable() function that should be called by the freezable kernel threads in order to unset PF_NOFREEZE. It also makes all of the currently freezable kernel threads call set_freezable(), so it shouldn't cause any (intentional) change of behaviour to appear. Additionally, it updates documentation to describe the freezing of tasks more accurately. [akpm@linux-foundation.org: build fixes] Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl> Acked-by: Nigel Cunningham <nigel@nigel.suspend2.net> Cc: Pavel Machek <pavel@ucw.cz> Cc: Oleg Nesterov <oleg@tv-sign.ru> Cc: Gautham R Shenoy <ego@in.ibm.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
241 lines
6.4 KiB
C
241 lines
6.4 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>
|
|
#include <linux/freezer.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;
|
|
set_freezable();
|
|
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();
|
|
try_to_freeze();
|
|
spin_lock_irq(&pdflush_lock);
|
|
if (!list_empty(&my_work->list)) {
|
|
/*
|
|
* Someone woke us up, but without removing our control
|
|
* structure from the global list. swsusp will do this
|
|
* in try_to_freeze()->refrigerator(). Handle it.
|
|
*/
|
|
my_work->fn = NULL;
|
|
continue;
|
|
}
|
|
if (my_work->fn == NULL) {
|
|
printk("pdflush: bogus wakeup\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;
|
|
|
|
BUG_ON(fn == NULL); /* 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);
|