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