系统调用的封装例程

Posted 2023-02-22 kaluotee



原文 http://blog.chinaunix.net/uid-27033491-id-3249801.html

1，什么是封装例程？
        系统调用是内核实现的，内核向用户态提供服务，内核向用户态提供系统调用的接口是一个软中断。
也就是int 0x80.如果用户直接调用系统调用会很麻烦。下面就举个直接调用系统调用的例子。用汇编实现的。

1. # hello.s ----> intel汇编的注释用的; 而ATT用的＃
2. # display a string "Hello, world."
3. 
   
4. .section .rodata
5. msg:
6. .ascii "Hello, world.\\n"
7. 
   
8. .section .text
9. .globl _start
10. _start:
11. 
    
12. movl $2, %eax #调用fork系统调用
13. int $0x80
14. 
    
15. 
    
16. movl $4, %eax # system call 系统调用号(sys_write)
17. movl $1, %ebx # file descriptor 参数一:文件描述符(stdout)
18. movl $msg, %ecx # string address 参数二:要显示的字符串
19. movl $14, %edx # string length 参数三:字符串长度
20. int $0x80 # 调用内核功能
21. 
    
22. movl $1, %eax # 系统调用号(sys_exit)
23. movl $0, %ebx # 参数一:退出代码
24. int $0x80 # 调用内核功能

这就需要对系统调用进行封装，便于用户调用，比如说fork()，getpid()，这些函数都是libc库中的函数
都对系统调用进行了封装。而且都是遵循POSIX标准的。
---------------------------------------------------------------------------------------------
2，什么是POSIX？
      POSIX是一套操作系统标准，它是随着UNIX标准化而诞生的。linux是遵循POSIX标准的操作系统，如果
linux遵循POSIX标准的话，UNIX上的应用程序就可以顺利移植到linux上来了。形象点说也就是linux和UNIX
很多函数名字及其参数都定义的是一样的。
---------------------------------------------------------------------------------------------
3，旧方式封装（淘汰了），__syscall0()  ~ __syscall6()
     这几个宏实际上是利用了系统调用参数的个数不能超个6个来进行分类的。为了内核的安全考虑。从内核2.6.18开始该宏就从头文件中删除了，其实完全也可以自己加入到 指定的头文件中去。该宏被syscall()取代了，syscall()是glibc中的函数。而上面的_syscall()宏是不依赖于库的。

1. #define __syscall_return(type, res) \\
2. do \\
3. if ((unsigned long)(res) >= (unsigned long)(-MAX_ERRNO)) \\
4. res = -1; \\
5. \\
6. return (type) (res); \\
7. while (0)
8. 
   
9. #define _syscall0(type,name) \\
10. type name(void) \\
11. \\
12. long __res; \\
13. __asm__ volatile ("int $0x80" \\
14. : "=a" (__res) \\
15. : "0" (__NR_##name)); \\
16. __syscall_return(type,__res); \\
18. 
    
19. #define _syscall1(type,name,type1,arg1) \\
20. type name(type1 arg1) \\
21. \\
22. long __res; \\
23. __asm__ volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx" \\
24. : "=a" (__res) \\
25. : "0" (__NR_##name),"ri" ((long)(arg1)) : "memory"); \\
26. __syscall_return(type,__res); \\
28. 
    
29. #define _syscall2(type,name,type1,arg1,type2,arg2) \\
30. type name(type1 arg1,type2 arg2) \\
31. \\
32. long __res; \\
33. __asm__ volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx" \\
34. : "=a" (__res) \\
35. : "0" (__NR_##name),"ri" ((long)(arg1)),"c" ((long)(arg2)) \\
36. : "memory"); \\
37. __syscall_return(type,__res); \\
39. 
    
40. #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \\
41. type name(type1 arg1,type2 arg2,type3 arg3) \\
42. \\
43. long __res; \\
44. __asm__ volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx" \\
45. : "=a" (__res) \\
46. : "0" (__NR_##name),"ri" ((long)(arg1)),"c" ((long)(arg2)), \\
47. "d" ((long)(arg3)) : "memory"); \\
48. __syscall_return(type,__res); \\
50. 
    
51. #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \\
52. type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \\
53. \\
54. long __res; \\
55. __asm__ volatile ("push %%ebx ; movl %2,%%ebx ; int $0x80 ; pop %%ebx" \\
56. : "=a" (__res) \\
57. : "0" (__NR_##name),"ri" ((long)(arg1)),"c" ((long)(arg2)), \\
58. "d" ((long)(arg3)),"S" ((long)(arg4)) : "memory"); \\
59. __syscall_return(type,__res); \\
61. 
    
62. #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \\
63. type5,arg5) \\
64. type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \\
65. \\
66. long __res; \\
67. __asm__ volatile ("push %%ebx ; movl %2,%%ebx ; movl %1,%%eax ; " \\
68. "int $0x80 ; pop %%ebx" \\
69. : "=a" (__res) \\
70. : "i" (__NR_##name),"ri" ((long)(arg1)),"c" ((long)(arg2)), \\
71. "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)) \\
72. : "memory"); \\
73. __syscall_return(type,__res); \\
75. 
    
76. #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \\
77. type5,arg5,type6,arg6) \\
78. type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \\
79. \\
80. long __res; \\
81. struct long __a1; long __a6; __s = (long)arg1, (long)arg6 ; \\
82. __asm__ volatile ("push %%ebp ; push %%ebx ; movl 4(%2),%%ebp ; " \\
83. "movl 0(%2),%%ebx ; movl %1,%%eax ; int $0x80 ; " \\
84. "pop %%ebx ; pop %%ebp" \\
85. : "=a" (__res) \\
86. : "i" (__NR_##name),"0" ((long)(&__s)),"c" ((long)(arg2)), \\
87. "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)) \\
88. : "memory"); \\
89. __syscall_return(type,__res); \\

---------------------------------------------------------------------------------------------
4，新方式封装。（现在的封装方式）
现在对系统调用的封装都是用的syscall函数，该函数是不定参数，很好用，可以调用所有的系统调用。

1.   1 #include <linux/unistd.h>
   
2.   2 #include <syscall.h>
   
3.   3 #include <sys/types.h>
   
4.   4 #include <stdio.h>
   
5.   6
   
6.   7
   
7.   8 int main(void)
   
8.   9
   
9.  10 long pid1;
   
10.  11 pid1 = syscall(SYS_getpid); //getpid
    
11.  12 printf("pid = %ld\\n",pid1);
    
12.  13 return 0;
    
13.  14

---------------------------------------------------------------------------------------------
5，问题：我自己添加了一个系统调用，想在用户态下测试下，代码如下：

1.   1 #include <linux/unistd.h>
   
2.   2 #include <syscall.h>
   
3.   3 #include <sys/types.h>
   
4.   4 #include <stdio.h>
   
5.   5
   
6.   6
   
7.   7 int main(void)
   
8.   8
   
9.   9 long n = 0;
   
10.  10 n = syscall(SYS_mysyscall,190);
    
11.  11 return 0;
    
12.  12

该程序会提示“SYS_mysyscall”没有定义。
解决办法：
1，/usr/include/bits/syscall.h文件中添加：#define SYS_mysyscall __NR_mysyscall
2，/usr/include/i386-linux-gnu/asm/unistd_32文件末尾添加：
      #define __NR_mysyscall          345
      这样，你添加的系统调用和系统本身自带的系统调用的用户态使用上就一模一样了。
---------------------------------------------------------------------------------------------