1 /* Kernel thread helper functions.
2 * Copyright (C) 2004 IBM Corporation, Rusty Russell.
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,
8 #include <linux/sched.h>
9 #include <linux/kthread.h>
10 #include <linux/completion.h>
11 #include <linux/err.h>
12 #include <linux/unistd.h>
13 #include <linux/file.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <trace/sched.h>
18 #define KTHREAD_NICE_LEVEL (-5)
20 static DEFINE_SPINLOCK(kthread_create_lock
);
21 static LIST_HEAD(kthread_create_list
);
22 struct task_struct
*kthreadd_task
;
24 DEFINE_TRACE(sched_kthread_stop
);
25 DEFINE_TRACE(sched_kthread_stop_ret
);
27 struct kthread_create_info
29 /* Information passed to kthread() from kthreadd. */
30 int (*threadfn
)(void *data
);
32 struct completion started
;
34 /* Result passed back to kthread_create() from kthreadd. */
35 struct task_struct
*result
;
36 struct completion done
;
38 struct list_head list
;
41 struct kthread_stop_info
43 struct task_struct
*k
;
45 struct completion done
;
48 /* Thread stopping is done by setthing this var: lock serializes
49 * multiple kthread_stop calls. */
50 static DEFINE_MUTEX(kthread_stop_lock
);
51 static struct kthread_stop_info kthread_stop_info
;
54 * kthread_should_stop - should this kthread return now?
56 * When someone calls kthread_stop() on your kthread, it will be woken
57 * and this will return true. You should then return, and your return
58 * value will be passed through to kthread_stop().
60 int kthread_should_stop(void)
62 return (kthread_stop_info
.k
== current
);
64 EXPORT_SYMBOL(kthread_should_stop
);
66 static int kthread(void *_create
)
68 struct kthread_create_info
*create
= _create
;
69 int (*threadfn
)(void *data
);
73 /* Copy data: it's on kthread's stack */
74 threadfn
= create
->threadfn
;
77 /* OK, tell user we're spawned, wait for stop or wakeup */
78 __set_current_state(TASK_UNINTERRUPTIBLE
);
79 complete(&create
->started
);
82 if (!kthread_should_stop())
85 /* It might have exited on its own, w/o kthread_stop. Check. */
86 if (kthread_should_stop()) {
87 kthread_stop_info
.err
= ret
;
88 complete(&kthread_stop_info
.done
);
93 static void create_kthread(struct kthread_create_info
*create
)
97 /* We want our own signal handler (we take no signals by default). */
98 pid
= kernel_thread(kthread
, create
, CLONE_FS
| CLONE_FILES
| SIGCHLD
);
100 create
->result
= ERR_PTR(pid
);
102 struct sched_param param
= { .sched_priority
= 0 };
103 wait_for_completion(&create
->started
);
104 read_lock(&tasklist_lock
);
105 create
->result
= find_task_by_pid_ns(pid
, &init_pid_ns
);
106 read_unlock(&tasklist_lock
);
108 * root may have changed our (kthreadd's) priority or CPU mask.
109 * The kernel thread should not inherit these properties.
111 sched_setscheduler(create
->result
, SCHED_NORMAL
, ¶m
);
112 set_user_nice(create
->result
, KTHREAD_NICE_LEVEL
);
113 set_cpus_allowed_ptr(create
->result
, cpu_all_mask
);
115 complete(&create
->done
);
119 * kthread_create - create a kthread.
120 * @threadfn: the function to run until signal_pending(current).
121 * @data: data ptr for @threadfn.
122 * @namefmt: printf-style name for the thread.
124 * Description: This helper function creates and names a kernel
125 * thread. The thread will be stopped: use wake_up_process() to start
126 * it. See also kthread_run(), kthread_create_on_cpu().
128 * When woken, the thread will run @threadfn() with @data as its
129 * argument. @threadfn() can either call do_exit() directly if it is a
130 * standalone thread for which noone will call kthread_stop(), or
131 * return when 'kthread_should_stop()' is true (which means
132 * kthread_stop() has been called). The return value should be zero
133 * or a negative error number; it will be passed to kthread_stop().
135 * Returns a task_struct or ERR_PTR(-ENOMEM).
137 struct task_struct
*kthread_create(int (*threadfn
)(void *data
),
139 const char namefmt
[],
142 struct kthread_create_info create
;
144 create
.threadfn
= threadfn
;
146 init_completion(&create
.started
);
147 init_completion(&create
.done
);
149 spin_lock(&kthread_create_lock
);
150 list_add_tail(&create
.list
, &kthread_create_list
);
151 spin_unlock(&kthread_create_lock
);
153 wake_up_process(kthreadd_task
);
154 wait_for_completion(&create
.done
);
156 if (!IS_ERR(create
.result
)) {
158 va_start(args
, namefmt
);
159 vsnprintf(create
.result
->comm
, sizeof(create
.result
->comm
),
163 return create
.result
;
165 EXPORT_SYMBOL(kthread_create
);
168 * kthread_bind - bind a just-created kthread to a cpu.
169 * @k: thread created by kthread_create().
170 * @cpu: cpu (might not be online, must be possible) for @k to run on.
172 * Description: This function is equivalent to set_cpus_allowed(),
173 * except that @cpu doesn't need to be online, and the thread must be
174 * stopped (i.e., just returned from kthread_create()).
176 void kthread_bind(struct task_struct
*k
, unsigned int cpu
)
178 /* Must have done schedule() in kthread() before we set_task_cpu */
179 if (!wait_task_inactive(k
, TASK_UNINTERRUPTIBLE
)) {
183 set_task_cpu(k
, cpu
);
184 k
->cpus_allowed
= cpumask_of_cpu(cpu
);
185 k
->rt
.nr_cpus_allowed
= 1;
186 k
->flags
|= PF_THREAD_BOUND
;
188 EXPORT_SYMBOL(kthread_bind
);
191 * kthread_stop - stop a thread created by kthread_create().
192 * @k: thread created by kthread_create().
194 * Sets kthread_should_stop() for @k to return true, wakes it, and
195 * waits for it to exit. Your threadfn() must not call do_exit()
196 * itself if you use this function! This can also be called after
197 * kthread_create() instead of calling wake_up_process(): the thread
198 * will exit without calling threadfn().
200 * Returns the result of threadfn(), or %-EINTR if wake_up_process()
203 int kthread_stop(struct task_struct
*k
)
207 mutex_lock(&kthread_stop_lock
);
209 /* It could exit after stop_info.k set, but before wake_up_process. */
212 trace_sched_kthread_stop(k
);
214 /* Must init completion *before* thread sees kthread_stop_info.k */
215 init_completion(&kthread_stop_info
.done
);
218 /* Now set kthread_should_stop() to true, and wake it up. */
219 kthread_stop_info
.k
= k
;
223 /* Once it dies, reset stop ptr, gather result and we're done. */
224 wait_for_completion(&kthread_stop_info
.done
);
225 kthread_stop_info
.k
= NULL
;
226 ret
= kthread_stop_info
.err
;
227 mutex_unlock(&kthread_stop_lock
);
229 trace_sched_kthread_stop_ret(ret
);
233 EXPORT_SYMBOL(kthread_stop
);
235 int kthreadd(void *unused
)
237 struct task_struct
*tsk
= current
;
239 /* Setup a clean context for our children to inherit. */
240 set_task_comm(tsk
, "kthreadd");
242 set_user_nice(tsk
, KTHREAD_NICE_LEVEL
);
243 set_cpus_allowed_ptr(tsk
, cpu_all_mask
);
245 current
->flags
|= PF_NOFREEZE
| PF_FREEZER_NOSIG
;
248 set_current_state(TASK_INTERRUPTIBLE
);
249 if (list_empty(&kthread_create_list
))
251 __set_current_state(TASK_RUNNING
);
253 spin_lock(&kthread_create_lock
);
254 while (!list_empty(&kthread_create_list
)) {
255 struct kthread_create_info
*create
;
257 create
= list_entry(kthread_create_list
.next
,
258 struct kthread_create_info
, list
);
259 list_del_init(&create
->list
);
260 spin_unlock(&kthread_create_lock
);
262 create_kthread(create
);
264 spin_lock(&kthread_create_lock
);
266 spin_unlock(&kthread_create_lock
);