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

8.  -》\kernel\proc.c

点击(此处)折叠或打开

1. PUBLIC int do_ipc(reg_t r1, reg_t r2, reg_t r3)
   
2. {
   
3.   struct proc *const caller_ptr = get_cpulocal_var(proc_ptr);    /* get pointer to caller */
   
4.   int call_nr = (int) r1;
   
5. 
   
6.   assert(!RTS_ISSET(caller_ptr, RTS_SLOT_FREE));
   
7. 
   
8.   /* bill kernel time to this process. */
   
9.   kbill_ipc = caller_ptr;
   
10. 
    
11.   /* If this process is subject to system call tracing, handle that first. */
    
12.   if (caller_ptr->p_misc_flags & (MF_SC_TRACE | MF_SC_DEFER)) {
    
13.     /* Are we tracing this process, and is it the first sys_call entry? */
    
14.     if ((caller_ptr->p_misc_flags & (MF_SC_TRACE | MF_SC_DEFER)) ==
    
15.                             MF_SC_TRACE) {
    
16.         /* We must notify the tracer before processing the actual
    
17.          * system call. If we don't, the tracer could not obtain the
    
18.          * input message. Postpone the entire system call.
    
19.          */
    
20.         caller_ptr->p_misc_flags &= ~MF_SC_TRACE;
    
21.         caller_ptr->p_misc_flags |= MF_SC_DEFER;
    
22. 
    
23.         /* Signal the "enter system call" event. Block the process. */
    
24.         cause_sig(proc_nr(caller_ptr), SIGTRAP);
    
25. 
    
26.         /* Preserve the return register's value. */
    
27.         return caller_ptr->p_reg.retreg;
    
28.     }
    
29. 
    
30.     /* If the MF_SC_DEFER flag is set, the syscall is now being resumed. */
    
31.     caller_ptr->p_misc_flags &= ~MF_SC_DEFER;
    
32. 
    
33.     assert (!(caller_ptr->p_misc_flags & MF_SC_ACTIVE));
    
34. 
    
35.     /* Set a flag to allow reliable tracing of leaving the system call. */
    
36.     caller_ptr->p_misc_flags |= MF_SC_ACTIVE;
    
37.   }
    
38. 
    
39.   if(caller_ptr->p_misc_flags & MF_DELIVERMSG) {
    
40.     panic("sys_call: MF_DELIVERMSG on for %s / %d\n",
    
41.         caller_ptr->p_name, caller_ptr->p_endpoint);
    
42.   }
    
43. 
    
44.   /* Now check if the call is known and try to perform the request. The only
    
45.    * system calls that exist in MINIX are sending and receiving messages.
    
46.    * - SENDREC: combines SEND and RECEIVE in a single system call
    
47.    * - SEND: sender blocks until its message has been delivered
    
48.    * - RECEIVE: receiver blocks until an acceptable message has arrived
    
49.    * - NOTIFY: asynchronous call; deliver notification or mark pending
    
50.    * - SENDA: list of asynchronous send requests
    
51.    */
    
52.   switch(call_nr) {
    
53.       case SENDREC:
    
54.       case SEND:            
    
55.       case RECEIVE:            
    
56.       case NOTIFY:
    
57.       case SENDNB:
    
58.       {
    
59.        /* Process accounting for scheduling */
    
60.      caller_ptr->p_accounting.ipc_sync++;
    
61. 
    
62.        return do_sync_ipc(caller_ptr, call_nr, (endpoint_t) r2,
    
63.              (message *) r3);
    
64.       }
    
65.       case SENDA:
    
66.       {
    
67.       /*
    
68.        * Get and check the size of the argument in bytes as it is a
    
69.        * table
    
70.        */
    
71.        size_t msg_size = (size_t) r2;
    
72.   
    
73.        /* Process accounting for scheduling */
    
74.      caller_ptr->p_accounting.ipc_async++;
    
75.  
    
76.        /* Limit size to something reasonable. An arbitrary choice is 16
    
77.        * times the number of process table entries.
    
78.        */
    
79.        if (msg_size > 16*(NR_TASKS + NR_PROCS))
    
80.      return EDOM;
    
81.        return mini_senda(caller_ptr, (asynmsg_t *) r3, msg_size);
    
82.       }
    
83.       default:
    
84.     return EBADCALL;        /* illegal system call */
    
85.   }
    
86. }

点击(此处)折叠或打开

1. PRIVATE int do_sync_ipc(struct proc * caller_ptr, /* who made the call */
   
2.             int call_nr,    /* system call number and flags */
   
3.             endpoint_t src_dst_e,    /* src or dst of the call */
   
4.             message *m_ptr)    /* users pointer to a message */
   
5. {
   
6.   int result;                    /* the system call's result */
   
7.   int src_dst_p;                /* Process slot number */
   
8.   char *callname;
   
9. 
   
10.   /* Check destination. RECEIVE is the only call that accepts ANY (in addition
    
11.    * to a real endpoint). The other calls (SEND, SENDREC, and NOTIFY) require an
    
12.    * endpoint to corresponds to a process. In addition, it is necessary to check
    
13.    * whether a process is allowed to send to a given destination.
    
14.    */
    
15.   assert(call_nr != SENDA);
    
16. 
    
17.   /* Only allow non-negative call_nr values less than 32 */
    
18.   if (call_nr < 0 || call_nr > IPCNO_HIGHEST || call_nr >= 32
    
19.       || !(callname = ipc_call_names[call_nr])) {
    
20. #if DEBUG_ENABLE_IPC_WARNINGS
    
21.       printf("sys_call: trap %d not allowed, caller %d, src_dst %d\n",
    
22.           call_nr, proc_nr(caller_ptr), src_dst_p);
    
23. #endif
    
24.     return(ETRAPDENIED);        /* trap denied by mask or kernel */
    
25.   }
    
26. 
    
27.   if (src_dst_e == ANY)
    
28.   {
    
29.     if (call_nr != RECEIVE)
    
30.     {
    
31. #if 0
    
32.         printf("sys_call: %s by %d with bad endpoint %d\n",
    
33.             callname,
    
34.             proc_nr(caller_ptr), src_dst_e);
    
35. #endif
    
36.         return EINVAL;
    
37.     }
    
38.     src_dst_p = (int) src_dst_e;
    
39.   }
    
40.   else
    
41.   {
    
42.     /* Require a valid source and/or destination process. */
    
43.     if(!isokendpt(src_dst_e, &src_dst_p)) {
    
44. #if 0
    
45.         printf("sys_call: %s by %d with bad endpoint %d\n",
    
46.             callname,
    
47.             proc_nr(caller_ptr), src_dst_e);
    
48. #endif
    
49.         return EDEADSRCDST;
    
50.     }
    
51. 
    
52.     /* If the call is to send to a process, i.e., for SEND, SENDNB,
    
53.      * SENDREC or NOTIFY, verify that the caller is allowed to send to
    
54.      * the given destination.
    
55.      */
    
56.     if (call_nr != RECEIVE)
    
57.     {
    
58.         if (!may_send_to(caller_ptr, src_dst_p)) {
    
59. #if DEBUG_ENABLE_IPC_WARNINGS
    
60.             printf(
    
61.             "sys_call: ipc mask denied %s from %d to %d\n",
    
62.                 callname,
    
63.                 caller_ptr->p_endpoint, src_dst_e);
    
64. #endif
    
65.             return(ECALLDENIED);    /* call denied by ipc mask */
    
66.         }
    
67.     }
    
68.   }
    
69. 
    
70.   /* Check if the process has privileges for the requested call. Calls to the
    
71.    * kernel may only be SENDREC, because tasks always reply and may not block
    
72.    * if the caller doesn't do receive().
    
73.    */
    
74.   if (!(priv(caller_ptr)->s_trap_mask & (1 << call_nr))) {
    
75. #if DEBUG_ENABLE_IPC_WARNINGS
    
76.       printf("sys_call: %s not allowed, caller %d, src_dst %d\n",
    
77.           callname, proc_nr(caller_ptr), src_dst_p);
    
78. #endif
    
79.     return(ETRAPDENIED);        /* trap denied by mask or kernel */
    
80.   }
    
81. 
    
82.   if (call_nr != SENDREC && call_nr != RECEIVE && iskerneln(src_dst_p)) {
    
83. #if DEBUG_ENABLE_IPC_WARNINGS
    
84.       printf("sys_call: trap %s not allowed, caller %d, src_dst %d\n",
    
85.            callname, proc_nr(caller_ptr), src_dst_e);
    
86. #endif
    
87.     return(ETRAPDENIED);        /* trap denied by mask or kernel */
    
88.   }
    
89. 
    
90.   switch(call_nr) {
    
91.   case SENDREC:
    
92.     /* A flag is set so that notifications cannot interrupt SENDREC. */
    
93.     caller_ptr->p_misc_flags |= MF_REPLY_PEND;
    
94.     /* fall through */
    
95.   case SEND:            
    
96.     result = mini_send(caller_ptr, src_dst_e, m_ptr, 0);
    
97.     if (call_nr == SEND || result != OK)
    
98.         break;                /* done, or SEND failed */
    
99.     /* fall through for SENDREC */
    
100.   case RECEIVE:            
     
101.     if (call_nr == RECEIVE) {
     
102.         caller_ptr->p_misc_flags &= ~MF_REPLY_PEND;
     
103.         IPC_STATUS_CLEAR(caller_ptr); /* clear IPC status code */
     
104.     }
     
105.     result = mini_receive(caller_ptr, src_dst_e, m_ptr, 0);
     
106.     break;
     
107.   case NOTIFY:
     
108.     result = mini_notify(caller_ptr, src_dst_e);
     
109.     break;
     
110.   case SENDNB:
     
111.         result = mini_send(caller_ptr, src_dst_e, m_ptr, NON_BLOCKING);
     
112.         break;
     
113.   default:
     
114.     result = EBADCALL;            /* illegal system call */
     
115.   }
     
116. 
     
117.   /* Now, return the result of the system call to the caller. */
     
118.   return(result);
     
119. }

9. 由于call_nr==SENDREC，所以，首先调用mini_send函数（同样在源文件\kernel\proc.c）

点击(此处)折叠或打开

1. /*===========================================================================*
   
2.  *                mini_send                 *
   
3.  *===========================================================================*/
   
4. PUBLIC int mini_send(
   
5.   register struct proc *caller_ptr,    /* who is trying to send a message? */
   
6.   endpoint_t dst_e,            /* to whom is message being sent? */
   
7.   message *m_ptr,            /* pointer to message buffer */
   
8.   const int flags
   
9. )
   
10. {
    
11. /* Send a message from 'caller_ptr' to 'dst'. If 'dst' is blocked waiting
    
12.  * for this message, copy the message to it and unblock 'dst'. If 'dst' is
    
13.  * not waiting at all, or is waiting for another source, queue 'caller_ptr'.
    
14.  */
    
15.   register struct proc *dst_ptr;
    
16.   register struct proc **xpp;
    
17.   int dst_p;
    
18.   dst_p = _ENDPOINT_P(dst_e);
    
19.   dst_ptr = proc_addr(dst_p);
    
20. 
    
21.   if (RTS_ISSET(dst_ptr, RTS_NO_ENDPOINT))
    
22.   {
    
23.     return EDEADSRCDST;
    
24.   }
    
25. 
    
26.   /* Check if 'dst' is blocked waiting for this message. The destination's
    
27.    * RTS_SENDING flag may be set when its SENDREC call blocked while sending.
    
28.    */
    
29.   if (WILLRECEIVE(dst_ptr, caller_ptr->p_endpoint)) {
    
30.     int call;
    
31.     /* Destination is indeed waiting for this message. */
    
32.     assert(!(dst_ptr->p_misc_flags & MF_DELIVERMSG));    
    
33. 
    
34.     if (!(flags & FROM_KERNEL)) {
    
35.         if(copy_msg_from_user(caller_ptr, m_ptr, &dst_ptr->p_delivermsg))
    
36.             return EFAULT;
    
37.     } else {
    
38.         dst_ptr->p_delivermsg = *m_ptr;
    
39.         IPC_STATUS_ADD_FLAGS(dst_ptr, IPC_FLG_MSG_FROM_KERNEL);
    
40.     }
    
41. 
    
42.     dst_ptr->p_delivermsg.m_source = caller_ptr->p_endpoint;
    
43.     dst_ptr->p_misc_flags |= MF_DELIVERMSG;
    
44. 
    
45.     call = (caller_ptr->p_misc_flags & MF_REPLY_PEND ? SENDREC
    
46.         : (flags & NON_BLOCKING ? SENDNB : SEND));
    
47.     IPC_STATUS_ADD_CALL(dst_ptr, call);
    
48. 
    
49.     if (dst_ptr->p_misc_flags & MF_REPLY_PEND)
    
50.         dst_ptr->p_misc_flags &= ~MF_REPLY_PEND;
    
51. 
    
52.     RTS_UNSET(dst_ptr, RTS_RECEIVING)