]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - mm/pdflush.c
2 * mm/pdflush.c - worker threads for writing back filesystem data
4 * Copyright (C) 2002, Linus Torvalds.
6 * 09Apr2002 akpm@zip.com.au
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.
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>
23 #include <linux/cpuset.h>
24 #include <linux/freezer.h>
28 * Minimum and maximum number of pdflush instances
30 #define MIN_PDFLUSH_THREADS 2
31 #define MAX_PDFLUSH_THREADS 8
33 static void start_one_pdflush_thread(void);
37 * The pdflush threads are worker threads for writing back dirty data.
38 * Ideally, we'd like one thread per active disk spindle. But the disk
39 * topology is very hard to divine at this level. Instead, we take
40 * care in various places to prevent more than one pdflush thread from
41 * performing writeback against a single filesystem. pdflush threads
42 * have the PF_FLUSHER flag set in current->flags to aid in this.
46 * All the pdflush threads. Protected by pdflush_lock
48 static LIST_HEAD(pdflush_list
);
49 static DEFINE_SPINLOCK(pdflush_lock
);
52 * The count of currently-running pdflush threads. Protected
55 * Readable by sysctl, but not writable. Published to userspace at
56 * /proc/sys/vm/nr_pdflush_threads.
58 int nr_pdflush_threads
= 0;
61 * The time at which the pdflush thread pool last went empty
63 static unsigned long last_empty_jifs
;
68 * Thread pool management algorithm:
70 * - The minimum and maximum number of pdflush instances are bound
71 * by MIN_PDFLUSH_THREADS and MAX_PDFLUSH_THREADS.
73 * - If there have been no idle pdflush instances for 1 second, create
76 * - If the least-recently-went-to-sleep pdflush thread has been asleep
77 * for more than one second, terminate a thread.
81 * A structure for passing work to a pdflush thread. Also for passing
82 * state information between pdflush threads. Protected by pdflush_lock.
85 struct task_struct
*who
; /* The thread */
86 void (*fn
)(unsigned long); /* A callback function */
87 unsigned long arg0
; /* An argument to the callback */
88 struct list_head list
; /* On pdflush_list, when idle */
89 unsigned long when_i_went_to_sleep
;
92 static int __pdflush(struct pdflush_work
*my_work
)
94 current
->flags
|= PF_FLUSHER
| PF_SWAPWRITE
;
96 my_work
->who
= current
;
97 INIT_LIST_HEAD(&my_work
->list
);
99 spin_lock_irq(&pdflush_lock
);
100 nr_pdflush_threads
++;
102 struct pdflush_work
*pdf
;
104 set_current_state(TASK_INTERRUPTIBLE
);
105 list_move(&my_work
->list
, &pdflush_list
);
106 my_work
->when_i_went_to_sleep
= jiffies
;
107 spin_unlock_irq(&pdflush_lock
);
110 spin_lock_irq(&pdflush_lock
);
111 if (!list_empty(&my_work
->list
)) {
113 * Someone woke us up, but without removing our control
114 * structure from the global list. swsusp will do this
115 * in try_to_freeze()->refrigerator(). Handle it.
120 if (my_work
->fn
== NULL
) {
121 printk("pdflush: bogus wakeup\n");
124 spin_unlock_irq(&pdflush_lock
);
126 (*my_work
->fn
)(my_work
->arg0
);
129 * Thread creation: For how long have there been zero
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();
141 spin_lock_irq(&pdflush_lock
);
145 * Thread destruction: For how long has the sleepiest
148 if (list_empty(&pdflush_list
))
150 if (nr_pdflush_threads
<= MIN_PDFLUSH_THREADS
)
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
;
159 nr_pdflush_threads
--;
160 spin_unlock_irq(&pdflush_lock
);
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).
171 static int pdflush(void *dummy
)
173 struct pdflush_work my_work
;
174 cpumask_t cpus_allowed
;
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.
180 set_user_nice(current
, 0);
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.
189 cpus_allowed
= cpuset_cpus_allowed(current
);
190 set_cpus_allowed(current
, cpus_allowed
);
192 return __pdflush(&my_work
);
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
200 int pdflush_operation(void (*fn
)(unsigned long), unsigned long arg0
)
205 BUG_ON(fn
== NULL
); /* Hard to diagnose if it's deferred */
207 spin_lock_irqsave(&pdflush_lock
, flags
);
208 if (list_empty(&pdflush_list
)) {
209 spin_unlock_irqrestore(&pdflush_lock
, flags
);
212 struct pdflush_work
*pdf
;
214 pdf
= list_entry(pdflush_list
.next
, struct pdflush_work
, list
);
215 list_del_init(&pdf
->list
);
216 if (list_empty(&pdflush_list
))
217 last_empty_jifs
= jiffies
;
220 wake_up_process(pdf
->who
);
221 spin_unlock_irqrestore(&pdflush_lock
, flags
);
226 static void start_one_pdflush_thread(void)
228 kthread_run(pdflush
, NULL
, "pdflush");
231 static int __init
pdflush_init(void)
235 for (i
= 0; i
< MIN_PDFLUSH_THREADS
; i
++)
236 start_one_pdflush_thread();
240 module_init(pdflush_init
);