Minix系列之系统调用的过程分析（1）

    下面举例说明系统调用的全过程（以fork为例）：

1.     当用户进程调用fork时，-》\lib\libc\syscall\fork.S中去执行，
   

   点击(此处)折叠或打开

   1. #include <machine/asm.h>
      
   2. 
      
   3. IMPORT(_fork)
      
   4. ENTRY(fork)
      
   5.     jmp    _C_LABEL(_fork)
2. -》\lib\libc\posix\_fork.c
   

   点击(此处)折叠或打开

   1. #include <lib.h>
      
   2. #define fork _fork
      
   3. #include <unistd.h>
      
   4. 
      
   5. PUBLIC pid_t fork()
      
   6. {
      
   7.   message m;
      
   8. 
      
   9.   return(_syscall(PM_PROC_NR, FORK, &m));
      
   10. }
3. -》\lib\nbsd_libc\sys-minix\syscall.c
   

   点击(此处)折叠或打开

   1. #include <sys/cdefs.h>
      
   2. #include <lib.h>
      
   3. #include "namespace.h"
      
   4. 
      
   5. #ifdef __weak_alias
      
   6. __weak_alias(syscall, _syscall)
      
   7. #endif
      
   8. 
      
   9. int _syscall(endpoint_t who, int syscallnr, message *msgptr)
      
   10. {
       
   11.   int status;
       
   12. 
       
   13.   msgptr->m_type = syscallnr;
       
   14.   status = _sendrec(who, msgptr);
       
   15.   if (status != 0) {
       
   16.     /* 'sendrec' itself failed. */
       
   17.     /* XXX - strerror doesn't know all the codes */
       
   18.     msgptr->m_type = status;
       
   19.   }
       
   20.   if (msgptr->m_type < 0) {
       
   21.     errno = -msgptr->m_type;
       
   22.     return(-1);
       
   23.   }
       
   24.   return(msgptr->m_type);
       
   25. }
4. -》\lib\nbsd_libc\arch\i386\sys-minix\_ipc.S
   

   点击(此处)折叠或打开

   1. #include <minix/ipcconst.h>
      
   2. #include <machine/asm.h>
      
   3. 
      
   4.     IPCVEC = 33    /* ipc trap to kernel */
      
   5.     KERVEC = 32    /* syscall trap to kernel */
      
   6. 
      
   7.     SRC_DST = 8    /* source/ destination process */
      
   8.     MESSAGE = 12    /* message pointer */
      
   9.     STATUS = 16    /* status pointer */
      
   10. 
       
   11. /**========================================================================* */
       
   12. /* IPC assembly routines             * */
       
   13. /**========================================================================* */
       
   14. /* all message passing routines save ebx, but destroy eax and ecx. */
       
   15. ENTRY(_send)
       
   16.     push    %ebp
       
   17.     movl    %esp, %ebp
       
   18.     push    %ebx
       
   19.     movl    SRC_DST(%ebp), %eax    /* eax = dest-src */
       
   20.     movl    MESSAGE(%ebp), %ebx    /* ebx = message pointer */
       
   21.     movl    $SEND, %ecx    /* _send(dest, ptr) */
       
   22.     int    $IPCVEC    /* trap to the kernel */
       
   23.     pop    %ebx
       
   24.     pop    %ebp
       
   25.     ret
       
   26. 
       
   27. ENTRY(_receive)
       
   28.     push    %ebp
       
   29.     movl    %esp, %ebp
       
   30.     push    %ebx
       
   31.     movl    SRC_DST(%ebp), %eax    /* eax = dest-src */
       
   32.     movl    MESSAGE(%ebp), %ebx    /* ebx = message pointer */
       
   33.     movl    $RECEIVE, %ecx    /* _receive(src, ptr) */
       
   34.     int    $IPCVEC    /* trap to the kernel */
       
   35.     movl    STATUS(%ebp), %ecx    /* ecx = status pointer */
       
   36.     movl    %ebx, (%ecx)
       
   37.     pop    %ebx
       
   38.     pop    %ebp
       
   39.     ret
       
   40. 
       
   41. ENTRY(_sendrec)
       
   42.     push    %ebp
       
   43.     movl    %esp, %ebp
       
   44.     push    %ebx
       
   45.     movl    SRC_DST(%ebp), %eax    /* eax = dest-src */
       
   46.     movl    MESSAGE(%ebp), %ebx    /* ebx = message pointer */
       
   47.     movl    $SENDREC, %ecx    /* _sendrec(srcdest, ptr) */
       
   48.     int    $IPCVEC    /* trap to the kernel */
       
   49.     pop    %ebx
       
   50.     pop    %ebp
       
   51.     ret
       
   52. 
       
   53. ENTRY(_notify)
       
   54.     push    %ebp
       
   55.     movl    %esp, %ebp
       
   56.     push    %ebx
       
   57.     movl    SRC_DST(%ebp), %eax    /* eax = destination */
       
   58.     movl    $NOTIFY, %ecx    /* _notify(srcdst) */
       
   59.     int    $IPCVEC    /* trap to the kernel */
       
   60.     pop    %ebx
       
   61.     pop    %ebp
       
   62.     ret
       
   63. 
       
   64. ENTRY(_sendnb)
       
   65.     push    %ebp
       
   66.     movl    %esp, %ebp
       
   67.     push    %ebx
       
   68.     movl    SRC_DST(%ebp), %eax    /* eax = dest-src */
       
   69.     movl    MESSAGE(%ebp), %ebx    /* ebx = message pointer */
       
   70.     movl    $SENDNB, %ecx    /* _sendnb(dest, ptr) */
       
   71.     int    $IPCVEC    /* trap to the kernel */
       
   72.     pop    %ebx
       
   73.     pop    %ebp
       
   74.     ret
       
   75. 
       
   76. ENTRY(_do_kernel_call)
       
   77.     /* pass the message pointer to kernel in the %eax register */
       
   78.     movl    4(%esp), %eax
       
   79.     int    $KERVEC
       
   80.     ret
5. 语句（int 33）触发33号软中断，在\common\include\arch\i386\interrupt.h中定义宏IPC_VECTOR（#include IPC_VECTOR 33），中断向量表gate_table在\kernel\arch\i386\protect.c中进行初始化，中断33的中断处理程序为ipc_entry。
   

   点击(此处)折叠或打开

   1. /* Build descriptors for interrupt gates in IDT. */
      
   2. PUBLIC void idt_init(void)
      
   3. {
      
   4.     struct gate_table_s gate_table[] = {
      
   5.         { divide_error, DIVIDE_VECTOR, INTR_PRIVILEGE },
      
   6.         { single_step_exception, DEBUG_VECTOR, INTR_PRIVILEGE },
      
   7.         { nmi, NMI_VECTOR, INTR_PRIVILEGE },
      
   8.         { breakpoint_exception, BREAKPOINT_VECTOR, USER_PRIVILEGE },
      
   9.         { overflow, OVERFLOW_VECTOR, USER_PRIVILEGE },
      
   10.         { bounds_check, BOUNDS_VECTOR, INTR_PRIVILEGE },
       
   11.         { inval_opcode, INVAL_OP_VECTOR, INTR_PRIVILEGE },
       
   12.         { copr_not_available, COPROC_NOT_VECTOR, INTR_PRIVILEGE },
       
   13.         { double_fault, DOUBLE_FAULT_VECTOR, INTR_PRIVILEGE },
       
   14.         { copr_seg_overrun, COPROC_SEG_VECTOR, INTR_PRIVILEGE },
       
   15.         { inval_tss, INVAL_TSS_VECTOR, INTR_PRIVILEGE },
       
   16.         { segment_not_present, SEG_NOT_VECTOR, INTR_PRIVILEGE },
       
   17.         { stack_exception, STACK_FAULT_VECTOR, INTR_PRIVILEGE },
       
   18.         { general_protection, PROTECTION_VECTOR, INTR_PRIVILEGE },
       
   19.         { page_fault, PAGE_FAULT_VECTOR, INTR_PRIVILEGE },
       
   20.         { copr_error, COPROC_ERR_VECTOR, INTR_PRIVILEGE },
       
   21.         { alignment_check, ALIGNMENT_CHECK_VECTOR, INTR_PRIVILEGE },
       
   22.         { machine_check, MACHINE_CHECK_VECTOR, INTR_PRIVILEGE },
       
   23.         { simd_exception, SIMD_EXCEPTION_VECTOR, INTR_PRIVILEGE },
       
   24.         { ipc_entry, IPC_VECTOR, USER_PRIVILEGE },
       
   25.         { kernel_call_entry, KERN_CALL_VECTOR, USER_PRIVILEGE },
       
   26.         { NULL, 0, 0}
       
   27.     };
       
   28. 
       
   29.     idt_copy_vectors(gate_table);
       
   30.     idt_copy_vectors(gate_table_pic);
       
   31. }
   
   
6. -》\kernel\arch\i386\mpx.S
   

   点击(此处)折叠或打开

   1. /*
      
   2.  * IPC is only from a process to kernel
      
   3.  */
      
   4. ENTRY(ipc_entry)
      
   5. 
      
   6.     SAVE_PROCESS_CTX(0)
      
   7. 
      
   8.     /* save the pointer to the current process */
      
   9.     push    %ebp
      
   10. 
       
   11.     /*
       
   12.      * pass the syscall arguments from userspace to the handler.
       
   13.      * SAVE_PROCESS_CTX() does not clobber these registers, they are still
       
   14.      * set as the userspace have set them
       
   15.      */
       
   16.     push    %ebx
       
   17.     push    %eax
       
   18.     push    %ecx
       
   19. 
       
   20.     /* stop user process cycles */
       
   21.     push    %ebp
       
   22.     /* for stack trace */
       
   23.     movl    $0, %ebp
       
   24.     call    _C_LABEL(context_stop)
       
   25.     add    $4, %esp
       
   26. 
       
   27.     call    _C_LABEL(do_ipc)
       
   28. 
       
   29.     /* restore the current process pointer and save the return value */
       
   30.     add    $3 * 4, %esp
       
   31.     pop    %esi
       
   32.     mov %eax, AXREG(%esi)
       
   33. 
       
   34.     jmp    _C_LABEL(switch_to_user)
7. -》\kernel\arch\i386\arch_clock.c
   

   点击(此处)折叠或打开

   1. PUBLIC void context_stop(struct proc * p)
      
   2. {
      
   3.     u64_t tsc, tsc_delta;
      
   4.     u64_t * __tsc_ctr_switch = get_cpulocal_var_ptr(tsc_ctr_switch);
      
   5. #ifdef CONFIG_SMP
      
   6.     unsigned cpu = cpuid;
      
   7. 
      
   8.     /*
      
   9.      * This function is called only if we switch from kernel to user or idle
      
   10.      * or back. Therefore this is a perfect location to place the big kernel
       
   11.      * lock which will hopefully disappear soon.
       
   12.      *
       
   13.      * If we stop accounting for KERNEL we must unlock the BKL. If account
       
   14.      * for IDLE we must not hold the lock
       
   15.      */
       
   16.     if (p == proc_addr(KERNEL)) {
       
   17.         u64_t tmp;
       
   18. 
       
   19.         read_tsc_64(&tsc);
       
   20.         tmp = sub64(tsc, *__tsc_ctr_switch);
       
   21.         kernel_ticks[cpu] = add64(kernel_ticks[cpu], tmp);
       
   22.         p->p_cycles = add64(p->p_cycles, tmp);
       
   23.         BKL_UNLOCK();
       
   24.     } else {
       
   25.         u64_t bkl_tsc;
       
   26.         atomic_t succ;
       
   27.         
       
   28.         read_tsc_64(&bkl_tsc);
       
   29.         /* this only gives a good estimate */
       
   30.         succ = big_kernel_lock.val;
       
   31.         
       
   32.         BKL_LOCK();
       
   33.         
       
   34.         read_tsc_64(&tsc);
       
   35. 
       
   36.         bkl_ticks[cpu] = add64(bkl_ticks[cpu], sub64(tsc, bkl_tsc));
       
   37.         bkl_tries[cpu]++;
       
   38.         bkl_succ[cpu] += !(!(succ == 0));
       
   39. 
       
   40.         p->p_cycles = add64(p->p_cycles, sub64(tsc, *__tsc_ctr_switch));
       
   41.     }
       
   42. #else
       
   43.     read_tsc_64(&tsc);
       
   44.     p->p_cycles = add64(p->p_cycles, sub64(tsc, *__tsc_ctr_switch));
       
   45. #endif
       
   46.     
       
   47.     tsc_delta = sub64(tsc, *__tsc_ctr_switch);
       
   48. 
       
   49.     if(kbill_ipc) {
       
   50.         kbill_ipc->p_kipc_cycles =
       
   51.             add64(kbill_ipc->p_kipc_cycles, tsc_delta);
       
   52.         kbill_ipc = NULL;
       
   53.     }
       
   54. 
       
   55.     if(kbill_kcall) {
       
   56.         kbill_kcall->p_kcall_cycles =
       
   57.             add64(kbill_kcall->p_kcall_cycles, tsc_delta);
       
   58.         kbill_kcall = NULL;
       
   59.     }
       
   60. 
       
   61.     /*
       
   62.      * deduct the just consumed cpu cycles from the cpu time left for this
       
   63.      * process during its current quantum. Skip IDLE and other pseudo kernel
       
   64.      * tasks
       
   65.      */
       
   66.     if (p->p_endpoint >= 0) {
       
   67. #if DEBUG_RACE
       
   68.         make_zero64(p->p_cpu_time_left);
       
   69. #else
       
   70.         /* if (tsc_delta < p->p_cpu_time_left) in 64bit */
       
   71.         if (ex64hi(tsc_delta) < ex64hi(p->p_cpu_time_left) ||
       
   72.                 (ex64hi(tsc_delta) == ex64hi(p->p_cpu_time_left) &&
       
   73.                  ex64lo(tsc_delta) < ex64lo(p->p_cpu_time_left)))
       
   74.             p->p_cpu_time_left = sub64(p->p_cpu_time_left, tsc_delta);
       
   75.         else {
       
   76.             make_zero64(p->p_cpu_time_left);
       
   77.         }
       
   78. #endif