ARM-Linux系统调用(http://my.oschina.net/raybin/blog/100379)

旧式x86平台上的系统调用由int 0x80中断实现，后来对于新式CPU，Linux使用了 sysenter方式。
    在ARM平台上，使用了swi中断来实现系统调用的跳转。
    swi指令用于产生软件中断，从而实现从用户模式变换到管理模式，CPSR（Current Program Status Register，程序状态寄存器，包含了条件标志位、中断禁止位、当前处理器模式标志以及其他的一些控制和状态位）保存到管理模式的SPSR（Saved Program Status Register，程序状态保存寄存器，用于保存CPSR的状态，以便异常返回后恢复异常发生时的工作状态），执行转移到SWI向量，在其他模式下也可使用SWI指令，处理器同样地切换到管理模式。
    指令格式如下：
    SWI {cond}  immed_24
    其中：
     immed_24  24位立即数，值为从0——16777215之间的整数。
使用SWI指令时，通常使用一下两种方法进行参数传递，SWI异常处理程序可以提供相关的服务，这两种方法均是用户软件协定。SWI异常中断处理程序要通过读取引起软件中断的SWI指令，以取得24为立即数。
    1）指令中24位的立即数指定了用户请求的服务类型，参数通过通用寄存器传递。如：
    MOV R0,#34
    SWI 12 
    2）指令中的24位立即数被忽略，用户请求的服务类型有寄存器R0的只决定，参数通过其他的通用寄存器传递。如：
    MOV R0, #12
    MOV R1, #34
    SWI 0
    在SWI异常处理程序中，去除SWI立即数的步骤为：首先确定一起软中断的SWI指令时ARM指令还是Thumb指令，这可通过对SPSR访问得到；然后取得该SWI指令的地址，这可通过访问LR寄存器得到；接着读出指令，分解出立即数（低24位）。
    在arch/arm/include/asm 目录下unistd.h文件中，在Linux内核中，每个系统调用都具有唯一的一个系统调用功能号，这些功能号的定义就在此文件中，在这文件可以看到很多类似这样的定义：
    #define __NR_write (__NR_SYSCALL_BASE+  4)
    这是系统调用write的定义，功能号是__NR_SYSCALL_BASE +4，定义为符号__NR_write。
    由于采用了不同的二进制接口，所以 __NR_SYSCALL_BASE +4的定义会有所不同，在文件中可以找到定义：

01 #ifndef __ASM_ARM_UNISTD_H
02 #define __ASM_ARM_UNISTD_H
03
04 #define __NR_OABI_SYSCALL_BASE  0x900000
05
06 #if defined(__thumb__) || defined(__ARM_EABI__)
07 #define __NR_SYSCALL_BASE   0
08 #else
09 #define __NR_SYSCALL_BASE   __NR_OABI_SYSCALL_BASE
10 #endif

   注意那个EABI， EABI是什么东西呢？ABI，Application Binary Interface，应用二进制接口。在较新的EABI规范中，是将系统调用号压入寄存器r7中，而在老的OABI中则是执行的swi 中断号的方式，也就是说原来的调用方式(Old ABI)是通过跟随在swi指令中的调用号来进行的。
    这里主要是对调用号的索取定义了不同的方式。
    而这些系统调用号所对应的系统调用列表，定义在arch/arm/kernel目录下的calls.S。

01 /* 0 */ CALL(sys_restart_syscall)
02         CALL(sys_exit)
03         CALL(sys_fork_wrapper)
04         CALL(sys_read)
05         CALL(sys_write)
06 /* 5 */ CALL(sys_open)
07         CALL(sys_close)
08         CALL(sys_ni_syscall)        /* was sys_waitpid */
09         CALL(sys_creat)
10         CALL(sys_link)
11 /*………省略……….*/

   在源码中，我们可以找到诸如sys_write的函数声明：
    asmlinkage long sys_write (unsigned int fd, const char __user *buf,size_t count);
    asmlinkage是gcc标签，表明函数读取传递而来的参数位于栈中，具体的作用可以参考链接： http://blog.chinaunix.net/uid-20585891-id-1919646.html
    但具体的实现代码则用宏来定义。
    Linux已经为每一个系统调用都设定了唯一的一个系统调用功能号，当执行系统调用时，会按照系统调用号来索引系统调用，用的是几个带参数的宏来实现，位于syscalls.h文件中，可以看到：

1 #define SYSCALL_DEFINE0(name)      asmlinkage long sys_##name(void)
2 #define SYSCALL_DEFINE1(name, ...) SYSCALL_DEFINEx(1, _##name, __VA_ARGS__)
3 #define SYSCALL_DEFINE2(name, ...) SYSCALL_DEFINEx(2, _##name, __VA_ARGS__)
4 #define SYSCALL_DEFINE3(name, ...) SYSCALL_DEFINEx(3, _##name, __VA_ARGS__)
5 #define SYSCALL_DEFINE4(name, ...) SYSCALL_DEFINEx(4, _##name, __VA_ARGS__)
6 #define SYSCALL_DEFINE5(name, ...) SYSCALL_DEFINEx(5, _##name, __VA_ARGS__)
7 #define SYSCALL_DEFINE6(name, ...) SYSCALL_DEFINEx(6, _##name, __VA_ARGS__)

    这里DEFINEn表示的是参数的个数，有参数的系统调用最终都是指向这么一个宏：

1 #define SYSCALL_DEFINEx(x, sname, ...)  __SYSCALL_DEFINEx(x, sname, __VA_ARGS__)

    翻看__SYSCALL_DEFINEx的定义：

1 #define __SYSCALL_DEFINEx(x, name, ...)                 \
2     asmlinkage long sys##name(__SC_DECL##x(__VA_ARGS__))

    翻查代码，可以找到：

1 SYSCALL_DEFINE3(write, unsigned int, fd, const char __user *, buf,
2         size_t, count)

    展开此宏，便可以得到“ asmlinkage long sys_write (unsigned int fd, const char __user *buf,size_t count);”的声明形式。
    PS：~~不明白为何要使用这样的形式来说明定义，不明意图郁闷ing~~
    PS：__SC_DECLX的宏定义如下(/include/linux/syscalls.h)，__VA_ARGS__是个可变参数宏：

1 #define __SC_DECL1(t1, a1)  t1 a1
2 #define __SC_DECL2(t2, a2, ...) t2 a2, __SC_DECL1(__VA_ARGS__)
3 #define __SC_DECL3(t3, a3, ...) t3 a3, __SC_DECL2(__VA_ARGS__)
4 #define __SC_DECL4(t4, a4, ...) t4 a4, __SC_DECL3(__VA_ARGS__)
5 #define __SC_DECL5(t5, a5, ...) t5 a5, __SC_DECL4(__VA_ARGS__)
6 #define __SC_DECL6(t6, a6, ...) t6 a6, __SC_DECL5(__VA_ARGS__)

    那么系统是如何找到该函数的。
    前面提交到系统调用号，这是一个偏移量，来匹配系统调用表的各项入口，在calls.S文件中有对各项入口的声明，而对于系统调用表的定义，在文件arch/arm/kernel/entry-armv.S中。

01 /*
02  * This is the syscall table declaration for native ABI syscalls.
03  * With EABI a couple syscalls are obsolete and defined as sys_ni_syscall.
04  */
05 #define ABI(native, compat) native
06 #ifdef CONFIG_AEABI
07 #define OBSOLETE(syscall) sys_ni_syscall
08 #else
09 #define OBSOLETE(syscall) syscall
10 #endif
11
12     .type   sys_call_table, #object
13 ENTRY(sys_call_table)
14 #include "calls.S"
15 #undef ABI
16 #undef OBSOLETE

    还有

01 /*
02  * Let's declare a second syscall table for old ABI binaries
03  * using the compatibility syscall entries.
04  */
05 #define ABI(native, compat) compat
06 #define OBSOLETE(syscall) syscall
07
08     .type   sys_oabi_call_table, #object
09 ENTRY(sys_oabi_call_table)
10 #include "calls.S"
11 #undef ABI
12 #undef OBSOLETE

    sys_call_table 在内核中是个跳转表，这个表中存储的是一系列的函数指针，这些指针就是系统调用函数的指针，如(sys_open)。内核是根据一个系统调用号（对于EABI来说为系统调用表的索引）找到实际该调用内核哪个函数，然后通过运行该函数完成系统调用的。
    对于old ABI，内核给出的处理是为它建立一个单独的system call table,叫sys_oabi_call_table。这样，兼容方式下就会有两个system call table, 以old ABI方式的系统调用会执行old_syscall_table表中的系统调用函数，EABI方式的系统调用会用sys_call_table中的函数指针。
    配置无外乎以下4中： 
    第一、两个宏都配置行为就是上面说的那样。 
    第二、只配置CONFIG_OABI_COMPAT，那么以oldABI方式调用的会用sys_oabi_call_table，以EABI方式调用的用sys_call_table，和1实质上是相同的。只是情况1更加明确。
    第三、只配置CONFIG_AEABI系统中不存在sys_oabi_call_table，对old ABI方式调用不兼容。只能 以EABI方式调用，用sys_call_table。
    第四、两个都没有配置，系统默认会只允许old ABI方式，但是不存在old_syscall_table，最终会通过sys_call_table 完成函数调用。

    系统会根据ABI的不同而将相应的系统调用表的基地址加载进tbl寄存器。
    接下来查找的过程。
    ARM-Linux内核启动时，通过start_kernel(/init/main.c)->setup_arch(/arch/arm/kernel/setup.c)->paging_init(/arch/arm/mm/nommu.c)->early_trap_init(/arch/arm/kernel/traps.c)，初始化中断异常向量表：

01 void __init early_trap_init(void *vectors_base)
02 {
03     unsigned long vectors = (unsigned long)vectors_base;
04     extern char __stubs_start[], __stubs_end[];
05     extern char __vectors_start[], __vectors_end[];
06     extern char __kuser_helper_start[], __kuser_helper_end[];
07     int kuser_sz = __kuser_helper_end - __kuser_helper_start;
08
09     vectors_page = vectors_base;
10
11     /*
12      * Copy the vectors, stubs and kuser helpers (in entry-armv.S)
13      * into the vector page, mapped at 0xffff0000, and ensure these
14      * are visible to the instruction stream.
15      */
16     memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);
17     memcpy((void *)vectors + 0x200, __stubs_start, __stubs_end - __stubs_start);
18     memcpy((void *)vectors + 0x1000 - kuser_sz, __kuser_helper_start, kuser_sz);
19
20     /*
21      * Do processor specific fixups for the kuser helpers
22      */
23     kuser_get_tls_init(vectors);
24
25     /*
26      * Copy signal return handlers into the vector page, and
27      * set sigreturn to be a pointer to these.
28      */
29     memcpy((void *)(vectors + KERN_SIGRETURN_CODE - CONFIG_VECTORS_BASE),
30            sigreturn_codes, sizeof(sigreturn_codes));
31     memcpy((void *)(vectors + KERN_RESTART_CODE - CONFIG_VECTORS_BASE),
32            syscall_restart_code, sizeof(syscall_restart_code));
33
34     flush_icache_range(vectors, vectors + PAGE_SIZE);
35     modify_domain(DOMAIN_USER, DOMAIN_CLIENT);
36 }

    paging_init函数中调用传递的参数是：early_trap_init((void *)CONFIG_VECTORS_BASE);
    early_trap_init主要完成将中断向量表（__vectors_start, __vectors_end）和中断入口函数表（__stubs_start, __stubs_end）的相关代码copy到内存0xffff0000或者0x00000000处。
    这个函数把定义在 arch/arm/kernel/entry-armv.S 中的异常向量表和异常处理程序的 stub 进行
重定位：异常向量表拷贝到 0xFFFF_0000，异常向量处理程序的 stub 拷贝到 0xFFFF_0200。
然后调用 modify_domain()修改了异常向量表所占据的页面的访问权限，这使得用户态无法
访问该页，只有核心态才可以访问。
    异常向量表，在文件arch/arm/kernel/entry-armv.S 中 ：
   

01 __vectors_start:
02  ARM(  swi SYS_ERROR0  )
03  THUMB(    svc #0      )
04  THUMB(    nop         )
05  W(b)   vector_und + stubs_offset
06  W(ldr) pc, .LCvswi + stubs_offset
07  W(b)   vector_pabt + stubs_offset
08  W(b)   vector_dabt + stubs_offset
09  W(b)   vector_addrexcptn + stubs_offset
10  W(b)   vector_irq + stubs_offset
11  W(b)   vector_fiq + stubs_offset
12  .globl __vectors_end
13 __vectors_end:

   填充后，向量表如下：
    
   虚拟地址        异常              处理代码
    0xffff0000      reset              swi SYS_ERROR0
    0xffff0004      undefined        b __real_stubs_start + (vector_undefinstr - __stubs_start)
    0xffff0008      软件中断          ldr pc, __real_stubs_start + (.LCvswi - __stubs_start)
    0xffff000c      取指令异常       b __real_stubs_start + (vector_prefetch - __stubs_start)
    0xffff0010      数据异常          b __real_stubs_start + (vector_data - __stubs_start)
    0xffff0014      reserved         b __real_stubs_start + (vector_addrexcptn - __stubs_start)
    0xffff0018      irq                 b __real_stubs_start + (vector_IRQ - __stubs_start)
    0xffff001c      fiq                  b __real_stubs_start + (vector_FIQ - __stubs_start)

    发生软中断swi时，会跳到.LCvswi + stubs_offset处执行， LCvswi定义如下：

1 .LCvswi:
2     .word   vector_swi

    最终会执行例程vector_swi来完成对系统调用的处理，翻看/arch/arm/kernel/entry-common.S下vector_swi的定义。

001 ENTRY(vector_swi)
002     sub sp, sp, #S_FRAME_SIZE
003     stmia   sp, {r0 - r12}          @ Calling r0 - r12
004  ARM(   add r8, sp, #S_PC       )
005  ARM(   stmdb   r8, {sp, lr}^       )   @ Calling sp, lr
006  THUMB( mov r8, sp          )
007  THUMB( store_user_sp_lr r8, r10, S_SP  )   @ calling sp, lr
008     mrs r8, spsr            @ called from non-FIQ mode, so ok.
009     str lr, [sp, #S_PC]         @ Save calling PC
010     str r8, [sp, #S_PSR]        @ Save CPSR
011     str r0, [sp, #S_OLD_R0]     @ Save OLD_R0
012     zero_fp
013
014     /*
015      * Get the system call number.
016      */
017
018 #if defined(CONFIG_OABI_COMPAT)
019     /*
020      * If we have CONFIG_OABI_COMPAT then we need to look at the swi
021      * value to determine if it is an EABI or an old ABI call.
022      */
023 #ifdef CONFIG_ARM_THUMB
024     tst r8, #PSR_T_BIT
025     movne   r10, #0             @ no thumb OABI emulation
026     ldreq   r10, [lr, #-4]          @ get SWI instruction
027 #else
028     ldr r10, [lr, #-4]          @ get SWI instruction
029   A710( and ip, r10, #0x0f000000        @ check for SWI     )
030   A710( teq ip, #0x0f000000                     )
031   A710( bne .Larm710bug                     )
032 #endif //endif "CONFIG_ARM_THUMB<span></span>"
033
034 #ifdef CONFIG_CPU_ENDIAN_BE8
035     rev r10, r10            @ little endian instruction
036 #endif //endif "CONFIG_CPU_ENDIAN_BE8"
037
038 #elif defined(CONFIG_AEABI)
039
040     /*
041      * Pure EABI user space always put syscall number into scno (r7).
042      */
043   A710( ldr ip, [lr, #-4]           @ get SWI instruction   )
044   A710( and ip, ip, #0x0f000000     @ check for SWI     )
045   A710( teq ip, #0x0f000000                     )
046   A710( bne .Larm710bug                     )
047
048 #elif defined(CONFIG_ARM_THUMB)
049
050     /* Legacy ABI only, possibly thumb mode. */
051     tst r8, #PSR_T_BIT          @ this is SPSR from save_user_regs
052     addne   scno, r7, #__NR_SYSCALL_BASE    @ put OS number in
053     ldreq   scno, [lr, #-4]
054
055 #else
056
057     /* Legacy ABI only. */
058     ldr scno, [lr, #-4]         @ get SWI instruction
059   A710( and ip, scno, #0x0f000000       @ check for SWI     )
060   A710( teq ip, #0x0f000000                     )
061   A710( bne .Larm710bug                     )
062
063 #endif //endif "CONFIG_OABI_COMPAT"
064
065 #ifdef CONFIG_ALIGNMENT_TRAP
066     ldr ip, __cr_alignment
067     ldr ip, [ip]
068     mcr p15, 0, ip, c1, c0      @ update control register
069 #endif
070     enable_irq
071
072     get_thread_info tsk
073         //tbl是r8寄存器的别名，在arch/arm/kernel/entry-header.S中定义：
074         // tbl  .req   r8     @syscall table pointer，
075         // 用来存放系统调用表的指针，系统调用表在后面调用
076         adr tbl, sys_call_table     @ load syscall table pointer
077
078 #if defined(CONFIG_OABI_COMP<span></span>AT)
079     /*
080      * If the swi argument is zero, this is an EABI call and we do nothing.
081      *
082      * If this is an old ABI call, get the syscall number into scno and
083      * get the old ABI syscall table address.
084      */
085     bics    r10, r10, #0xff000000
086     eorne   scno, r10, #__NR_OABI_SYSCALL_BASE
087     ldrne   tbl, =sys_oabi_call_table
088 #elif !defined(CONFIG_AEABI)
089         // scno是寄存器r7的别名
090     bic scno, scno, #0xff000000     @ mask off SWI op-code
091     eor scno, scno, #__NR_SYSCALL_BASE  @ check OS number
092 #endif
093
094     ldr r10, [tsk, #TI_FLAGS]       @ check for syscall tracing
095     stmdb   sp!, {r4, r5}           @ push fifth and sixth args
096
097 #ifdef CONFIG_SECCOMP
098     tst r10, #_TIF_SECCOMP
099     beq 1f
100     mov r0, scno
101     bl  __secure_computing
102     add r0, sp, #S_R0 + S_OFF       @ pointer to regs
103     ldmia   r0, {r0 - r3}           @ have to reload r0 - r3
104 1:
105 #endif
106
107     tst r10, #_TIF_SYSCALL_WORK     @ are we tracing syscalls?
108     bne __sys_trace
109
110     cmp scno, #NR_syscalls      @ check upper syscall limit
111     adr lr, BSYM(ret_fast_syscall)  @ return address
112         //转入到实现函数
113     ldrcc   pc, [tbl, scno, lsl #2]     @ call sys_* routine
114
115     add r1, sp, #S_OFF
116         // why是r8寄存器的别名
117 2:  mov why, #0             @ no longer a real syscall
118     cmp scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE)
119     eor r0, scno, #__NR_SYSCALL_BASE    @ put OS number back
120     bcs arm_syscall
121     b   sys_ni_syscall          @ not private func
122 ENDPROC(vector_swi)

    然后转入到函数入口，执行系统调用。

参考总结于：http://blog.csdn.net/xiyangfan/article/details/5701673

http://blog.csdn.net/hongjiujing/article/details/6831192

http://blog.chinaunix.net/uid-26316047-id-3402198.html