linux有內(nèi)核級線程么

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中斷線程去創(chuàng)建改線程*/ 	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);   //發(fā)信號給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 %urn", times); 		times++; 		msleep_interruptible(time_conut*1000); 	}  	printk("n   test_thread_fun exit successrnn");  	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, };