kthread: implement kthread_worker
[linux-2.6.git] / kernel / kthread.c
1 /* Kernel thread helper functions.
2  *   Copyright (C) 2004 IBM Corporation, Rusty Russell.
3  *
4  * Creation is done via kthreadd, so that we get a clean environment
5  * even if we're invoked from userspace (think modprobe, hotplug cpu,
6  * etc.).
7  */
8 #include <linux/sched.h>
9 #include <linux/kthread.h>
10 #include <linux/completion.h>
11 #include <linux/err.h>
12 #include <linux/cpuset.h>
13 #include <linux/unistd.h>
14 #include <linux/file.h>
15 #include <linux/module.h>
16 #include <linux/mutex.h>
17 #include <linux/slab.h>
18 #include <linux/freezer.h>
19 #include <trace/events/sched.h>
20
21 static DEFINE_SPINLOCK(kthread_create_lock);
22 static LIST_HEAD(kthread_create_list);
23 struct task_struct *kthreadd_task;
24
25 struct kthread_create_info
26 {
27         /* Information passed to kthread() from kthreadd. */
28         int (*threadfn)(void *data);
29         void *data;
30
31         /* Result passed back to kthread_create() from kthreadd. */
32         struct task_struct *result;
33         struct completion done;
34
35         struct list_head list;
36 };
37
38 struct kthread {
39         int should_stop;
40         struct completion exited;
41 };
42
43 #define to_kthread(tsk) \
44         container_of((tsk)->vfork_done, struct kthread, exited)
45
46 /**
47  * kthread_should_stop - should this kthread return now?
48  *
49  * When someone calls kthread_stop() on your kthread, it will be woken
50  * and this will return true.  You should then return, and your return
51  * value will be passed through to kthread_stop().
52  */
53 int kthread_should_stop(void)
54 {
55         return to_kthread(current)->should_stop;
56 }
57 EXPORT_SYMBOL(kthread_should_stop);
58
59 static int kthread(void *_create)
60 {
61         /* Copy data: it's on kthread's stack */
62         struct kthread_create_info *create = _create;
63         int (*threadfn)(void *data) = create->threadfn;
64         void *data = create->data;
65         struct kthread self;
66         int ret;
67
68         self.should_stop = 0;
69         init_completion(&self.exited);
70         current->vfork_done = &self.exited;
71
72         /* OK, tell user we're spawned, wait for stop or wakeup */
73         __set_current_state(TASK_UNINTERRUPTIBLE);
74         create->result = current;
75         complete(&create->done);
76         schedule();
77
78         ret = -EINTR;
79         if (!self.should_stop)
80                 ret = threadfn(data);
81
82         /* we can't just return, we must preserve "self" on stack */
83         do_exit(ret);
84 }
85
86 static void create_kthread(struct kthread_create_info *create)
87 {
88         int pid;
89
90         /* We want our own signal handler (we take no signals by default). */
91         pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
92         if (pid < 0) {
93                 create->result = ERR_PTR(pid);
94                 complete(&create->done);
95         }
96 }
97
98 /**
99  * kthread_create - create a kthread.
100  * @threadfn: the function to run until signal_pending(current).
101  * @data: data ptr for @threadfn.
102  * @namefmt: printf-style name for the thread.
103  *
104  * Description: This helper function creates and names a kernel
105  * thread.  The thread will be stopped: use wake_up_process() to start
106  * it.  See also kthread_run().
107  *
108  * When woken, the thread will run @threadfn() with @data as its
109  * argument. @threadfn() can either call do_exit() directly if it is a
110  * standalone thread for which noone will call kthread_stop(), or
111  * return when 'kthread_should_stop()' is true (which means
112  * kthread_stop() has been called).  The return value should be zero
113  * or a negative error number; it will be passed to kthread_stop().
114  *
115  * Returns a task_struct or ERR_PTR(-ENOMEM).
116  */
117 struct task_struct *kthread_create(int (*threadfn)(void *data),
118                                    void *data,
119                                    const char namefmt[],
120                                    ...)
121 {
122         struct kthread_create_info create;
123
124         create.threadfn = threadfn;
125         create.data = data;
126         init_completion(&create.done);
127
128         spin_lock(&kthread_create_lock);
129         list_add_tail(&create.list, &kthread_create_list);
130         spin_unlock(&kthread_create_lock);
131
132         wake_up_process(kthreadd_task);
133         wait_for_completion(&create.done);
134
135         if (!IS_ERR(create.result)) {
136                 struct sched_param param = { .sched_priority = 0 };
137                 va_list args;
138
139                 va_start(args, namefmt);
140                 vsnprintf(create.result->comm, sizeof(create.result->comm),
141                           namefmt, args);
142                 va_end(args);
143                 /*
144                  * root may have changed our (kthreadd's) priority or CPU mask.
145                  * The kernel thread should not inherit these properties.
146                  */
147                 sched_setscheduler_nocheck(create.result, SCHED_NORMAL, &param);
148                 set_cpus_allowed_ptr(create.result, cpu_all_mask);
149         }
150         return create.result;
151 }
152 EXPORT_SYMBOL(kthread_create);
153
154 /**
155  * kthread_bind - bind a just-created kthread to a cpu.
156  * @p: thread created by kthread_create().
157  * @cpu: cpu (might not be online, must be possible) for @k to run on.
158  *
159  * Description: This function is equivalent to set_cpus_allowed(),
160  * except that @cpu doesn't need to be online, and the thread must be
161  * stopped (i.e., just returned from kthread_create()).
162  */
163 void kthread_bind(struct task_struct *p, unsigned int cpu)
164 {
165         /* Must have done schedule() in kthread() before we set_task_cpu */
166         if (!wait_task_inactive(p, TASK_UNINTERRUPTIBLE)) {
167                 WARN_ON(1);
168                 return;
169         }
170
171         p->cpus_allowed = cpumask_of_cpu(cpu);
172         p->rt.nr_cpus_allowed = 1;
173         p->flags |= PF_THREAD_BOUND;
174 }
175 EXPORT_SYMBOL(kthread_bind);
176
177 /**
178  * kthread_stop - stop a thread created by kthread_create().
179  * @k: thread created by kthread_create().
180  *
181  * Sets kthread_should_stop() for @k to return true, wakes it, and
182  * waits for it to exit. This can also be called after kthread_create()
183  * instead of calling wake_up_process(): the thread will exit without
184  * calling threadfn().
185  *
186  * If threadfn() may call do_exit() itself, the caller must ensure
187  * task_struct can't go away.
188  *
189  * Returns the result of threadfn(), or %-EINTR if wake_up_process()
190  * was never called.
191  */
192 int kthread_stop(struct task_struct *k)
193 {
194         struct kthread *kthread;
195         int ret;
196
197         trace_sched_kthread_stop(k);
198         get_task_struct(k);
199
200         kthread = to_kthread(k);
201         barrier(); /* it might have exited */
202         if (k->vfork_done != NULL) {
203                 kthread->should_stop = 1;
204                 wake_up_process(k);
205                 wait_for_completion(&kthread->exited);
206         }
207         ret = k->exit_code;
208
209         put_task_struct(k);
210         trace_sched_kthread_stop_ret(ret);
211
212         return ret;
213 }
214 EXPORT_SYMBOL(kthread_stop);
215
216 int kthreadd(void *unused)
217 {
218         struct task_struct *tsk = current;
219
220         /* Setup a clean context for our children to inherit. */
221         set_task_comm(tsk, "kthreadd");
222         ignore_signals(tsk);
223         set_cpus_allowed_ptr(tsk, cpu_all_mask);
224         set_mems_allowed(node_states[N_HIGH_MEMORY]);
225
226         current->flags |= PF_NOFREEZE | PF_FREEZER_NOSIG;
227
228         for (;;) {
229                 set_current_state(TASK_INTERRUPTIBLE);
230                 if (list_empty(&kthread_create_list))
231                         schedule();
232                 __set_current_state(TASK_RUNNING);
233
234                 spin_lock(&kthread_create_lock);
235                 while (!list_empty(&kthread_create_list)) {
236                         struct kthread_create_info *create;
237
238                         create = list_entry(kthread_create_list.next,
239                                             struct kthread_create_info, list);
240                         list_del_init(&create->list);
241                         spin_unlock(&kthread_create_lock);
242
243                         create_kthread(create);
244
245                         spin_lock(&kthread_create_lock);
246                 }
247                 spin_unlock(&kthread_create_lock);
248         }
249
250         return 0;
251 }
252
253 /**
254  * kthread_worker_fn - kthread function to process kthread_worker
255  * @worker_ptr: pointer to initialized kthread_worker
256  *
257  * This function can be used as @threadfn to kthread_create() or
258  * kthread_run() with @worker_ptr argument pointing to an initialized
259  * kthread_worker.  The started kthread will process work_list until
260  * the it is stopped with kthread_stop().  A kthread can also call
261  * this function directly after extra initialization.
262  *
263  * Different kthreads can be used for the same kthread_worker as long
264  * as there's only one kthread attached to it at any given time.  A
265  * kthread_worker without an attached kthread simply collects queued
266  * kthread_works.
267  */
268 int kthread_worker_fn(void *worker_ptr)
269 {
270         struct kthread_worker *worker = worker_ptr;
271         struct kthread_work *work;
272
273         WARN_ON(worker->task);
274         worker->task = current;
275 repeat:
276         set_current_state(TASK_INTERRUPTIBLE);  /* mb paired w/ kthread_stop */
277
278         if (kthread_should_stop()) {
279                 __set_current_state(TASK_RUNNING);
280                 spin_lock_irq(&worker->lock);
281                 worker->task = NULL;
282                 spin_unlock_irq(&worker->lock);
283                 return 0;
284         }
285
286         work = NULL;
287         spin_lock_irq(&worker->lock);
288         if (!list_empty(&worker->work_list)) {
289                 work = list_first_entry(&worker->work_list,
290                                         struct kthread_work, node);
291                 list_del_init(&work->node);
292         }
293         spin_unlock_irq(&worker->lock);
294
295         if (work) {
296                 __set_current_state(TASK_RUNNING);
297                 work->func(work);
298                 smp_wmb();      /* wmb worker-b0 paired with flush-b1 */
299                 work->done_seq = work->queue_seq;
300                 smp_mb();       /* mb worker-b1 paired with flush-b0 */
301                 if (atomic_read(&work->flushing))
302                         wake_up_all(&work->done);
303         } else if (!freezing(current))
304                 schedule();
305
306         try_to_freeze();
307         goto repeat;
308 }
309 EXPORT_SYMBOL_GPL(kthread_worker_fn);
310
311 /**
312  * queue_kthread_work - queue a kthread_work
313  * @worker: target kthread_worker
314  * @work: kthread_work to queue
315  *
316  * Queue @work to work processor @task for async execution.  @task
317  * must have been created with kthread_worker_create().  Returns %true
318  * if @work was successfully queued, %false if it was already pending.
319  */
320 bool queue_kthread_work(struct kthread_worker *worker,
321                         struct kthread_work *work)
322 {
323         bool ret = false;
324         unsigned long flags;
325
326         spin_lock_irqsave(&worker->lock, flags);
327         if (list_empty(&work->node)) {
328                 list_add_tail(&work->node, &worker->work_list);
329                 work->queue_seq++;
330                 if (likely(worker->task))
331                         wake_up_process(worker->task);
332                 ret = true;
333         }
334         spin_unlock_irqrestore(&worker->lock, flags);
335         return ret;
336 }
337 EXPORT_SYMBOL_GPL(queue_kthread_work);
338
339 /**
340  * flush_kthread_work - flush a kthread_work
341  * @work: work to flush
342  *
343  * If @work is queued or executing, wait for it to finish execution.
344  */
345 void flush_kthread_work(struct kthread_work *work)
346 {
347         int seq = work->queue_seq;
348
349         atomic_inc(&work->flushing);
350
351         /*
352          * mb flush-b0 paired with worker-b1, to make sure either
353          * worker sees the above increment or we see done_seq update.
354          */
355         smp_mb__after_atomic_inc();
356
357         /* A - B <= 0 tests whether B is in front of A regardless of overflow */
358         wait_event(work->done, seq - work->done_seq <= 0);
359         atomic_dec(&work->flushing);
360
361         /*
362          * rmb flush-b1 paired with worker-b0, to make sure our caller
363          * sees every change made by work->func().
364          */
365         smp_mb__after_atomic_dec();
366 }
367 EXPORT_SYMBOL_GPL(flush_kthread_work);
368
369 struct kthread_flush_work {
370         struct kthread_work     work;
371         struct completion       done;
372 };
373
374 static void kthread_flush_work_fn(struct kthread_work *work)
375 {
376         struct kthread_flush_work *fwork =
377                 container_of(work, struct kthread_flush_work, work);
378         complete(&fwork->done);
379 }
380
381 /**
382  * flush_kthread_worker - flush all current works on a kthread_worker
383  * @worker: worker to flush
384  *
385  * Wait until all currently executing or pending works on @worker are
386  * finished.
387  */
388 void flush_kthread_worker(struct kthread_worker *worker)
389 {
390         struct kthread_flush_work fwork = {
391                 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
392                 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
393         };
394
395         queue_kthread_work(worker, &fwork.work);
396         wait_for_completion(&fwork.done);
397 }
398 EXPORT_SYMBOL_GPL(flush_kthread_worker);