1. 概念

1.1 ABI与API

问题：保持一个稳定的 ABI 和保持一个稳定的 API相比，谁更困难，为什么？
ABI: ABI是一系列约定的集合，可以说调用惯例(calling convention)就是ABI。因此， ABI是和具体CPU架构和OS相关
的。具体而言， ABI包含以下内容：
1. 一个特定的处理器指令集
2. 函数调用惯例
3. 系统调用方式
4. 可执行文件的格式(ELF,PE)
API: 应用程序调用接口，比如Linux API是Linux内核与用户空间的API，也就是让用户空间的
程序能够通过这个接口访问系统资源和内核提供的服务。 LinuxAPI由两部分组成： Linux内核的系统调用接口和GNU C库（glibc
）中的例程。
因此，ABI更困难，因为API只自定义函数接口，如POSIX 标准，不限制不同系统对其的具体实现；但ABI去限定底层实现框架，过于严格。

1.2 系统调用与中断，异常比较

机制	源头	处理机制不同	服务响应方式不同
系统调用	应用程序请求OS提供	用户发出请求后等待OS的服务	异步/同步
中断	是外设发出的请求	内核态下运行，对用户是透明的	异步的
异常	是应用程序意想不到的行为	或者杀死进程，或者重新执行引起异常的指令	同步的

1.3 调用流程

在这里插入图片描述
以fork()调用为例讲解

从用户程序中调用fork
在libc库中把fork对应的系统调用号2放入寄存器eax
通过int 0x80陷入内核(存在优化)
在中断描述表IDT中查到系统调用的入口0x80 （存在优化）

#define SYSCALL_VECTOR		0x80
// IDT的初始化在 \arch\i386\kernel\traps.c
void __init trap_init(void)
{
    
    
	set_system_gate(SYSCALL_VECTOR,&system_call); // system_call 本质是一个汇编地址
}

进入Linux内核的entry_32(64).S文件，从系统调用表sys_call_table中找到sys_fork的入口地址

	# system call handler stub
ENTRY(system_call)
	pushl %eax			# save orig_eax
	SAVE_ALL
	GET_THREAD_INFO(%ebp)
	cmpl $(nr_syscalls), %eax
	jae syscall_badsys
					# system call tracing in operation
	testb $_TIF_SYSCALL_TRACE,TI_FLAGS(%ebp)
	jnz syscall_trace_entry
syscall_call:
	call *sys_call_table(,%eax,4)
	movl %eax,EAX(%esp)		# store the return value

执行fork.c中的do_fork代码
通过iret或者sysiret返回

syscall_exit:
	cli				# make sure we don't miss an interrupt
					# setting need_resched or sigpending
					# between sampling and the iret
	movl TI_FLAGS(%ebp), %ecx
	testw $_TIF_ALLWORK_MASK, %cx	# current->work
	jne syscall_exit_work
restore_all:
	// 里面有iret命令, 返回用户空间
	RESTORE_ALL

1.4 调用流程优化

在这里插入图片描述
因为系统调用的实现从用户态切换到内核态，执行完系统调用程序后又从内核态切换回用户态,代价很大，为了加
快系统调用的速度，随后先后引入了两种机制——vsycalls和vDSO 。
这两种机制都是从机制上对系统调用速度进行的优化，但是使用软中断来进行系统调用需要进行特权级的切换这一
根本问题没有解决。为了解决这一问题， Intel x86 CPU从Pentium II之后，开始支持快速系统调用指令
sysenter/sysexit，这两条指令是Intel在32位下提出的，而AMD提出syscall/sysret， 64位统一使用这两条指令了。

2 实例-日志收集系统

功能：系统调用被my_audit拦截后，记录到内核的buffer中（这是一个内核模块），测试用程序通过自己实现的系统调用my_sysaudit获取buffer;
思路：

因为需要增加系统调用获取内核中的buffer，因此需要修改内核，增加一个系统调用号；
在系统调用模块处需要记录到内核；
通过增加的系统调用获取内核中的数据；

2.1 内核编译

进入vim arch/x86/entry/syscalls/syscall_64.tbl 添加中断号

334 common  rseq            __x64_sys_rseq
335 common  myaudit         __x64_sys_myaudit

添加系统调用函数：在内核目录添加 vim arch/x86/kernel/myaudit.c

#include <linux/uaccess.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/syscalls.h>
#include <linux/kernel.h>
#include <asm/current.h>


void (*my_audit) (int,int) = 0;

int(*my_sysaudit)(u8,u8*,u16,u8) = 0;
// SYSCALL_DEFINE4 定义了系统调用在内核的入口
SYSCALL_DEFINE4(myaudit,u8,type,u8 *,us_buf,u16,us_buf_size,u8,reset)
{
    
    
        if (my_audit){
    
    
                printk("IN KENEL:my system call sys_myaudit() working\n");
                return (*my_sysaudit)(type,us_buf,us_buf_size,reset);
        } else
                printk("my_audit is not exist\n");
        return 1;

}

// 声明两个钩子函数等待实现
EXPORT_SYMBOL(my_audit);
EXPORT_SYMBOL(my_sysaudit);

修改makefile文件把myaudit.c添加到内核中进行编译 vim arch/x86/kernel/Makefile

obj-y           := process_$(BITS).o signal.o
obj-y           += myaudit.o  # 添加的文件

增加函数声明：

long compat_ksys_semtimedop(int semid, struct sembuf __user *tsems,
                unsigned int nsops,
                const struct old_timespec32 __user *timeout);
// 添加函数声明 `vim include/linux/syscalls.h `
asmlinkage long sys_myaudit(u8, u8*, u16, u8);
extern void (*my_audit)(int, int);    

#endif

拦截相关的系统调用 vim arch/x86/entry/common.c

// do_syscall_64函数中增加拦截标记
299     if (likely(nr < NR_syscalls)) {
    
    
300         nr = array_index_nospec(nr, NR_syscalls);
301         regs->ax = sys_call_table[nr](regs);
302 
303         if (nr == 2 || nr == 3 || nr == 56 || nr == 57 || nr == 59) {
    
    
304             if (my_audit)
305                 (*my_audit)(nr, regs->ax);
306             else
307                 printk("my_audit is not exist");                                                                                                                                                                               
309         }
		}

编译内核, 装内核，修改内核引导

# 编译内核和模块
make image j2
make modules
make modules_install
make install
# 修改内核应道
update-grub2
reboot #重新系统

2.2 内核模块

在新的内核中安装myaudit内核模块

#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sched.h>
#include <linux/uaccess.h>

#define COMM_SIZE 16
#define AUDIT_BUF_SIZE 20

MODULE_LICENSE("GPL v2");

struct syscall_buf{
    
    
u32 serial;
u64 ts_sec;
u64 ts_micro;
u32 syscall;
u32 status;
pid_t pid;
uid_t uid;
u8 comm[COMM_SIZE];	
};

DECLARE_WAIT_QUEUE_HEAD(buffer_wait);

static struct  syscall_buf  audit_buf[AUDIT_BUF_SIZE];
static int current_pos = 0;
static u32 serial = 0;

//系统调用函数， 将数据拷贝到
void syscall_audit(int syscall,int return_status)
{
    
    	
	struct syscall_buf *ppb_temp;
	struct timespec64 nowtime;
	
	ktime_get_real_ts64(&nowtime);
	if(current_pos < AUDIT_BUF_SIZE){
    
    
		ppb_temp = &audit_buf[current_pos];
		ppb_temp->serial = serial++;
		ppb_temp->ts_sec = nowtime.tv_sec;
		ppb_temp->ts_micro = nowtime.tv_nsec;
		ppb_temp->syscall = syscall;
		ppb_temp->status = return_status;
		ppb_temp->pid = current->pid;
		ppb_temp->uid = current->tgid;
		
		memcpy(ppb_temp->comm, current->comm, COMM_SIZE);
		if(++current_pos == AUDIT_BUF_SIZE * 6/10)
		{
    
    
			printk("IN MODULE_AUDIT:yes,it near full\n");
			wake_up_interruptible(&buffer_wait);
		}
	}
	
}

int sys_audit(u8 type, u8 *us_buf, u16 us_buf_size, u8 reset)
{
    
    
	int ret = 0;
		if(!type){
    
    
			if(clear_user(us_buf,us_buf_size)){
    
    
				printk("Error:clear_user\n");
				return 0;
			}
			printk("IN MODULE_systemcall:starting...\n");
			ret = wait_event_interruptible(buffer_wait,	current_pos >= AUDIT_BUF_SIZE *6/10);
			printk("IN MODULE_systemcall:over,current_pos is %d\n", current_pos);
			
			if(copy_to_user(us_buf, audit_buf, (current_pos)*sizeof(struct syscall_buf))){
    
    
				printk("Error:copy error\n");
				return 0;
			}
			ret = current_pos;
			current_pos = 0;
		}
		return ret;		
}

extern void(*my_audit)(int,int);
extern int (*my_sysaudit)(u8,u8*,u16,u8);
static int __init audit_init(void)
{
    
    
	my_sysaudit = sys_audit;
	my_audit = syscall_audit;
	printk("Exiting System Call Auditing\n");
	return 0;
}

module_init(audit_init);

static void __exit audit_exit(void)
{
    
    
	my_audit = NULL;
	my_sysaudit = NULL;
	printk("Exiting System Calling Auditing\n");
	return;
}

module_exit(audit_exit);

2.3 测试内核模块

通过如下测试程序调用我们自己实现的系统调用sys_myaudit

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <time.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/types.h>

#define COMM_SIZE 16

typedef unsigned char u8;
typedef unsigned int u32;
typedef unsigned long long u64;

struct syscall_buf
{
    
    
    u32 serial;
    u64 ts_sec;
    u64 ts_micro;
    u32 syscall;
    u32 status;
    pid_t pid;
    uid_t uid;
    u8 comm[COMM_SIZE];
};

#define AUDIT_BUF_SIZE (20 * sizeof(struct syscall_buf))

int main(int argc, char *argv[])
{
    
    
    u8 col_buf[AUDIT_BUF_SIZE];
    unsigned char reset = 1;
    int num = 0;
    int i, j;
    struct syscall_buf *p;
    int max = 100;
    while (max-- > 0)
    {
    
    
    	// 调用335系统调用
        num = syscall(335, 0, col_buf, AUDIT_BUF_SIZE, reset);
        printf("num :%d\n", num);
        p = (struct syscall_buf *)col_buf;
        
        for (i = 0; i < num; i++)
        {
    
    
            printf("num[%d],serial:%d,\t syscall :%d,\t pid:%d,\t comm:%s,\t time:%s\n", i, p[i].serial, p[i].syscall, 		       p[i].pid, p[i].comm, ctime(&p[i].ts_sec));
        }
    }
    return 1;
}

linux内核7-系统调用

文章目录