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    asmlinkagelong sys##name(__SC_DECL##x(__VA_ARGS__))

    翻查代码，可以找到：

1SYSCALL_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

13ENTRY(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

09ENTRY(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)，初始化中断异常向量表：

01void __init early_trap_init(void*vectors_base)

02{

03    unsigned long vectors = (unsigned long)vectors_base;

04    externchar __stubs_start[], __stubs_end[];

05    externchar __vectors_start[], __vectors_end[];

06    externchar __kuser_helper_start[], __kuser_helper_end[];

07    intkuser_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的定义。

001ENTRY(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        @ checkfor 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     @ checkfor 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       @ checkfor 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 controlregister

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]       @ checkfor 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

1041:

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寄存器的别名

1172:  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          @ notprivate func

122ENDPROC(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