异步消息流程

迈不过友情╰ 2024-02-18 19:20 83阅读 0赞

PUBLIC int get\_ticks()  
\{  
disp\_str("get\_ticks ");  
//pause\_system();  
MESSAGE msg;  
reset\_msg(&msg);  
msg.type = GET\_TICKS;  
send\_recv(BOTH, TASK\_SYS, &msg);  
return msg.RETVAL;  
\}  
  
PUBLIC int send\_recv(int function, int src\_dest, MESSAGE\* msg)  
\{  
disp\_str("send\_recv ");  
  
  
int ret = 0;  
  
  
if (function == RECEIVE)  
memset(msg, 0, sizeof(MESSAGE));  
  
  
switch (function) \{  
case BOTH:  
ret = sendrec(SEND, src\_dest, msg);  
if (ret == 0)  
ret = sendrec(RECEIVE, src\_dest, msg);  
break;  
case SEND:  
case RECEIVE:  
ret = sendrec(function, src\_dest, msg);  
break;  
default:  
assert((function == BOTH) ||  
 (function == SEND) || (function == RECEIVE));  
break;  
\}  
  
  
return ret;  
\}  
  
; ====================================================================================  
; sendrec(int function, int src\_dest, MESSAGE\* msg);  
; ====================================================================================  
; Never call sendrec() directly, call send\_recv() instead.  
sendrec:  
mov eax, \_NR\_sendrec  
mov ebx, \[esp + 4\] ; function  
mov ecx, \[esp + 8\] ; src\_dest  
mov edx, \[esp + 12\] ; p\_msg  
int INT\_VECTOR\_SYS\_CALL  
ret  
  
  
PUBLIC system\_call sys\_call\_table\[NR\_SYS\_CALL\] = \{sys\_printx,  
 sys\_sendrec\};  
  
  
  
; =============================================================================  
; sys\_call  
; =============================================================================  
sys\_call:  
call save  
  
  
sti  
push esi  
  
  
push dword \[p\_proc\_ready\]  
push edx  
push ecx  
push ebx  
call \[sys\_call\_table + eax \* 4\]  
add esp, 4 \* 4  
  
  
pop esi  
mov \[esi + EAXREG - P\_STACKBASE\], eax  
cli  
  
  
ret  
  
  
  
  
PUBLIC int sys\_sendrec(int function, int src\_dest, MESSAGE\* m, struct proc\* p)  
\{  
disp\_str("sys\_sendrec ");  
assert(k\_reenter == 0); /\* make sure we are not in ring0 \*/  
assert((src\_dest >= 0 && src\_dest < NR\_TASKS + NR\_PROCS) ||  
 src\_dest == ANY ||  
 src\_dest == INTERRUPT);  
  
  
int ret = 0;  
int caller = proc2pid(p);  
MESSAGE\* mla = (MESSAGE\*)va2la(caller, m);  
mla->source = caller;  
  
  
assert(mla->source != src\_dest);  
  
  
/\*\*  
 \* Actually we have the third message type: BOTH. However, it is not  
 \* allowed to be passed to the kernel directly. Kernel doesn't know  
 \* it at all. It is transformed into a SEND followed by a RECEIVE  
 \* by \`send\_recv()'.  
 \*/  
if (function == SEND)  
\{  
ret = msg\_send(p, src\_dest, m);  
if (ret != 0)  
return ret;  
\}  
else if (function == RECEIVE) \{  
ret = msg\_receive(p, src\_dest, m);  
if (ret != 0)  
return ret;  
\}  
else \{  
panic("\{sys\_sendrec\} invalid function: "  
 "%d (SEND:%d, RECEIVE:%d).", function, SEND, RECEIVE);  
\}  
  
  
return 0;  
\}   
  
  
PRIVATE int msg\_send(struct proc\* current, int dest, MESSAGE\* m)  
\{  
disp\_str("msg\_send ");  
struct proc\* sender = current;  
struct proc\* p\_dest = proc\_table + dest; /\* proc dest \*/  
  
  
assert(proc2pid(sender) != dest);  
  
  
/\* check for deadlock here \*/  
if (deadlock(proc2pid(sender), dest)) \{  
panic(">>DEADLOCK<< %s->%s", sender->name, p\_dest->name);  
\}  
  
  
if ((p\_dest->p\_flags & RECEIVING) && /\* dest is waiting for the msg \*/  
 (p\_dest->p\_recvfrom == proc2pid(sender) ||  
 p\_dest->p\_recvfrom == ANY)) \{  
assert(p\_dest->p\_msg);  
assert(m);  
  
  
phys\_copy(va2la(dest, p\_dest->p\_msg),  
 va2la(proc2pid(sender), m),  
 sizeof(MESSAGE));  
p\_dest->p\_msg = 0;  
p\_dest->p\_flags &= ~RECEIVING; /\* dest has received the msg \*/  
p\_dest->p\_recvfrom = NO\_TASK;  
unblock(p\_dest);  
  
  
assert(p\_dest->p\_flags == 0);  
assert(p\_dest->p\_msg == 0);  
assert(p\_dest->p\_recvfrom == NO\_TASK);  
assert(p\_dest->p\_sendto == NO\_TASK);  
assert(sender->p\_flags == 0);  
assert(sender->p\_msg == 0);  
assert(sender->p\_recvfrom == NO\_TASK);  
assert(sender->p\_sendto == NO\_TASK);  
\}  
else \{ /\* dest is not waiting for the msg \*/  
sender->p\_flags |= SENDING;  
assert(sender->p\_flags == SENDING);  
sender->p\_sendto = dest;  
sender->p\_msg = m;  
  
  
/\* append to the sending queue \*/  
struct proc \* p;  
if (p\_dest->q\_sending) \{  
p = p\_dest->q\_sending;  
while (p->next\_sending)  
p = p->next\_sending;  
p->next\_sending = sender;  
\}  
else \{  
p\_dest->q\_sending = sender;  
\}  
sender->next\_sending = 0;  
  
  
block(sender);  
  
  
assert(sender->p\_flags == SENDING);  
assert(sender->p\_msg != 0);  
assert(sender->p\_recvfrom == NO\_TASK);  
assert(sender->p\_sendto == dest);  
\}  
  
  
return 0;  
\}  
  
上边这个函数返回0后  
从第26行继续执行：