/* * 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);