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