Linux内核中增加一个系统调用.doc

选题要求：在Linux内核中增加一个系统调用，并编写对应的linux应用程序。利用该系统调用能够遍历系统当前所有进程的任务描述符，并按进程父子关系将这些描述符所对应的进程id（PID）组织成树形结构显示。

目录

一.程序的主要设计思路，实现方式 1
1.1 添加系统调用的两种方法 1
1.1.1编译内核法 1
1.1.2内核模块法 1
1.2 程序的主要设计思路 1
1.3 环境 2
二.程序的模块划分，及对每个模块的说明 2
2.1 通过内核模块实现添加系统调用 2
2.1.1修改系统调用的模块 2
2.1.2获取sys_call_table的地址 2
2.1.3清除内存区域的写保护 3
2.2 编写系统调用指定自己的系统调用 4
2.2.1内核的初始化函数 4
2.2.2自己的系统调用服务例程 4
2.2.3移除内核模块时，将原有的系统调用进行还原 6
2.2.4模块注册相关 6
2.3 编写用户态的测试程序 6
2.4 编写Makefile文件 7
三.所遇到的问题及解决的方法 8
3.1 进程个数确定 8
3.2 被更改的系统调用号的选择 8
3.3 获取系统调用表的地址 8
3.4 内核和用户态数据交换 8
四.程序运行结果及使用说明 8
4.1 将编译出来的内核模块hello.ko加载到内核中 8
4.2通过dmesg查看输出信息是否正确 9
4.3运行测试程序，输出树状打印结果（部分结果截图） 9
4.4卸载自定义模块 10
五.附录 11
5.1 内核模块程序hello.c 11
5.2 测试程序hello_test.c 14
5.3 Makefile文件 14

Linux内核分析课程大作业
一.程序的主要设计思路，实现方式
1.1 添加系统调用的两种方法
1.1.1编译内核法
编写好源码之后
· 修改内核的系统调用库函数 /usr/include/asm-generic/unistd.h，在这里面可以使用在syscall_table中没有用到的223号
· 添加系统调用号，让系统根据这个号，去找到syscall_table中的相应表项。在/arch/x86/kernel/syscall_table_32.s文件中添加系统调用号和调用函数的对应关系
· 接着就是my_syscall的实现了，在这里有两种方法：第一种方法是在kernel下自己新建一个目录添加自己的文件，但是要编写Makefile，而且要修改全局的Makefile。第二种比较简便的方法是，在kernel/sys.c中添加自己的服务函数，这样子不用修改Makefile.
以上准备工作做完之后，然后就要进行编译内核了，以下是编译内核的一个过程
1. make menuconfig (使用图形化的工具，更新.config文件)
2. make -j3 bzImage（编译，-j3指的是同时使用3个cpu来编译，bzImage指的是更新grub，以便重新引导）
3. make modules（对模块进行编译）
4. make modules_install（安装编译好的模块）
5. depmod（进行依赖关系的处理）
6. reboot （重启看到自己编译好的内核）
1.1.2内核模块法
内核模块可以作为独立程序来编译的函数和数据类型的集合。之所以提供模块机制，是因为Linux本身是一个单内核。单内核由于所有内容都集成在一起，效率很高，但可扩展性和可维护性相对较差，模块机制可以弥补这一缺陷。
Linux模块可以通过静态或动态的方法加载到内核空间，静态加载是指在内核启动过程中加载；动态加载是指在内核运行的过程中随时加载。
一个模块被加载到内核中时，就成为内核代码的一部分。模块加载入系统时，系统修改内核中的符号表，将新加载的模块提供的资源和符号添加到内核符号表中，以便模块间通信。
这种方法是采用系统调用拦截的一种方式，改变某一个系统调用号对应的服务程序为我们自己的编写的程序，从而相当于添加了我们自己的系统调用。
下面的内容，会详述用内核模块法实现目标的过程。
1.2 程序的主要设计思路
程序分三部分，一部分是通过内核模块实现添加系统调用，二是编写系统调用指定自己的系统调用，最后是编写用户态的测试程序。
1.3 环境
Ubuntu14.04 + 3.13.0内核版本
内核版本：

二.程序的模块划分，及对每个模块的说明
2.1 通过内核模块实现添加系统调用
这种方法其实是系统调用拦截的实现。系统调用服务程序的地址是放在sys_call_table中通过系统调用号定位到具体的系统调用地址，那么我们通过编写内核模块来修改sys_call_table中的系统调用的地址为我们自己定义的函数的地址，就可以实现系统调用的拦截。
通过模块加载时，将系统调用表里面的那个系统调用号的那个系统调用号对应的系统调用服务例程改为我们自己实现的系统历程函数地址。
2.1.1修改系统调用的模块
在/usr/include/i386-linux-gnu/asm/unistd_32.h文件中查看系统调用序号：

找到结果（部分截图）：

可以看到，222号和223号系统调用是空的，因此选取223作为新的系统调用号。
2.1.2获取sys_call_table的地址
在/boot/System.map-3.16.0-30-generic查看系统调用表的内存地址：

找到结果：

为0xc165e140
2.1.3清除内存区域的写保护
得到了sys_call_table的地址，该符号对应的内存区域是只读的。所以我们要修改它，必须对它进行清除写保护，这里介绍两种方法：
第一种方法：我们知道控制寄存器cr0的第16位是写保护位。cr0的第16位置为了禁止超级权限，若清零了则允许超级权限往内核中写入数据，这样我们可以再写入之前，将那一位清零，使我们可以写入。然后写完后，又将那一位复原就行了。
//使cr0寄存器的第17位设置为0（即是内核空间可写）
unsigned int clear_and_return_cr0(void)
{
unsigned int cr0 = 0;
unsigned int ret;
asm("movl %%cr0, %%eax":"=a"(cr0));
//将cr0寄存器的值移动到eax寄存器中，同时输出到cr0变量中
ret = cr0;
cr0 &= 0xfffeffff;//将cr0变量的第17位清0
asm("movl %%eax, %%cr0"::"a"(cr0));
//将cr0变量的值放入寄存器eax中，并且放入cr0寄存器中
return ret;
}

//读取val的值到eax寄存器，再将eax寄存器的值放入cr0寄存器中---改变内核地址空间参数
void setback_cr0(unsigned int val)
{
asm volatile("movl %%eax, %%cr0"::"a"(val));
}

第二种方法：通过设置虚拟地址对应的也表项的读写属性来设置。
int make_rw(unsigned long address)
{
unsigned int level;
pte_t *pte = lookup_address(address, &level);//查找虚拟地址所在的页表地址
if (pte->pte & ~_PAGE_RW) //设置页表读写属性
pte->pte |= _PAGE_RW;
return 0;
}

int make_ro(unsigned long address)
{
unsigned int level;
pte_t *pte = lookup_address(address, &level);
pte->pte &= ~_PAGE_RW; //设置只读属性
return 0;
}
2.2 编写系统调用指定自己的系统调用
2.2.1内核的初始化函数
此函数内采用的是2.1.3中的第一种方法。
static int __init init_addsyscall(void)
{
printk("hello,yinyu kernel\n");
//获取系统调用服务首地址
sys_call_table = (unsigned long *)sys_call_table_address;
printk("%x\n",sys_call_table);
//保存系统调用表中的NUM位置上的系统调用
anything_saved = (int(*)(void)) (sys_call_table[my_syscall_num]);
//使内核地址空间可写
orig_cr0 = clear_and_return_cr0();
//用自己的系统调用替换NUM位置上的系统调用
sys_call_table[my_syscall_num]= (unsigned long)&sys_mycall;
//使内核地址空间不可写
setback_cr0(orig_cr0);
return 0;
}

2.2.2自己的系统调用服务例程
部分一：创建进程树
void processtree(struct task_struct * p,int b);
结果需要以树状形式展示所有进程的父子关系。为此，我们定义processtree()递归函数来访问遍历，并且将结果存储在数组中，以便提供给用户态访问。
void processtree(struct task_struct * p,int b)//创建进程树（进程，深度）
{
struct list_head * l;
a[counter].pid = p -> pid;
a[counter].depth = b;
counter ++;
for(l = p -> children.next; l != &(p->children); l = l->next)
{
struct task_struct *t = list_entry(l,struct task_struct,sibling);
processtree(t,b+1);
}
}
其中，特别使用了宏：
#define list_entry(ptr, type, member) / ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
ptr是指向list_head类型链表的指针；
type为一个结构；
member为结构type中的一个域，类型为list_head；
这个宏返回指向type结构的指针。
目的：从一个结构的成员指针找到其容器的指针
部分二：创建自己的系统调用服务
asmlinkage long sys_mycall(char __user * buf);
在sys_mycall()中，从当前进程开始，递归调用processtree()函数，将进程信息存储在数组中。然后利用copy_to_user函数将内核信息传递给用户态下，用户态下的测试程序对结果进行展示。
asmlinkage long sys_mycall(char __user * buf)
{
int b = 0;
struct task_struct * p;
printk("This is yinyu_syscall!\n");
for(p = current; p != &init_task; p = p->parent );
processtree(p,b);
if(copy_to_user((struct process *)buf,a,512*sizeof(struct process)))
return -EFAULT;
else
return sizeof(a);
}

2.2.3移除内核模块时，将原有的系统调用进行还原
static void __exit exit_addsyscall(void)
{
//设置cr0中对sys_call_table的更改权限。
orig_cr0 = clear_and_return_cr0();
//恢复原有的中断向量表中的函数指针的值。
sys_call_table[my_syscall_num]= (unsigned long)anything_saved;
//恢复原有的cr0的值
setback_cr0(orig_cr0);
printk("call yinyu exit \n");
}
2.2.4模块注册相关
l 模块构造函数
module_init(init_addsyscall);
执行insmod或modprobe指令加载内核模块时会调用的初始化函数。函数原型必须是module_init()，内是函数指针
l 模块析构函数
module_exit(exit_addsyscall);
执行rmmod指令卸载模块时调用的函数。函数原型是module_exit();
l 模块许可声明
MODULE_LICENSE("GPL");
函数原型是MODULE_LICENSE()，告诉内核程序使用的许可证，不然在加载时它会提示该模块污染内核。一般会写GPL。
2.3 编写用户态的测试程序
#include
#include //asmlinkage
#include
#include
struct process
{

int pid;
int depth;
};
struct process a[512];
int main()
{
int i,j;
//在内核中将223本来对应的系统调用，临时链到我们自定义的sys_mycall()中。通过该系统调用后获得数组a
printf("the result is:%d\n",syscall(223,&a));
for(i = 0; i < 512; i++)
{
for(j = 0; j < a[i].depth; j++)
printf("|-");
printf("%d\n",a[i].pid);
if(a[i+1].pid == 0)
break;
}
return 0;
}
2.4 编写Makefile文件
KVERS = $(shell uname -r)

# Kernel modules
obj-m += hello.o

# Specify flags for the module compilation.
#EXTRA_CFLAGS=-g -O0

build: kernel_modules user_test
kernel_modules:
make -C /lib/modules/$(KVERS)/build M=$(CURDIR) modules

user_test:
gcc -o hello_test hello_test.c

clean:
make -C /lib/modules/$(KVERS)/build M=$(CURDIR) clean

三.所遇到的问题及解决的方法
3.1 进程个数确定
系统可运行的最大进程数，通过ulimit –u 查看有7863个

我们通过ps –ef|wc –l命令实际查看当前运行进程数量为191个

存储进程信息的数组大小为512是够用的。
3.2 被更改的系统调用号的选择
见2.1.1。
3.3 获取系统调用表的地址
见2.1.2。
3.4 内核和用户态数据交换
我们在内核模块程序中，将进程遍历信息存储在数组中，然后需要将其传递给用户态下。采用copy_from_user()和copy_to_user()这两个函数，这两个函数负责在用户空间和内核空间传递数据。因此我们在测试程序中，将空数组a的地址作为参数传递给内核模块程序，在内核中使用copy_to_user()函数将内核中的数组信息传递给用户态下的地址。

四.程序运行结果及使用说明
4.1 将编译出来的内核模块hello.ko加载到内核中
加载内核模块命令：
insmod hello.ko

4.2通过dmesg查看输出信息是否正确

4.3运行测试程序，输出树状打印结果（部分结果截图）

4.4卸载自定义模块
卸载内核模块命令：
insmod hello.ko

五.附录
5.1 内核模块程序hello.c
#include
#include
#include //list_head
#include

#include
#include //task_struct

#define my_syscall_num 223
#define sys_call_table_address 0xc165e140

static int counter = 0;

struct process
{
int pid;
int depth;
};

struct process a[512];

unsigned int clear_and_return_cr0(void);
void setback_cr0(unsigned int val);
asmlinkage long sys_mycall(char __user *buf);

int orig_cr0;
unsigned long *sys_call_table = 0;
static int (*anything_saved)(void);

void processtree(struct task_struct * p,int b)//创建进程树（进程，深度）
{
struct list_head * l;
a[counter].pid = p -> pid;
a[counter].depth = b;
counter ++;
for(l = p -> children.next; l != &(p->children); l = l->next)
{
struct task_struct *t = list_entry(l,struct task_struct,sibling);
processtree(t,b+1);
}
}

unsigned int clear_and_return_cr0(void)//使cr0寄存器的第17位设置为0（即是内核空间可写）
{
unsigned int cr0 = 0;
unsigned int ret;
asm("movl cr0, %%eax":"=a"(cr0));
//将cr0寄存器的值移动到eax寄存器中，同时输出到cr0变量中
ret = cr0;
cr0 &= 0xfffeffff;//将cr0变量的第17位清0
asm("movl %%eax, %%cr0"::"a"(cr0));
//将cr0变量的值放入寄存器eax中，并且放入cr0寄存器中
return ret;
}

void setback_cr0(unsigned int val)//读取val的值到eax寄存器，再将eax寄存器的值放入cr0寄存器中---改变内核地址空间参数
{
asm volatile("movl %%eax, %%cr0"::"a"(val));
}

static int __init init_addsyscall(void)//保存原来系统调用表中此地址中的系统调用
{
printk("hello,yinyu kernel\n");
sys_call_table = (unsigned long *)sys_call_table_address;//获取系统调用服务首地址
printk("%x\n",sys_call_table);
anything_saved = (int(*)(void)) (sys_call_table[my_syscall_num]);//保存系统调用表中的NUM位置上的系统调用
orig_cr0 = clear_and_return_cr0();//使内核地址空间可写
sys_call_table[my_syscall_num]= (unsigned long)&sys_mycall;//用自己的系统调用替换NUM位置上的系统调用
setback_cr0(orig_cr0);//使内核地址空间不可写
return 0;
}

asmlinkage long sys_mycall(char __user * buf)
{
int b = 0;
struct task_struct * p;
printk("This is yinyu_syscall!\n");
for(p = current; p != &init_task; p = p->parent );
processtree(p,b);
if(copy_to_user((struct process *)buf,a,512*sizeof(struct process)))//将内核空间内容复制到用户空间
return -EFAULT;
else
return sizeof(a);
}

static void __exit exit_addsyscall(void)
{
//设置cr0中对sys_call_table的更改权限。
orig_cr0 = clear_and_return_cr0();
//恢复原有的中断向量表中的函数指针的值。
sys_call_table[my_syscall_num]= (unsigned long)anything_saved;
//恢复原有的cr0的值
setback_cr0(orig_cr0);
printk("call yinyu exit \n");
}

//模块入口函数为init_addsyscall()，由module_init()宏指定，在模块被加载的时候被调用向系统注册。入口函数的返回值：0表示成功，非0表示失败。
module_init(init_addsyscall);

//模块的退出函数为exit_addsyscall()，由module_exit()宏指定，在模块被卸载时被调用向系统注销，主要来完成资源的清理工作
module_exit(exit_addsyscall);

//̨MODULE_LICENSE(“GPL”)表示设置模块遵守GPL证书，取消警告信息。
MODULE_LICENSE("GPL");
52 测试程序hello_test.c
#include
#include //asmlinkage
#include
#include
struct process
{
int pid;
int depth;
};
struct process a[512];
int main()
{
int i,j;
//在内核中将223本来对应的系统调用，临时链到我们自定义的sys_mycall()中。通过该系统调用后获得数组a
printf("the result is:%d\n",syscall(223,&a));
for(i = 0; i < 512; i++)
{
for(j = 0; j < a[i].depth; j++)
printf("|-");
printf("%d\n",a[i].pid);
if(a[i+1].pid == 0)
break;
}
return 0;
}
5.3 Makefile文件
KVERS = $(shell uname -r)

# Kernel modules
objm += hello.o

# Specify flags for the module compilation.
#EXTRA_CFLAGS=-g -O0

build: kernel_modules user_test

kernel_modules:
make -C /lib/modules/$(KVERS)/build M=$(CURDIR) modules
user_test:
gcc -o hello_test hello_test.c

clean:
make -C /lib/modules/$(KVERS)/build M=$(CURDIR) clean

15