自学教程：C++ to_kthread函数代码示例

/** * kthread_create_on_cpu - Create a cpu bound kthread * @threadfn: the function to run until signal_pending(current). * @data: data ptr for @threadfn. * @cpu: The cpu on which the thread should be bound, * @namefmt: printf-style name for the thread. Format is restricted *	     to "name.*%u". Code fills in cpu number. * * Description: This helper function creates and names a kernel thread * The thread will be woken and put into park mode. */struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data),					  void *data, unsigned int cpu,					  const char *namefmt){	struct task_struct *p;	p = kthread_create_on_node(threadfn, data, cpu_to_mem(cpu), namefmt,				   cpu);	if (IS_ERR(p))		return p;	set_bit(KTHREAD_IS_PER_CPU, &to_kthread(p)->flags);	to_kthread(p)->cpu = cpu;	/* Park the thread to get it out of TASK_UNINTERRUPTIBLE state */	kthread_park(p);	return p;}

/** * probe_kthread_data - speculative version of kthread_data() * @task: possible kthread task in question * * @task could be a kthread task.  Return the data value specified when it * was created if accessible.  If @task isn't a kthread task or its data is * inaccessible for any reason, %NULL is returned.  This function requires * that @task itself is safe to dereference. */void *probe_kthread_data(struct task_struct *task){	struct kthread *kthread = to_kthread(task);	void *data = NULL;	probe_kernel_read(&data, &kthread->data, sizeof(data));	return data;}

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

/** * kthread_should_stop - should this kthread return now? * * When someone calls kthread_stop() on your kthread, it will be woken * and this will return true.  You should then return, and your return * value will be passed through to kthread_stop(). */int kthread_should_stop(void){	return to_kthread(current)->should_stop;}

//.........这里部分代码省略......... */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;	}	/* It's safe because the task is inactive. */	do_set_cpus_allowed(p, cpumask_of(cpu));	p->flags |= PF_THREAD_BOUND;}EXPORT_SYMBOL(kthread_bind);/** * 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);	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;	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, cpu_all_mask);	set_mems_allowed(node_states[N_HIGH_MEMORY]);	current->flags |= PF_NOFREEZE | PF_FREEZER_NOSIG;	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 __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;}

/** * kthread_should_park - should this kthread park now? * * When someone calls kthread_park() on your kthread, it will be woken * and this will return true.  You should then do the necessary * cleanup and call kthread_parkme() * * Similar to kthread_should_stop(), but this keeps the thread alive * and in a park position. kthread_unpark() "restarts" the thread and * calls the thread function again. */bool kthread_should_park(void){	return test_bit(KTHREAD_SHOULD_PARK, &to_kthread(current)->flags);}

/** * kthread_should_stop - should this kthread return now? * * When someone calls kthread_stop() on your kthread, it will be woken * and this will return true.  You should then return, and your return * value will be passed through to kthread_stop(). */bool kthread_should_stop(void){	return test_bit(KTHREAD_SHOULD_STOP, &to_kthread(current)->flags);}

void kthread_parkme(void){	__kthread_parkme(to_kthread(current));}

struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),					   void *data,					   int node,					   const char namefmt[],					   ...){	struct kthread_create_info create;	create.threadfn = threadfn;	create.data = data;	create.node = node;	init_completion(&create.done);	spin_lock(&kthread_create_lock);	list_add_tail(&create.list, &kthread_create_list);	spin_unlock(&kthread_create_lock);	wake_up_process(kthreadd_task);	wait_for_completion(&create.done);	if (!IS_ERR(create.result)) {		static const struct sched_param param = { .sched_priority = 0 };		va_list args;		va_start(args, namefmt);		vsnprintf(create.result->comm, sizeof(create.result->comm),			  namefmt, args);		va_end(args);		/*                                                                                                                               */		sched_setscheduler_nocheck(create.result, SCHED_NORMAL, &param);		set_cpus_allowed_ptr(create.result, cpu_all_mask);	}	return create.result;}EXPORT_SYMBOL(kthread_create_on_node);/*                                                                                                                                                                                                                                                                                                                                                                         */void kthread_bind(struct task_struct *p, unsigned int cpu){	/*                                                               */	if (!wait_task_inactive(p, TASK_UNINTERRUPTIBLE)) {		WARN_ON(1);		return;	}	/*                                         */	do_set_cpus_allowed(p, cpumask_of(cpu));	p->flags |= PF_THREAD_BOUND;}EXPORT_SYMBOL(kthread_bind);/*                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         */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);	barrier(); /*                      */	if (k->vfork_done != NULL) {		kthread->should_stop = 1;		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);//.........这里部分代码省略.........

/** * kthread_create_ve - create a kthread. * @threadfn: the function to run until signal_pending(current). * @data: data ptr for @threadfn. * @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 * it.  See also kthread_run(), kthread_create_on_cpu(). * * When woken, the thread will run @threadfn() with @data as its * argument. @threadfn() can either call do_exit() directly if it is a * standalone thread for which noone will call kthread_stop(), or * 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). */struct task_struct *kthread_create_ve(struct ve_struct *ve,				   int (*threadfn)(void *data),				   void *data,				   const char namefmt[],				   ...){	struct kthread_create_info create;	struct ve_struct *old_ve;	old_ve = set_exec_env(ve);	create.threadfn = threadfn;	create.data = data;	init_completion(&create.done);	spin_lock(&kthread_create_lock);	list_add_tail(&create.list, &kthread_create_list);	spin_unlock(&kthread_create_lock);	wake_up_process(kthreadd_task);	wait_for_completion(&create.done);	if (!IS_ERR(create.result)) {		struct sched_param param = { .sched_priority = 0 };		va_list args;		va_start(args, namefmt);		vsnprintf(create.result->comm, sizeof(create.result->comm),			  namefmt, args);		va_end(args);		/*		 * 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);	}	set_exec_env(old_ve);	return create.result;}EXPORT_SYMBOL(kthread_create_ve);/** * 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);	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;	put_task_struct(k);	trace_sched_kthread_stop_ret(ret);	return ret;}//.........这里部分代码省略.........

/** * kthread_create - create a kthread. * @threadfn: the function to run until signal_pending(current). * @data: data ptr for @threadfn. * @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 * it.  See also kthread_run(), kthread_create_on_cpu(). * * When woken, the thread will run @threadfn() with @data as its * argument. @threadfn() can either call do_exit() directly if it is a * standalone thread for which noone will call kthread_stop(), or * 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). */struct task_struct *kthread_create(int (*threadfn)(void *data),				   void *data,				   const char namefmt[],				   ...){	struct kthread_create_info create;	create.threadfn = threadfn;	create.data = data;	init_completion(&create.done);	spin_lock(&kthread_create_lock);	list_add_tail(&create.list, &kthread_create_list);	spin_unlock(&kthread_create_lock);	wake_up_process(kthreadd_task);	wait_for_completion(&create.done);	if (!IS_ERR(create.result)) {		struct sched_param param = { .sched_priority = 0 };		va_list args;		va_start(args, namefmt);		vsnprintf(create.result->comm, sizeof(create.result->comm),			  namefmt, args);		va_end(args);		/*		 * 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);	}	return create.result;}EXPORT_SYMBOL(kthread_create);/** * 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);	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;	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. *///.........这里部分代码省略.........