freebsd9.2-系统调用机制-实现

71v5

假设：
1：当前正在运行的进程为p1，其对应的struct proc对象简记为p1_proc，相关联的线程为th1，其对应的struct thread对象简记为th1_thread。

2：cpu已经完成了调用系统调用异常处理程序前的硬件处理，此时将开始执行系统调用异常处理程序。

3：执行的是rfork系统调用，系统调用号为251，十六进制为0xfb；该系统调用只有一个参数flags，这样可以看一下参数是如何传递的。

4：p1_proc的p_sysent成员指向elf32_freebsd_sysvec对象。

先来一张线程th1_thread内核栈和用户栈的结构图，下面的分析结合图会更清楚：



[函数IDTVEC(int0x80_syscall)]-系统调用异常处理程序：

1. /***********************************************************************************************
   
2. * Trap gate entry for syscalls (int 0x80).
   
3. * This is used by FreeBSD ELF executables, "new" NetBSD executables, and all
   
4. * Linux executables.
   
5. *
   
6. * Even though the name says 'int0x80', this is actually a trap gate, not an
   
7. * interrupt gate.  Thus interrupts are enabled on entry just as they are for
   
8. * a normal syscall.
   
9. 
   
10.    这里的宏IDTVEC展开后为Xint0x80_syscall
    
11. 
    
12.    260：
    
13.    当执行指令"int 0x80"时，返回地址指向紧接该指令后面那条指令，返回地址由保存在线程th1_thread
    
14.    内核栈上的CS和EIP寄存器来描述。
    
15.    这里将数值常量2(指令"int 0x80"的字节数)压入线程th1_thread的内核栈，就可以通过struct trapframe
    
16.    对象的tf_err成员访问这个数值常量，在需要重新执行系统调用时，只要将保存在线程th1_thread内核栈上
    
17.    的EIP寄存器的值减去2，系统调用返回后就会重新执行指令"int 0x80"，这样就能重新执行系统调用。
    
18.    见后面cpu_set_syscall_retval函数中的描述。
    
19. 
    
20.    pushal指令：
    
21.    Pushes the contents of the general-purpose registers onto the stack. The registers
    
22.    are stored on the stack in the following order: EAX, ECX, EDX, EBX, ESP (original
    
23.    value), EBP, ESI, and EDI (if the current operand-size attribute is 32)。
    
24. 
    
25.    266：SET_KERNEL_SREGS宏见下面的描述。
    
26. 
    
27.    267：
    
28.    清DF标志，string operations increment the index registers (ESI and/or EDI).
    
29. 
    
30.    270：调用函数syscall。
    
31. 
    
32. ***************************************/
    
33.    258                SUPERALIGN_TEXT
    
34.    259        IDTVEC(int0x80_syscall)
    
35.    260                pushl        $2                        /* sizeof "int 0x80" */
    
36.    261                subl        $4,%esp                        /* skip over tf_trapno */
    
37.    262                pushal
    
38.    263                pushl        %ds
    
39.    264                pushl        %es
    
40.    265                pushl        %fs
    
41.    266                SET_KERNEL_SREGS
    
42.    267                cld
    
43.    268                FAKE_MCOUNT(TF_EIP(%esp))
    
44.    269                pushl        %esp
    
45.    270                call        syscall
    
46.    271                add        $4, %esp
    
47.    272                MEXITCOUNT
    
48.    273                jmp        doreti

复制代码

[宏SET_KERNEL_SREGS]：

1. /**********************************************************************************
   
2. * Setup the kernel segment registers.
   
3.    此时处理器x运行在内核态，段寄存器也要更改。
   
4.    
   
5.    173-175：
   
6.    用内核数据段的segment selector，即KDSEL加载DS，ES两个寄存器，访问内核数据。
   
7. 
   
8.    176-177：
   
9.    用KPSEL加载FS寄存器，这样就能访问数据对象__pcpu[x]，也是宏PCPU_*的基础。   
   
10. ******************************************/
    
11.    172        #define        SET_KERNEL_SREGS                                                \
    
12.    173                movl        $KDSEL, %eax ;        /* reload with kernel's data segment */        \
    
13.    174                movl        %eax, %ds ;                                                \
    
14.    175                movl        %eax, %es ;                                                \
    
15.    176                movl        $KPSEL, %eax ;        /* reload with per-CPU data segment */        \
    
16.    177                movl        %eax, %fs
    

复制代码

[函数syscall]：

1. /******************************************************************************
   
2. * syscall - system call request C handler.  A system call is
   
3. * essentially treated as a trap by reusing the frame layout.
   
4. 
   
5.    参数描述：
   
6. 
   
7.    frame：
   
8.    从上面线程th1_thread的内核栈结构可以明显看出，调用syscall函数时，传递
   
9.    的是一个指向struct trapframe对象的指针，而不是整个struct trapframe结构体。
   
10. ********************************************/
    
11.   1140        void
    
12.   1141        syscall(struct trapframe *frame)
    
13.   1142        {
    
14. /***************************************************************************
    
15. * 局部变量描述：
    
16.    td：指向描述当前运行线程的struct thread对象。
    
17. 
    
18.    sa：一个类型struct syscall_args的对象，用来保存系统调用的参数等信息。
    
19. 
    
20.    orig_tf_eflags：用来临时保存线程th1_thread内核栈上的EFLAGS寄存器的值。
    
21. 
    
22.    error：保存系统调用的返回值。
    
23. 
    
24.    ksi：信号相关，暂时忽略。
    
25. *******************************************/
    
26.   1143                struct thread *td;
    
27.   1144                struct syscall_args sa;
    
28.   1145                register_t orig_tf_eflags;
    
29.   1146                int error;
    
30.   1147                ksiginfo_t ksi;
    
31.   1148       
    
32. /********************************************************************************
    
33. * 1149-1154：
    
34.    编译内核时选择了DIAGNOSTIC这个选项时，才执行额外的检查。
    
35.    
    
36.    #define      SEL_UPL         3
    
37.    #define        ISPL(s)        ((s)&3)        what is the priority level of a selector
    
38. 
    
39.    这里将检查执行"int 0x80"指令陷入内核时cpu是否运行在用户态。
    
40.    这是通过检查保存在线程th1_thread内核栈上的CS寄存器的值来实现的，根据之前的
    
41.    描述，CS寄存器保存的是segment selector，而segment selector中RPL字段的值
    
42.    标识了cpu运行在用户态还是内核态，如果RPL字段的值为3，就表示cpu运行在
    
43.    用户态。
    
44. 
    
45.    从这里可以看出，只有在cpu运行在用户态时才能触发系统调用异常。  
    
46. **************************************/
    
47.   1149        #ifdef DIAGNOSTIC
    
48.   1150                if (ISPL(frame->tf_cs) != SEL_UPL) {
    
49.   1151                        panic("syscall");
    
50.   1152                        /* NOT REACHED */
    
51.   1153                }
    
52.   1154        #endif
    
53.   1155                orig_tf_eflags = frame->tf_eflags;
    
54.   1156       
    
55. /*******************************************************************************
    
56. * 1157：
    
57.    这里td的值为&th1_thread。
    
58.    
    
59.    1158：
    
60.    th1_thread的td_frame用来访问保存在线程th1_thread内核栈上的用户态硬件上下文，
    
61.    即通过类型为struct trapframe的对象来描述。
    
62.    和前面描述"处理器J间中断-接收处理"中对比一下，是通过td_intr_frame这个成员访问
    
63.    struct trapframe对象的。
    
64.    从这里可以看出，貌似这两个成员在不同的场合中使用。
    
65. 
    
66.    1160：
    
67.    调用syscallenter函数，这个函数任务有点杂，见下面的描述。
    
68. 
    
69.    1162-1172:
    
70.    single-step mode for debugging, 暂时将其忽略。
    
71. *****************************************************/
    
72.   1157                td = curthread;
    
73.   1158                td->td_frame = frame;
    
74.   1159       
    
75.   1160                error = syscallenter(td, &sa);
    
76.   1161       
    
77.   1162                /*
    
78.   1163                 * Traced syscall.
    
79.   1164                 */
    
80.   1165                if ((orig_tf_eflags & PSL_T) && !(orig_tf_eflags & PSL_VM)) {
    
81.   1166                        frame->tf_eflags &= ~PSL_T;
    
82.   1167                        ksiginfo_init_trap(&ksi);
    
83.   1168                        ksi.ksi_signo = SIGTRAP;
    
84.   1169                        ksi.ksi_code = TRAP_TRACE;
    
85.   1170                        ksi.ksi_addr = (void *)frame->tf_eip;
    
86.   1171                        trapsignal(td, &ksi);
    
87.   1172                }
    
88.   1173       
    
89.   1174                KASSERT(PCB_USER_FPU(td->td_pcb),
    
90.   1175                    ("System call %s returning with kernel FPU ctx leaked",
    
91.   1176                     syscallname(td->td_proc, sa.code)));
    
92.   1177                KASSERT(td->td_pcb->pcb_save == &td->td_pcb->pcb_user_save,
    
93.   1178                    ("System call %s returning with mangled pcb_save",
    
94.   1179                     syscallname(td->td_proc, sa.code)));
    
95.   1180       
    
96. /*********************************************************************************
    
97. * 1181：
    
98.    函数syscallret完成的工作的还是挺多的，比如重新设置线程th1_thread的优先级，
    
99.    当线程th1_thread是通过vfork创建的，就要进行相应的处理，进程跟踪相关处理等等。
    
100.    这里暂时将其忽略。
     
101.    现在系统调用已经执行完，主要的工作也就完成，这个函数留作以后再分析。
     
102. ******************************/
     
103.   1181                syscallret(td, error, &sa);
     
104.   1182        }

复制代码

[函数syscallenter]：

1. /******************************************************************************
   
2. * 参数描述：
   
3.    td：这里为&th1_thread。
   
4.    sa：指向一个类型为struct syscall_args的对象，保存系统调用的参数。
   
5. 
   
6.    这里略去了进程跟踪等相关的代码，重点看一下系统调用处理相关的代码。
   
7.    完整的函数可以在"$FreeBSD: release/9.2.0/sys/kern/subr_syscall.c"中找到。
   
8. **************************************/
   
9.     55        static inline int
   
10.     56        syscallenter(struct thread *td, struct syscall_args *sa)
    
11.     57        {
    
12.     58                struct proc *p;
    
13.     59                int error, traced;
    
14.     60                
    
15. /*********************************************************************************
    
16. * 61：递增相关的计数器。
    
17.    cnt是内核定义的一个类型为struct vmmeter的对象，该对象的成员相当于一个计数器。
    
18.    u_int v_syscall; calls to syscall() 即调用函数syscall的次数。
    
19. 
    
20.    62：p为&p1_proc
    
21. *****************************************/
    
22.     61                PCPU_INC(cnt.v_syscall);
    
23.     62                p = td->td_proc;
    
24. .........................................................................................
    
25. .........................................................................................
    
26. /*********************************************************************************************************
    
27. * 75：
    
28.    这里将调用函数cpu_fetch_syscall_args获取系统调用参数，系统调用号等，并以系统调用号为索引，在数组sysent
    
29.    中找到其对应的数组元素，见下面的简单分析。
    
30.    从函数cpu_fetch_syscall_args的实现来看，在freebsd9.2中，系统调用号是通过
    
31.    EAX寄存器传递的，而系统调用的参数是通过用户栈来传递的，这点和linux有点区别，
    
32.    linux中系统调用的参数是通过寄存器来传递。
    
33. 
    
34.    当cpu_fetch_syscall_args函数执行完后:
    
35.    1->系统调用号超过最大限制时，忽略传递进来的系统调用号，此时sa指向的对象的成员被设置为：
    
36.       sa->callp被设置为&sysent[0].
    
37.       sa->narg被设置为sysent[0].sy_narg，这里的值为0。
    
38.       sa->code被设置为系统调用号，此时该成员的值被忽略。
    
39.       sa->args中保存了系统调用的参数。
    
40.       
    
41.       数组元素sysent[0]的各成员取值如下：
    
42.       sysent[0].sy_narg = 0;       
    
43.       sysent[0].sy_call= nosys;       
    
44.       sysent[0].sy_auevent = AUE_NULL;       
    
45.       sysent[0].sy_systrace_args_func = NULL;
    
46.       sysent[0].sy_entry = 0;       
    
47.       sysent[0].sy_return = 0;
    
48.       sysent[0].sy_flags = 0;
    
49.       sysent[0].sy_thrcnt = SY_THR_STATIC;
    
50. 
    
51. 
    
52.    2->系统调用号在正常的大小范围内，这里执行的是系统调用rfork，其系统调用号是251，此时sa指向的对象的
    
53.       成员被设置为：
    
54.       sa->callp被设置为&sysent[251].
    
55.       sa->narg被设置为sysent[251].sy_narg，这里的为AS(rfork_args)，值为1，即1个4字节。
    
56.       sa->code被设置为系统调用号251。
    
57.       sa->args中保存了系统调用的参数，系统调用rfork只有一个参数flags。
    
58. 
    
59.       数组元素sysent[251]的各成员取值如下：
    
60.       sysent[251].sy_narg = AS(rfork_args);       
    
61.       sysent[251].sy_call= sys_rfork;       
    
62.       sysent[251].sy_auevent = AUE_RFORK;       
    
63.       sysent[251].sy_systrace_args_func = NULL;
    
64.       sysent[251].sy_entry = 0;       
    
65.       sysent[251].sy_return = 0;
    
66.       sysent[251].sy_flags = 0;
    
67.       sysent[251].sy_thrcnt = SY_THR_STATIC;
    
68.       
    
69. ****************************************/
    
70.     75                error = (p->p_sysent->sv_fetch_syscall_args)(td, sa);
    
71. .........................................................................................
    
72. .........................................................................................
    
73.     86                if (error == 0) {
    
74. .........................................................................................
    
75. .........................................................................................
    
76. /******************************************************************************************************
    
77. * 119：
    
78.    如果通过模块向内核注册了一个系统调用，那么描述该系统调用的struct sysent对象的sy_thrcnt
    
79.    成员将被设置为0，从函数syscall_thread_enter的实现来看，该函数只对这种系统调用感兴趣，此时
    
80.    sy_thrcnt成员相当于一个计数器，每次执行相应的系统调用时，函数syscall_thread_enter都给其递增
    
81.    一个常量SY_THR_INCR。
    
82. 
    
83.    135：
    
84.    这里将调用内核中实现相应系统调用的内核函数。
    
85. 
    
86.    情况1->系统调用号超过最大限制时，从上面可以看出，此时将调用函数nosys，该函数将向线程th1_thread
    
87.           发送一个信号SIGSYS，该信号的默认操作是杀死线程th1_thread。
    
88.           #define SIGSYS          12      non-existent system call invoked
    
89. 
    
90.    情况2->系统调用号在正常的大小范围内,这里将调用sys_rfork函数，此时控制将传递给内核中实现
    
91.           rfork系统调用的内核函数。
    
92. 
    
93.    从这里还以看出，不管实现系统调用的内核函数是否需要参数，都将sa->args作为参数传递给相应的内核函数，
    
94.    因为相应的内核函数很清楚自己是否需要参数，如果需要，此时sa->args中已经包含了所需要的参数；
    
95.    如果不需要，sa->args中也没有包含参数，相应的内核函数也不会使用sa->args这个参数。
    
96. 
    
97.    152：
    
98.    和syscall_thread_enter函数的操作相反，这里将执行递减操作。
    
99. ************************************************************/
    
100.    119                        error = syscall_thread_enter(td, sa->callp);
     
101.    120                        if (error != 0)
     
102.    121                                goto retval;
     
103. ........................................................................................
     
104. ........................................................................................
     
105.    135                        error = (sa->callp->sy_call)(td, sa->args);
     
106. ........................................................................................
     
107. ........................................................................................
     
108.    152                        syscall_thread_exit(td, sa->callp);
     
109.    153                        CTR4(KTR_SYSC, "syscall: p=%p error=%d return %#lx %#lx",
     
110.    154                            p, error, td->td_retval[0], td->td_retval[1]);
     
111.    155                }
     
112.    156         retval:
     
113. ........................................................................................
     
114. ........................................................................................
     
115. /**************************************************************************
     
116. * 162: 对返回值进行处理。
     
117.    这里将调用cpu_set_syscall_retval函数。
     
118. ****************************/
     
119.    162                (p->p_sysent->sv_set_syscall_retval)(td, error);
     
120.    163                return (error);
     
121.    164        }
     

复制代码

[函数cpu_fetch_syscall_args]-获取系统调用的参数等，可以结合上面的图一起看：

1. /***************************************************************
   
2. * 参数描述：
   
3.    td：&th1_thread。
   
4.    sa：指向类型为struct syscall_args的数据对象。  
   
5. ***************************************************/
   
6.   1081        cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
   
7.   1082        {
   
8.   1083                struct proc *p;
   
9.   1084                struct trapframe *frame;
   
10.   1085                caddr_t params;
    
11.   1086                int error;
    
12.   1087                
    
13. /**********************************************************************
    
14. * 1088：这里p为&p1_proc。
    
15. 
    
16.    1089：通过变量frame访问保存在线程th1_thread内核栈上的用户态
    
17.          硬件上下文。
    
18. ***********************************/
    
19.   1088                p = td->td_proc;
    
20.   1089                frame = td->td_frame;
    
21.   1090                
    
22. /**********************************************************************
    
23. * 1091：tf_esp指向用户栈的栈顶，这里加上sizeof(int)是要跳过
    
24.          保存在用户栈上的返回地址，所以此时params指向的位置保存
    
25.          了传递给系统调用的参数。
    
26. 
    
27.    1092：系统调用号一般通过EAX寄存器来传递，所以这里的sa->code
    
28.          保存的就是系统调用号。
    
29. *******************************************/
    
30.   1091                params = (caddr_t)frame->tf_esp + sizeof(int);
    
31.   1092                sa->code = frame->tf_eax;
    
32.   1093       
    
33. /******************************************************************************
    
34. * 1097-1110：对系统调用号进行检查。
    
35. * Need to check if this is a 32 bit or 64 bit syscall.
    
36.    #define        SYS_syscall        0
    
37.    #define        SYS___syscall        198
    
38. 
    
39.    1097-1103：
    
40.    如果通过eax寄存器传递进来的系统调用号为SYS_syscall，那么保存在用户
    
41.    栈上的第一个参数为系统调用号，此时重新设置sa->code，并更新变量
    
42.    params，使其指向正确的位置
    
43.                   
    
44.    1103-1110：同上,貌似这里的系统调用号大小为64bit。
    
45. 
    
46.    至于为什么要进行这个检查，估计和函数库中的封装有关系，这块大家
    
47.    了解的话，麻烦及时联系一下。不过一般情况下，通过EAX寄存器传递的
    
48.    是标准的系统调用号，不会执行1097-1110之间的代码。
    
49. 
    
50.    这里看一下freebsd函数库中是怎么调用rfork系统调用的：
    
51.    00057764 <__sys_rfork>:
    
52.       57764:        b8 fb 00 00 00               mov    $0xfb,%eax
    
53.       57769:        cd 80                        int    $0x80
    
54.       5776b:        72 e3                        jb     57750 <__sys_lchown+0xc>
    
55.    上面的mov指令，0xfb就是系统调用rfork的系统调用号，值为251，可以看出EAX
    
56.    传递的是标准的系统调用号。
    
57. ***********************************************/
    
58.   1096               
    
59.   1097                if (sa->code == SYS_syscall) {
    
60.   1098                        /*
    
61.   1099                         * Code is first argument, followed by actual args.
    
62.   1100                         */
    
63.   1101                        sa->code = fuword(params);
    
64.   1102                        params += sizeof(int);
    
65.   1103                } else if (sa->code == SYS___syscall) {
    
66.   1104                        /*
    
67.   1105                         * Like syscall, but code is a quad, so as to maintain
    
68.   1106                         * quad alignment for the rest of the arguments.
    
69.   1107                         */
    
70.   1108                        sa->code = fuword(params);
    
71.   1109                        params += sizeof(quad_t);
    
72.   1110                }
    
73.   1111                
    
74. /**********************************************************************************
    
75. * 执行到这里的话，sa->code保存的都是有意义的系统调用号。
    
76. * 1112-1113:
    
77.    elf32_freebsd_sysvec对象的sv_mask成员为0，这里不会进行处理。
    
78. 
    
79.    1114-1117：检查系统调用号是否在指定的范围内。
    
80.    #define        SYS_MAXSYSCALL        533
    
81.    elf32_freebsd_sysvec对象的sv_size成员为SYS_MAXSYSCALL
    
82. 
    
83.    1114-1116：系统调用号超过最大限制，这时将忽略传递进来的系统调用号。
    
84.    sa->callp将被设置为&sysent[0]。
    
85.    
    
86.    1116-1117：系统调用号没有超过最大限制。
    
87.    sa->callp将被设置为&sysent[sa->code]。
    
88. 
    
89.    1118：sa->narg被设置为系统调用实际需要的参数的数目。
    
90. 
    
91.    1120-1124：
    
92.    struct sysent对象的sy_narg成员明确指定了相应的系统调用需要的参数的数目，
    
93.    所以这里根据需要将传递进来的系统调用参数copy到sa->args中。
    
94. ***************************************************/
    
95.   1112                 if (p->p_sysent->sv_mask)
    
96.   1113                         sa->code &= p->p_sysent->sv_mask;
    
97.   1114                 if (sa->code >= p->p_sysent->sv_size)
    
98.   1115                         sa->callp = &p->p_sysent->sv_table[0];
    
99.   1116                  else
    
100.   1117                         sa->callp = &p->p_sysent->sv_table[sa->code];
     
101.   1118                sa->narg = sa->callp->sy_narg;
     
102.   1119                
     
103.   1120                if (params != NULL && sa->narg != 0)
     
104.   1121                        error = copyin(params, (caddr_t)sa->args,
     
105.   1122                            (u_int)(sa->narg * sizeof(int)));
     
106.   1123                else
     
107.   1124                        error = 0;
     
108.   1125                
     
109. /***************************************************
     
110. * register_t        td_retval[2]; Syscall aux returns.
     
111.                
     
112.    这里设置的返回值暂时可以忽略。
     
113. ******************************/
     
114.   1126                if (error == 0) {
     
115.   1127                        td->td_retval[0] = 0;
     
116.   1128                        td->td_retval[1] = frame->tf_edx;
     
117.   1129                }
     
118.   1130                       
     
119.   1131                return (error);
     
120.   1132        }

复制代码

[函数cpu_set_syscall_retval]- 处理返回值，一般情况下，EAX寄存器包含的是返回值：

1.    391        void
   
2.    392        cpu_set_syscall_retval(struct thread *td, int error)
   
3.    393        {
   
4.    394       
   
5.    395                switch (error) {
   
6. /**********************************************************************
   
7. * 396-400:
   
8.    系统调用成功执行，error为0。
   
9.    此时td_retval[0],td_retval[1]已经被相应的内核函数设置为有意义的值。
   
10.    清除EFLAGS寄存器中的进位标志，表示没有错误发生。
    
11. ***************/
    
12.    396                case 0:
    
13.    397                        td->td_frame->tf_eax = td->td_retval[0];
    
14.    398                        td->td_frame->tf_edx = td->td_retval[1];
    
15.    399                        td->td_frame->tf_eflags &= ~PSL_C;
    
16.    400                        break;
    
17.    401                
    
18. /**********************************************************************************
    
19. * 402-408:
    
20.    系统调用被中断，但是内核返回错误码ERESTART：
    
21.    #define        ERESTART  (-1)         restart syscall
    
22. 
    
23.    将保存在线程th1_thread内核栈上的EIP寄存器的值减去2，在系统调用异常返回后，
    
24.    EIP寄存器的值为指令"int 0x80"的地址，此时将重新执行系统调用。  
    
25. **************************************/
    
26.    402                case ERESTART:
    
27.    403                        /*
    
28.    404                         * Reconstruct pc, assuming lcall $X,y is 7 bytes, int
    
29.    405                         * 0x80 is 2 bytes. We saved this in tf_err.
    
30.    406                         */
    
31.    407                        td->td_frame->tf_eip -= td->td_frame->tf_err;
    
32.    408                        break;
    
33.    409                
    
34. /**************************************************************
    
35. * 410-411：
    
36. * #define  EJUSTRETURN (-2) don't modify regs, just return
    
37.    不做任何处理。            
    
38. ************************/
    
39.    410                case EJUSTRETURN:
    
40.    411                        break;
    
41.    412                
    
42. /****************************************************************
    
43. * 413-422:
    
44.    由于某种原因，系统调用执行失败，error包含了相应的错误码。
    
45. 
    
46.    414-419：不做处理
    
47.    elf32_freebsd_sysvec对象的sv_errsize成员为0。
    
48.    
    
49.    420：
    
50.    将系统调用执行失败的的错误码通过eax寄存器返回给应用程序。
    
51.    注意，如果没有函数库或者封装例程的介入，此时系统调用的返回值
    
52.    就是执行失败的错误码，而不是-1；返回-1是因为函数库或者封装例程
    
53.    做了额外的处理，这个额外的处理就是errno变量的引入。
    
54.    
    
55.    421：
    
56.    设置EFLAGS寄存器的进位标志，表示系统调用执行失败。
    
57. *******************************/                       
    
58.    413                default:
    
59.    414                        if (td->td_proc->p_sysent->sv_errsize) {
    
60.    415                                if (error >= td->td_proc->p_sysent->sv_errsize)
    
61.    416                                        error = -1;        /* XXX */
    
62.    417                                else
    
63.    418                                        error = td->td_proc->p_sysent->sv_errtbl[error];
    
64.    419                        }
    
65.    420                        td->td_frame->tf_eax = error;
    
66.    421                        td->td_frame->tf_eflags |= PSL_C;
    
67.    422                        break;
    
68.    423                }
    
69.    424        }

复制代码

whhitdragon

**************************************/
  1149        #ifdef DIAGNOSTIC
  1150                if (ISPL(frame->tf_cs) != SEL_UPL) {
  1151                        panic("syscall");
  1152                        /* NOT REACHED */
  1153                }
  1154        #endif
  1155                orig_tf_eflags = frame->tf_eflags;
  1156        
/*******************************************************************************