kthread.c 12.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/* Kernel thread helper functions.
 *   Copyright (C) 2004 IBM Corporation, Rusty Russell.
 *
4
 * Creation is done via kthreadd, so that we get a clean environment
L
Linus Torvalds 已提交
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>
12
#include <linux/cpuset.h>
L
Linus Torvalds 已提交
13 14
#include <linux/unistd.h>
#include <linux/file.h>
15
#include <linux/export.h>
A
Arjan van de Ven 已提交
16
#include <linux/mutex.h>
T
Tejun Heo 已提交
17 18
#include <linux/slab.h>
#include <linux/freezer.h>
19
#include <trace/events/sched.h>
L
Linus Torvalds 已提交
20

21 22 23
static DEFINE_SPINLOCK(kthread_create_lock);
static LIST_HEAD(kthread_create_list);
struct task_struct *kthreadd_task;
L
Linus Torvalds 已提交
24 25 26

struct kthread_create_info
{
27
	/* Information passed to kthread() from kthreadd. */
L
Linus Torvalds 已提交
28 29
	int (*threadfn)(void *data);
	void *data;
30
	int node;
L
Linus Torvalds 已提交
31

32
	/* Result passed back to kthread_create() from kthreadd. */
L
Linus Torvalds 已提交
33 34
	struct task_struct *result;
	struct completion done;
35

36
	struct list_head list;
L
Linus Torvalds 已提交
37 38
};

O
Oleg Nesterov 已提交
39 40
struct kthread {
	int should_stop;
T
Tejun Heo 已提交
41
	void *data;
O
Oleg Nesterov 已提交
42
	struct completion exited;
L
Linus Torvalds 已提交
43 44
};

O
Oleg Nesterov 已提交
45 46
#define to_kthread(tsk)	\
	container_of((tsk)->vfork_done, struct kthread, exited)
L
Linus Torvalds 已提交
47

48 49 50
/**
 * kthread_should_stop - should this kthread return now?
 *
51
 * When someone calls kthread_stop() on your kthread, it will be woken
52 53 54
 * and this will return true.  You should then return, and your return
 * value will be passed through to kthread_stop().
 */
L
Linus Torvalds 已提交
55 56
int kthread_should_stop(void)
{
O
Oleg Nesterov 已提交
57
	return to_kthread(current)->should_stop;
L
Linus Torvalds 已提交
58 59 60
}
EXPORT_SYMBOL(kthread_should_stop);

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
/**
 * 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);

T
Tejun Heo 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98
/**
 * 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;
}

L
Linus Torvalds 已提交
99 100
static int kthread(void *_create)
{
O
Oleg Nesterov 已提交
101
	/* Copy data: it's on kthread's stack */
L
Linus Torvalds 已提交
102
	struct kthread_create_info *create = _create;
O
Oleg Nesterov 已提交
103 104 105 106
	int (*threadfn)(void *data) = create->threadfn;
	void *data = create->data;
	struct kthread self;
	int ret;
L
Linus Torvalds 已提交
107

O
Oleg Nesterov 已提交
108
	self.should_stop = 0;
T
Tejun Heo 已提交
109
	self.data = data;
O
Oleg Nesterov 已提交
110 111
	init_completion(&self.exited);
	current->vfork_done = &self.exited;
L
Linus Torvalds 已提交
112 113

	/* OK, tell user we're spawned, wait for stop or wakeup */
114
	__set_current_state(TASK_UNINTERRUPTIBLE);
115
	create->result = current;
116
	complete(&create->done);
L
Linus Torvalds 已提交
117 118
	schedule();

O
Oleg Nesterov 已提交
119 120
	ret = -EINTR;
	if (!self.should_stop)
L
Linus Torvalds 已提交
121 122
		ret = threadfn(data);

O
Oleg Nesterov 已提交
123 124
	/* we can't just return, we must preserve "self" on stack */
	do_exit(ret);
L
Linus Torvalds 已提交
125 126
}

127 128 129 130 131 132 133 134 135 136
/* 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();
}

137
static void create_kthread(struct kthread_create_info *create)
L
Linus Torvalds 已提交
138 139 140
{
	int pid;

141 142 143
#ifdef CONFIG_NUMA
	current->pref_node_fork = create->node;
#endif
L
Linus Torvalds 已提交
144 145
	/* We want our own signal handler (we take no signals by default). */
	pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
146
	if (pid < 0) {
L
Linus Torvalds 已提交
147
		create->result = ERR_PTR(pid);
148 149
		complete(&create->done);
	}
L
Linus Torvalds 已提交
150 151
}

152
/**
153
 * kthread_create_on_node - create a kthread.
154 155
 * @threadfn: the function to run until signal_pending(current).
 * @data: data ptr for @threadfn.
156
 * @node: memory node number.
157 158 159 160
 * @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
161
 * it.  See also kthread_run().
162
 *
163 164
 * 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.
165
 * When woken, the thread will run @threadfn() with @data as its
166
 * argument. @threadfn() can either call do_exit() directly if it is a
L
Lucas De Marchi 已提交
167
 * standalone thread for which no one will call kthread_stop(), or
168 169 170 171 172 173
 * 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).
 */
174 175 176 177 178
struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
					   void *data,
					   int node,
					   const char namefmt[],
					   ...)
L
Linus Torvalds 已提交
179 180 181 182 183
{
	struct kthread_create_info create;

	create.threadfn = threadfn;
	create.data = data;
184
	create.node = node;
L
Linus Torvalds 已提交
185
	init_completion(&create.done);
186 187 188 189 190

	spin_lock(&kthread_create_lock);
	list_add_tail(&create.list, &kthread_create_list);
	spin_unlock(&kthread_create_lock);

191
	wake_up_process(kthreadd_task);
192 193
	wait_for_completion(&create.done);

L
Linus Torvalds 已提交
194
	if (!IS_ERR(create.result)) {
195
		static const struct sched_param param = { .sched_priority = 0 };
L
Linus Torvalds 已提交
196
		va_list args;
197

L
Linus Torvalds 已提交
198 199 200 201
		va_start(args, namefmt);
		vsnprintf(create.result->comm, sizeof(create.result->comm),
			  namefmt, args);
		va_end(args);
202 203 204 205 206 207
		/*
		 * 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, &param);
		set_cpus_allowed_ptr(create.result, cpu_all_mask);
L
Linus Torvalds 已提交
208 209 210
	}
	return create.result;
}
211
EXPORT_SYMBOL(kthread_create_on_node);
L
Linus Torvalds 已提交
212

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
/**
 * 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;
	}

230 231
	/* It's safe because the task is inactive. */
	do_set_cpus_allowed(p, cpumask_of(cpu));
232 233 234 235
	p->flags |= PF_THREAD_BOUND;
}
EXPORT_SYMBOL(kthread_bind);

236 237 238 239 240
/**
 * 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
241 242 243 244 245 246
 * 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.
247 248 249 250
 *
 * Returns the result of threadfn(), or %-EINTR if wake_up_process()
 * was never called.
 */
L
Linus Torvalds 已提交
251 252
int kthread_stop(struct task_struct *k)
{
O
Oleg Nesterov 已提交
253
	struct kthread *kthread;
L
Linus Torvalds 已提交
254 255
	int ret;

256
	trace_sched_kthread_stop(k);
O
Oleg Nesterov 已提交
257
	get_task_struct(k);
258

O
Oleg Nesterov 已提交
259 260 261 262 263 264 265 266
	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;
L
Linus Torvalds 已提交
267 268

	put_task_struct(k);
269 270
	trace_sched_kthread_stop_ret(ret);

L
Linus Torvalds 已提交
271 272
	return ret;
}
273
EXPORT_SYMBOL(kthread_stop);
L
Linus Torvalds 已提交
274

275
int kthreadd(void *unused)
L
Linus Torvalds 已提交
276
{
277
	struct task_struct *tsk = current;
L
Linus Torvalds 已提交
278

279
	/* Setup a clean context for our children to inherit. */
280
	set_task_comm(tsk, "kthreadd");
281
	ignore_signals(tsk);
282
	set_cpus_allowed_ptr(tsk, cpu_all_mask);
283
	set_mems_allowed(node_states[N_HIGH_MEMORY]);
284

285
	current->flags |= PF_NOFREEZE;
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310

	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;
}
T
Tejun Heo 已提交
311

Y
Yong Zhang 已提交
312 313 314 315 316 317 318 319 320 321 322
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);

T
Tejun Heo 已提交
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
/**
 * 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);

381 382 383 384 385 386 387 388 389 390 391 392 393
/* insert @work before @pos in @worker */
static void insert_kthread_work(struct kthread_worker *worker,
			       struct kthread_work *work,
			       struct list_head *pos)
{
	lockdep_assert_held(&worker->lock);

	list_add_tail(&work->node, pos);
	work->queue_seq++;
	if (likely(worker->task))
		wake_up_process(worker->task);
}

T
Tejun Heo 已提交
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
/**
 * 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)) {
411
		insert_kthread_work(worker, work, &worker->work_list);
T
Tejun Heo 已提交
412 413 414 415 416 417 418
		ret = true;
	}
	spin_unlock_irqrestore(&worker->lock, flags);
	return ret;
}
EXPORT_SYMBOL_GPL(queue_kthread_work);

419 420 421 422 423 424 425 426 427 428 429 430
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);
}

T
Tejun Heo 已提交
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478
/**
 * 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);

/**
 * 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);