Linux内核进程和线程组织模型 （基于Kernel 4.3-rc3）

在linux内核代码里面，看到有for_each_process()和for_each_process_thread()两个函数，不太明白怎么回事，就做了个代码实验

1. 验证代码

/*****************************************************************
* Copyright (C) 2015 Intel Technology Co.,Ltd.*
******************************************************************
* lsitprocess.c
*
* DESCRIPTION:
* 	列出所有的进程/线程
* AUTHOR:
* 刘峰 11579502
*
* CREATED DATE:
* 2015年09月17日
* REVISION:
* 1.0
*
* MODIFICATION HISTORY
* --------------------
* $Log:$
* 刘峰 2015年09月17日  Creation
*****************************************************************/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/proc_fs.h>
#include <linux/time.h>
#include <linux/hrtimer.h>
#include <linux/kvm_para.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>
#include <stdbool.h>
#include <asm/msr.h>
#include <linux/slab.h>
#include <asm/page_64_types.h>

#include <linux/sched.h>

#define LOCAL		static

#define KMOD_DBGDUMP(fmt, args...) printk(KERN_DEBUG "LISTPROCESS[%d] "fmt" \r\n", __LINE__, args);	 
#define KMOD_RAWDUMP(args...) printk(args); /* RAW 信息输出 */

LOCAL struct proc_dir_entry *proc_file = NULL;
LOCAL int32_t kmod_action_sw = 8;

#define TEST_CASE_1	(1)
#define TEST_CASE_2	(2)
#define TEST_CASE_3	(3)

#define KMODSEPC	

/******************************************************************************
* DESCRIPTION:
*       利用list_for_each_entry进行打印
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
void listprocess_test_case_1(void){
	struct task_struct *task = NULL;
	struct task_struct *p = NULL;
	struct list_head *pos;
	int count = 0;

	printk("list_for_each\n");
	printk("PID\tCOMM\n");
	task = &init_task;
	list_for_each(pos, &task->tasks ) {
		p = list_entry(pos, struct task_struct, tasks);
		count++;
		printk("%d\t%s\n", p->pid, p->comm);
	}
	printk("Total process %d\n", count);
	return;
}

/******************************************************************************
* DESCRIPTION:
*       利用for_each_process进行打印
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
void listprocess_test_case_2(void){
	struct task_struct *tsk;
	int count = 0;

	printk("for_each_process\n");
	printk("PID\tCOMM\n");
	for_each_process(tsk){
		count++;
		printk("%d\t%s\n", tsk->pid, tsk->comm);
	}
	printk("Total process %d\n", count);
	
	return;
}


/******************************************************************************
* DESCRIPTION:
*       利用for_each_process_thread进行打印
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/

void listprocess_test_case_3(void){
	struct task_struct *p;
	struct task_struct *t;
	int count = 0;

	printk("for_each_process_thread\n");
	printk("PID\tCOMM\n");	
	for_each_process_thread(p,t){
		count++;
		printk("%d\t%s\n", t->pid, t->comm);
	}
	printk("Total thread %d\n", count);

	return;
}


#if 1
KMODSEPC
#endif




/******************************************************************************
* DESCRIPTION:
*       PROC 文件读方法
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
LOCAL int kmod_proc_read(struct seq_file * m, void * v)
{
	seq_printf(m, "Entering kmod_proc_read\n");
    return 0;
}



/******************************************************************************
* DESCRIPTION:
*       PROC 文件写方法
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
static ssize_t kmod_proc_write(struct file *file, const char __user *buffer, size_t count, loff_t *pos)
{
	char debug_string[sizeof("4294967295")];
	kmod_action_sw = 0;

	KMOD_DBGDUMP("%s","Entering kmod_proc_write");

	if (count >= sizeof(debug_string))
		return -EINVAL;
	
	if (copy_from_user(debug_string, buffer, count))
		return -EFAULT;	

	debug_string[count] = '\0';
	if (sscanf(debug_string, "%d", &kmod_action_sw) != 1)
		return -EINVAL;

	KMOD_DBGDUMP("write kmod_action_sw = %d\n", kmod_action_sw);


	/*运行测试用例*/
	switch(kmod_action_sw)
	{
		case TEST_CASE_1:
			listprocess_test_case_1();
			break;
		case TEST_CASE_2:
			listprocess_test_case_2();
			break;
		case TEST_CASE_3:
			listprocess_test_case_3();
			break;
		default:
			KMOD_DBGDUMP("%s","not support timer test case");
	}
	
 	return count;		

	return count;	
}


/******************************************************************************
* DESCRIPTION:
*       PROC 文件打开方法
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
static int kmod_proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, kmod_proc_read, NULL);
}


/*
 * PROC文件操作列表
 */
LOCAL const struct file_operations kmod_proc_fops = {
	.open    = kmod_proc_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
	.write   = kmod_proc_write,
};

/******************************************************************************
* DESCRIPTION:
*       初始化PROC 目录
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
LOCAL int kmod_proc_init(void)
{
	proc_file = proc_create("listprocess", 0666, NULL, &kmod_proc_fops);
	if(!proc_file){
		KMOD_DBGDUMP("%s","Can't create /proc/listprocess\n");
	}

	KMOD_DBGDUMP("%s","kmod_proc_init OK\n");
	return 0;
}

/******************************************************************************
* DESCRIPTION:
*       删除PROC 目录
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
LOCAL void kmod_proc_remove(void)
{
	remove_proc_entry("listprocess",NULL);
	return;
}


/******************************************************************************
* DESCRIPTION:
*       模块初始化函数
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
LOCAL int32_t __init listprocess_init(void)
{
	kmod_proc_init();
  	
	KMOD_DBGDUMP("%s","glistprocess_init init OK\n");
	return 0;
}

/******************************************************************************
* DESCRIPTION:
*       模块卸载函数
* INPUTS:
*       none
* OUTPUTS:
*       none
* RETURNS:
*       none
******************************************************************************/
LOCAL void __exit listprocess_exit(void)
{  	
	kmod_proc_remove();
	
	KMOD_DBGDUMP("%s","listprocess_exit exit OK\n");	
	return;
}

MODULE_LICENSE ( "GPL" );
module_init (listprocess_init);
module_exit (listprocess_exit);

编译为listprocess.ko模块

2. 实验步骤

启动一个多线程的程序test

[root@localhost ~]# ps -efL | grep test
root       6569   6410   6569  0    2 22:52 pts/0    00:00:00 ./test
root       6569   6410   6570  0    2 22:52 pts/0    00:00:00 ./test
root       7754   7658   7754  0    1 23:15 pts/2    00:00:00 grep --color=auto test

插入模块并验证

[root@localhost ~]# echo 2 > /proc/listprocess
[root@localhost ~]# dmesg | grep test

[ 3198.656973] 6569     test

[root@localhost ~]# echo 3 > /proc/listprocess
[root@localhost ~]# dmesg -c | grep test
[ 3229.872902] 6569     test

[ 3229.872903] 6570     test

3. 结论

系统中所有的进程都组织在init_task的tasks链表下面，每个进程的线程组织在每个进程task_sturct->signal的链表下，如下图所示