linux有没有内核级线程

struct thread_info {	int			preempt_count;	/* 0 => preemptable, <0 => bug */	struct task_struct	*task;		/* main task structure */	__u32			cpu;		/* cpu */};

struct task_struct {		pid_t pid;		pid_t tgid;	void *stack;	struct mm_struct *mm, *active_mm;	/* filesystem information */	struct fs_struct *fs;	/* open file information */	struct files_struct *files;};#define task_thread_info(task)	((struct thread_info *)(task)->stack)

pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags){	return do_fork(flags|CLONE_VM|CLONE_UNTRACED, (unsigned long)fn,		(unsigned long)arg, NULL, NULL);}pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);

#define kthread_run(threadfn, data, namefmt, ...)			   \({									   \	struct task_struct *__k						   \		= kthread_create(threadfn, data, namefmt, ## __VA_ARGS__); \	if (!IS_ERR(__k))						   \		wake_up_process(__k);					   \	__k;								   \})#define kthread_create(threadfn, data, namefmt, arg...) \	kthread_create_on_node(threadfn, data, -1, namefmt, ##arg)struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),					   void *data, int node,					   const char namefmt[],					   ...){	DECLARE_COMPLETION_ONSTACK(done);	struct task_struct *task;	/*分配kthread_create_info空间*/	struct kthread_create_info *create = kmalloc(sizeof(*create),						     GFP_KERNEL);	if (!create)		return ERR_PTR(-ENOMEM);	create->threadfn = threadfn;	create->data = data;	create->node = node;	create->done = &done;	/*加入到kthread_creta_list列表中，等待ktherad_add中断线程去创建改线程*/	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 in killable state, for I might be chosen by	* the OOM killer while kthreadd is trying to allocate memory for	* new kernel thread.	*/	if (unlikely(wait_for_completion_killable(&done))) {		/*		* If I was SIGKILLed before kthreadd (or new kernel thread)		* calls complete(), leave the cleanup of this structure to		* that thread.		*/		if (xchg(&create->done, NULL))			return ERR_PTR(-EINTR);		/*		* kthreadd (or new kernel thread) will call complete()		* shortly.		*/		wait_for_completion(&done);	}	task = create->result;	.	.	.	kfree(create);	return task;}

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_MEMORY]);	current->flags |= PF_NOFREEZE;		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;}

static void create_kthread(struct kthread_create_info *create){	int pid;	/* We want our own signal handler (we take no signals by default). */	pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);	if (pid < 0) {		/* If user was SIGKILLed, I release the structure. */		struct completion *done = xchg(&create->done, NULL);		if (!done) {			kfree(create);			return;		}		create->result = ERR_PTR(pid);		complete(done);	}}

static int kthread(void *_create){	.	.	.	.	/* If user was SIGKILLed, I release the structure. */	done = xchg(&create->done, NULL);	if (!done) {		kfree(create);		do_exit(-EINTR);	}	/* OK, tell user we're spawned, wait for stop or wakeup */	__set_current_state(TASK_UNINTERRUPTIBLE);	create->result = current;	complete(done);	schedule();	ret = -EINTR;	if (!test_bit(KTHREAD_SHOULD_STOP, &self.flags)) {		__kthread_parkme(&self);		ret = threadfn(data);	}	/* we can't just return, we must preserve "self" on stack */	do_exit(ret);}

int kthread_stop(struct task_struct *k){	struct kthread *kthread;	int ret;	trace_sched_kthread_stop(k);	get_task_struct(k);	kthread = to_live_kthread(k);	if (kthread) {		set_bit(KTHREAD_SHOULD_STOP, &kthread->flags);		__kthread_unpark(k, kthread);		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;}

thread_func(){    // do your work here    // wait to exit    while(!thread_could_stop())    {           wait();    }}exit_code(){     kthread_stop(_task);   //发信号给task，通知其可以退出了}

#include "test_kthread.h"#include <linux/delay.h>#include <linux/timer.h>#include <linux/platform_device.h>#include <linux/fs.h>#include <linux/module.h>static struct task_struct *test_thread = NULL;unsigned int time_conut = 5;int  test_thread_fun(void *data){	int times = 0;	while(!kthread_should_stop())	{		printk("\n   printk %u\r\n", times);		times++;		msleep_interruptible(time_conut*1000);	}	printk("\n   test_thread_fun exit success\r\n\n");	return 0;}void register_test_thread(void){	test_thread = kthread_run(test_thread_fun , NULL, "test_kthread" );	    if (IS_ERR(test_thread)){         printk(KERN_INFO "create test_thread failed!\n");     }      else {         printk(KERN_INFO "create test_thread ok!\n");      } 	}static ssize_t kthread_debug_start(struct device *dev, struct device_attribute *attr, char *buf){	register_test_thread();		return 0;	}static ssize_t kthread_debug_stop(struct device *dev, struct device_attribute *attr, char *buf){	kthread_stop(test_thread);		return 0;	}static DEVICE_ATTR(kthread_start,  S_IRUSR,  kthread_debug_start,NULL);static DEVICE_ATTR(kthread_stop, S_IRUSR,    kthread_debug_stop,NULL);struct attribute * kthread_group_info_attrs[] = {	&dev_attr_kthread_start.attr,	&dev_attr_kthread_stop.attr,		NULL,};struct attribute_group kthread_group = {	.name = "kthread",	.attrs = kthread_group_info_attrs,};