1338 lines · 36.4 KB · C
RawDownload
/** * kthread_unpark - unpark a thread created by kthread_create(). * @k:		thread created by kthread_create(). * * Sets kthread_should_park() for @k to return false, wakes it, and * waits for it to return. If the thread is marked percpu then its * bound to the cpu again. */void kthread_unpark(struct task_struct *k){	struct kthread *kthread = to_kthread(k); 	/*	 * Newly created kthread was parked when the CPU was offline.	 * The binding was lost and we need to set it again.	 */	if (test_bit(KTHREAD_IS_PER_CPU, &kthread->flags))		__kthread_bind(k, kthread->cpu, TASK_PARKED); 	clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);	/*	 * __kthread_parkme() will either see !SHOULD_PARK or get the wakeup.	 */	wake_up_state(k, TASK_PARKED);}EXPORT_SYMBOL_GPL(kthread_unpark); /** * kthread_park - park a thread created by kthread_create(). * @k: thread created by kthread_create(). * * Sets kthread_should_park() for @k to return true, wakes it, and * waits for it to return. This can also be called after kthread_create() * instead of calling wake_up_process(): the thread will park without * calling threadfn(). * * Returns 0 if the thread is parked, -ENOSYS if the thread exited. * If called by the kthread itself just the park bit is set. */int kthread_park(struct task_struct *k){	struct kthread *kthread = to_kthread(k); 	if (WARN_ON(k->flags & PF_EXITING))		return -ENOSYS; 	if (WARN_ON_ONCE(test_bit(KTHREAD_SHOULD_PARK, &kthread->flags)))		return -EBUSY; 	set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);	if (k != current) {		wake_up_process(k);		/*		 * Wait for __kthread_parkme() to complete(), this means we		 * _will_ have TASK_PARKED and are about to call schedule().		 */		wait_for_completion(&kthread->parked);		/*		 * Now wait for that schedule() to complete and the task to		 * get scheduled out.		 */		WARN_ON_ONCE(!wait_task_inactive(k, TASK_PARKED));	} 	return 0;}EXPORT_SYMBOL_GPL(kthread_park); /** * 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 * 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. * * Returns the result of threadfn(), or %-EINTR if wake_up_process() * was never called. */int kthread_stop(struct task_struct *k){	struct kthread *kthread;	int ret; 	trace_sched_kthread_stop(k); 	get_task_struct(k);	kthread = to_kthread(k);	set_bit(KTHREAD_SHOULD_STOP, &kthread->flags);	kthread_unpark(k);	wake_up_process(k);	wait_for_completion(&kthread->exited);	ret = k->exit_code;	put_task_struct(k); 	trace_sched_kthread_stop_ret(ret);	return ret;}EXPORT_SYMBOL(kthread_stop); int kthreadd(void *unused){	struct task_struct *tsk = current; 	/* Setup a clean context for our children to inherit. */	set_task_comm(tsk, "kthreadd");	ignore_signals(tsk);	set_cpus_allowed_ptr(tsk, housekeeping_cpumask(HK_FLAG_KTHREAD));	set_mems_allowed(node_states[N_MEMORY]); 	current->flags |= PF_NOFREEZE;	cgroup_init_kthreadd(); 	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;} void __kthread_init_worker(struct kthread_worker *worker,				const char *name,				struct lock_class_key *key){	memset(worker, 0, sizeof(struct kthread_worker));	raw_spin_lock_init(&worker->lock);	lockdep_set_class_and_name(&worker->lock, key, name);	INIT_LIST_HEAD(&worker->work_list);	INIT_LIST_HEAD(&worker->delayed_work_list);}EXPORT_SYMBOL_GPL(__kthread_init_worker); /** * kthread_worker_fn - kthread function to process kthread_worker * @worker_ptr: pointer to initialized kthread_worker * * This function implements the main cycle of kthread worker. It processes * work_list until it is stopped with kthread_stop(). It sleeps when the queue * is empty. * * The works are not allowed to keep any locks, disable preemption or interrupts * when they finish. There is defined a safe point for freezing when one work * finishes and before a new one is started. * * Also the works must not be handled by more than one worker at the same time, * see also kthread_queue_work(). */int kthread_worker_fn(void *worker_ptr){	struct kthread_worker *worker = worker_ptr;	struct kthread_work *work; 	/*	 * FIXME: Update the check and remove the assignment when all kthread	 * worker users are created using kthread_create_worker*() functions.	 */	WARN_ON(worker->task && worker->task != current);	worker->task = current; 	if (worker->flags & KTW_FREEZABLE)		set_freezable(); repeat:	set_current_state(TASK_INTERRUPTIBLE);	/* mb paired w/ kthread_stop */ 	if (kthread_should_stop()) {		__set_current_state(TASK_RUNNING);		raw_spin_lock_irq(&worker->lock);		worker->task = NULL;		raw_spin_unlock_irq(&worker->lock);		return 0;	} 	work = NULL;	raw_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);	}	worker->current_work = work;	raw_spin_unlock_irq(&worker->lock); 	if (work) {		__set_current_state(TASK_RUNNING);		work->func(work);	} else if (!freezing(current))		schedule(); 	try_to_freeze();	cond_resched();	goto repeat;}EXPORT_SYMBOL_GPL(kthread_worker_fn); static __printf(3, 0) struct kthread_worker *__kthread_create_worker(int cpu, unsigned int flags,			const char namefmt[], va_list args){	struct kthread_worker *worker;	struct task_struct *task;	int node = NUMA_NO_NODE; 	worker = kzalloc(sizeof(*worker), GFP_KERNEL);	if (!worker)		return ERR_PTR(-ENOMEM); 	kthread_init_worker(worker); 	if (cpu >= 0)		node = cpu_to_node(cpu); 	task = __kthread_create_on_node(kthread_worker_fn, worker,						node, namefmt, args);	if (IS_ERR(task))		goto fail_task; 	if (cpu >= 0)		kthread_bind(task, cpu); 	worker->flags = flags;	worker->task = task;	wake_up_process(task);	return worker; fail_task:	kfree(worker);	return ERR_CAST(task);} /** * kthread_create_worker - create a kthread worker * @flags: flags modifying the default behavior of the worker * @namefmt: printf-style name for the kthread worker (task). * * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM) * when the needed structures could not get allocated, and ERR_PTR(-EINTR) * when the worker was SIGKILLed. */struct kthread_worker *kthread_create_worker(unsigned int flags, const char namefmt[], ...){	struct kthread_worker *worker;	va_list args; 	va_start(args, namefmt);	worker = __kthread_create_worker(-1, flags, namefmt, args);	va_end(args); 	return worker;}EXPORT_SYMBOL(kthread_create_worker); /** * kthread_create_worker_on_cpu - create a kthread worker and bind it *	it to a given CPU and the associated NUMA node. * @cpu: CPU number * @flags: flags modifying the default behavior of the worker * @namefmt: printf-style name for the kthread worker (task). * * Use a valid CPU number if you want to bind the kthread worker * to the given CPU and the associated NUMA node. * * A good practice is to add the cpu number also into the worker name. * For example, use kthread_create_worker_on_cpu(cpu, "helper/%d", cpu). * * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM) * when the needed structures could not get allocated, and ERR_PTR(-EINTR) * when the worker was SIGKILLed. */struct kthread_worker *kthread_create_worker_on_cpu(int cpu, unsigned int flags,			     const char namefmt[], ...){	struct kthread_worker *worker;	va_list args; 	va_start(args, namefmt);	worker = __kthread_create_worker(cpu, flags, namefmt, args);	va_end(args); 	return worker;}EXPORT_SYMBOL(kthread_create_worker_on_cpu); /* * Returns true when the work could not be queued at the moment. * It happens when it is already pending in a worker list * or when it is being cancelled. */static inline bool queuing_blocked(struct kthread_worker *worker,				   struct kthread_work *work){	lockdep_assert_held(&worker->lock); 	return !list_empty(&work->node) || work->canceling;} static void kthread_insert_work_sanity_check(struct kthread_worker *worker,					     struct kthread_work *work){	lockdep_assert_held(&worker->lock);	WARN_ON_ONCE(!list_empty(&work->node));	/* Do not use a work with >1 worker, see kthread_queue_work() */	WARN_ON_ONCE(work->worker && work->worker != worker);} /* insert @work before @pos in @worker */static void kthread_insert_work(struct kthread_worker *worker,				struct kthread_work *work,				struct list_head *pos){	kthread_insert_work_sanity_check(worker, work); 	list_add_tail(&work->node, pos);	work->worker = worker;	if (!worker->current_work && likely(worker->task))		wake_up_process(worker->task);} /** * kthread_queue_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. * * Reinitialize the work if it needs to be used by another worker. * For example, when the worker was stopped and started again. */bool kthread_queue_work(struct kthread_worker *worker,			struct kthread_work *work){	bool ret = false;	unsigned long flags; 	raw_spin_lock_irqsave(&worker->lock, flags);	if (!queuing_blocked(worker, work)) {		kthread_insert_work(worker, work, &worker->work_list);		ret = true;	}	raw_spin_unlock_irqrestore(&worker->lock, flags);	return ret;}EXPORT_SYMBOL_GPL(kthread_queue_work); /** * kthread_delayed_work_timer_fn - callback that queues the associated kthread *	delayed work when the timer expires. * @t: pointer to the expired timer * * The format of the function is defined by struct timer_list. * It should have been called from irqsafe timer with irq already off. */void kthread_delayed_work_timer_fn(struct timer_list *t){	struct kthread_delayed_work *dwork = from_timer(dwork, t, timer);	struct kthread_work *work = &dwork->work;	struct kthread_worker *worker = work->worker;	unsigned long flags; 	/*	 * This might happen when a pending work is reinitialized.	 * It means that it is used a wrong way.	 */	if (WARN_ON_ONCE(!worker))		return; 	raw_spin_lock_irqsave(&worker->lock, flags);	/* Work must not be used with >1 worker, see kthread_queue_work(). */	WARN_ON_ONCE(work->worker != worker); 	/* Move the work from worker->delayed_work_list. */	WARN_ON_ONCE(list_empty(&work->node));	list_del_init(&work->node);	kthread_insert_work(worker, work, &worker->work_list); 	raw_spin_unlock_irqrestore(&worker->lock, flags);}EXPORT_SYMBOL(kthread_delayed_work_timer_fn); static void __kthread_queue_delayed_work(struct kthread_worker *worker,					 struct kthread_delayed_work *dwork,					 unsigned long delay){	struct timer_list *timer = &dwork->timer;	struct kthread_work *work = &dwork->work; 	WARN_ON_ONCE(timer->function != kthread_delayed_work_timer_fn); 	/*	 * If @delay is 0, queue @dwork->work immediately.  This is for	 * both optimization and correctness.  The earliest @timer can	 * expire is on the closest next tick and delayed_work users depend	 * on that there's no such delay when @delay is 0.	 */	if (!delay) {		kthread_insert_work(worker, work, &worker->work_list);		return;	} 	/* Be paranoid and try to detect possible races already now. */	kthread_insert_work_sanity_check(worker, work); 	list_add(&work->node, &worker->delayed_work_list);	work->worker = worker;	timer->expires = jiffies + delay;	add_timer(timer);} /** * kthread_queue_delayed_work - queue the associated kthread work *	after a delay. * @worker: target kthread_worker * @dwork: kthread_delayed_work to queue * @delay: number of jiffies to wait before queuing * * If the work has not been pending it starts a timer that will queue * the work after the given @delay. If @delay is zero, it queues the * work immediately. * * Return: %false if the @work has already been pending. It means that * either the timer was running or the work was queued. It returns %true * otherwise. */bool kthread_queue_delayed_work(struct kthread_worker *worker,				struct kthread_delayed_work *dwork,				unsigned long delay){	struct kthread_work *work = &dwork->work;	unsigned long flags;	bool ret = false; 	raw_spin_lock_irqsave(&worker->lock, flags); 	if (!queuing_blocked(worker, work)) {		__kthread_queue_delayed_work(worker, dwork, delay);		ret = true;	} 	raw_spin_unlock_irqrestore(&worker->lock, flags);	return ret;}EXPORT_SYMBOL_GPL(kthread_queue_delayed_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);} /** * kthread_flush_work - flush a kthread_work * @work: work to flush * * If @work is queued or executing, wait for it to finish execution. */void kthread_flush_work(struct kthread_work *work){	struct kthread_flush_work fwork = {		KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),		COMPLETION_INITIALIZER_ONSTACK(fwork.done),	};	struct kthread_worker *worker;	bool noop = false; 	worker = work->worker;	if (!worker)		return; 

Lines 501–1000 of 1338. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t