Sistemi Operativi 1. Mattia Monga. a.a. 2008/09. Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia

Transcript

1 1 Mattia Dip. di Informatica e Comunicazione Università degli Studi di Milano, Italia mattia.monga@unimi.it a.a. 2008/09 1 c 2009 M.. Creative Commons Attribuzione-Condividi allo stesso modo 2.5 Italia License. Immagini tratte da [?] e da Wikipedia. 1

2 332 Lezione XIX:

3 333 Send e receive A seguito dell interrupt software generato sia da send che da receive il sistema chiama come risposta all interruzione la routine s call la routine s call a sua volta volta chiama sys call che a sua volta (dopo aver controllato i privilegi e lo stato del processo) chiama la routine o eseguita direttamente dal kernel al termine dell esecuzione di queste procedure il controllo torna alla procedura restart

4 334 Sia S il processo che effettua la send verso D, le operazioni svolte per effettuare questa istruzione sono: 1 Verifica eventuale deadlock 2 Verifica che processo D sia in attesa di un messaggio da parte di S ed in questo caso consegna e sblocca D 3 altrimenti, S viene messo in attesa su una lista indirizzata dal puntatore iniziale p caller q del PCB di D 4 Inoltre nel campo p sendto del PCB di S viene inserito il valore di D

5 335 Verifica deadlock 1 / Send a message from caller ptr to dst. If dst is blocked waiting 2 for this message, copy the message to it and unblock dst. If dst is 3 not waiting at all, or is waiting for another source, queue caller ptr. 4 / 5 register struct proc dst ptr = proc addr(dst); 6 register struct proc xpp; 7 register struct proc xp; 8 9 / Check for deadlock by caller ptr and dst sending to each other. / 10 xp = dst ptr; 11 while (xp >p rts flags & SENDING) { / check while sending / 12 xp = proc addr(xp >p sendto); / get xp s destination / 13 if (xp == caller ptr) return(elocked); / deadlock if cyclic / 14 }

6 336 D is blocked 1 / Check if dst is blocked waiting for this message. The destination s 2 SENDING flag may be set when its SENDREC call blocked while sending. 3 / 4 if ( (dst ptr >p rts flags & (RECEIVING SENDING)) == RECEIVING && 5 (dst ptr >p getfrom == ANY dst ptr >p getfrom == caller ptr >p nr)) { 6 / Destination is indeed waiting for this message. / 7 CopyMess(caller ptr >p nr, caller ptr, m ptr, dst ptr, 8 dst ptr >p messbuf); 9 if ((dst ptr >p rts flags &= RECEIVING) == 0) enqueue(dst ptr); 10 }

7 337 D is not blocked 1 else if (! (flags & NON BLOCKING)) { 2 / Destination is not waiting. Block and caller. / 3 caller ptr >p messbuf = m ptr; 4 if (caller ptr >p rts flags == 0) (caller ptr); 5 caller ptr >p rts flags = SENDING; 6 caller ptr >p sendto = dst; 7 8 / Process is now blocked. Put in on the destination s queue. / 9 xpp = &dst ptr >p caller q; / find end of list / 10 while ( xpp!= NIL PROC) xpp = &( xpp) >p q link; 11 xpp = caller ptr; / add caller to end / 12 caller ptr >p q link = NIL PROC; / mark new end of list / 13 }

8 338 Unable to send Il processo 3 non può consegnare al processo 0, poi il processo 4 non può consegnare a 0

9 1 void enqueue(rp) 2 register struct proc rp; / this process is now runnable / 3 { 4 / Add rp to one of the queues of runnable processes. This function is 5 responsible for inserting a process into one of the scheduling queues. 6 The mechanism is implemented here. The actual scheduling policy is 7 defined in sched() and pick proc(). 8 / 9 /... / 10 pick proc(); 11 } 12 void (rp) 13 register struct proc rp; / this process is no longer runnable / 14 { 15 / A process must be removed from the scheduling queues, for example, because 16 it has blocked. If the currently active process is removed, a new process 17 is picked to run by calling pick proc(). 18 / 339

10 340 Sia R il processo che effettua la receive da S 1 Verifica se ci sono notifiche (che hanno la precedenza) da consegnare 2 Verifica se processo S è in attesa di consegnare il messaggio, in questo caso consegna e sblocca S 3 altrimenti, R viene messo in attesa 4 Inoltre nel campo p getfrom del PCB di R viene inserito il valore di S

11 341 Pending notification 1 / Check if there are pending notifications, except for SENDREC. / 2 if (! (priv(caller ptr) >s flags & SENDREC BUSY)) { 3 4 map = &priv(caller ptr) >s notify pending; 5 for (chunk=&map >chunk[0]; chunk<&map >chunk[nr SYS CHUNKS]; chun 6 7 / Find a pending notification from the requested source. / 8 /... / 9 / Found a suitable source, deliver the notification message. / 10 BuildMess(&m, src proc nr, caller ptr); / assemble message / 11 CopyMess(src proc nr, proc addr(hardware), &m, caller ptr, m ptr); 12 return(ok); / report success / 13 } 14 }

12 342 Messaggio disponibile 1 / Check caller queue. Use pointer pointers to keep code simple. / 2 xpp = &caller ptr >p caller q; 3 while ( xpp!= NIL PROC) { 4 if (src == ANY src == proc nr( xpp)) { 5 / Found acceptable message. Copy it and update status. / 6 CopyMess(( xpp) >p nr, xpp, ( xpp) >p messbuf, caller ptr, m ptr); 7 if ((( xpp) >p rts flags &= SENDING) == 0) enqueue( xpp); 8 xpp = ( xpp) >p q link; / remove from queue / 9 return(ok); / report success / 10 } 11 xpp = &( xpp) >p q link; / proceed to next / 12 }

13 343 Messaggio non disponibile 1 / No suitable message is available or the caller couldn t send in SENDREC. 2 Block the process trying to receive, unless the flags tell otherwise. 3 / 4 if (! (flags & NON BLOCKING)) { 5 caller ptr >p getfrom = src; 6 caller ptr >p messbuf = m ptr; 7 if (caller ptr >p rts flags == 0) (caller ptr); 8 caller ptr >p rts flags = RECEIVING; 9 return(ok); 10 }

14 344 1 / Check to see if target is blocked waiting for this message. A process 2 can be both sending and receiving during a SENDREC system call. 3 / 4 if ((dst ptr >p rts flags & (RECEIVING SENDING)) == RECEIVING && 5! (priv(dst ptr) >s flags & SENDREC BUSY) && 6 (dst ptr >p getfrom == ANY dst ptr >p getfrom == caller ptr >p nr)) { 7 8 / Destination is indeed waiting for a message. Assemble a notification 9 message and deliver it. Copy from pseudo source HARDWARE, since the 10 message is in the kernel s address space. 11 / 12 BuildMess(&m, proc nr(caller ptr), dst ptr); 13 CopyMess(proc nr(caller ptr), proc addr(hardware), &m, 14 dst ptr, dst ptr >p messbuf); 15 dst ptr >p rts flags &= RECEIVING; / deblock destination / 16 if (dst ptr >p rts flags == 0) enqueue(dst ptr); 17 return(ok); 18 }

15 345 1 / Destination is not ready to receive the notification. Add it to the 2 bit map with pending notifications. Note the indirectness: the system id 3 instead of the process number is used in the pending bit map. 4 / 5 src id = priv(caller ptr) >s id; 6 set sys bit(priv(dst ptr) >s notify pending, src id); 7 return(ok);

16 346 Servizi di sistema I servizi di sistema sono l interfaccia tra le applicazioni ed il sistema operativo. Permettono lo svolgimento di operazioni che coinvolgono dispositivi o strutture di memoria gestite dal sistema operativo in maniera controllata. In : API POSIX (Portable Operating System Interface), tramite librerie C messaggi di processi User ai Server Kernel call messaggi di processi Server o Driver al System Task

17 347 Kernel call

18 348 Il flusso di una system call POSIX (user) 1 u.c:user if (fork() == 0) /... / 2 lib/syscall/fork.s:user fork: jmp fork 3 lib/posix/ fork.c:user syscall(pm PROC NR, FORK, &m) 4 lib/other/syscall.c:user msgptr >m type = syscallnr; status = sendrec(who, msgptr); 5 lib/lib/i386/rts/ ipc.s:user 1 mov eax, SRC DST(ebp) 2 mov ebx, MESSAGE(ebp) 3 mov ecx, SENDREC 4 int 33

19 Il flusso di una system call POSIX (kernel) 1 kernel/protect.c:kernel {s call, SYS386 VECTOR, USER PRIVILEGE }, / 33: 386 system call / 2 kernel/mpx386.s:kernel 1 s call: 2 ;... 3 push edx ; event set or flags bit map 4 push ebx ; pointer to user message 5 push eax ; PM PROC NR 6 push ecx ; SENDREC 7 call sys call ; sys call(call nr, src dst, m ptr, bit map) 3 kernel/proc.c:kernel 1 switch(function) { 2 case SENDREC: 3 / fall through / 4 case SEND: 5 / caller USER, src dst PM PROC NR / 6 result = (caller ptr, src dst e, m ptr, flags); 7 case RECEIVE: 8 / caller USER, src dst PM PROC NR / 9 result = (caller ptr, src dst e, m ptr, flags); 10 break; 11 } 349

20 350 Il flusso di una system call POSIX (PM) 1 server/pm/main.c:pm server result = ( call vec[call nr])(); 2 server/pm/table.c:pm server 1 int ( call vec[ncalls]), (void) ) = { 2 /... / 3 do fork / 2 = fork / 4 /... / 5 } 3 server/pm/forkexit.c:pm server sys fork(who, child nr); 4 lib/syslib/sys fork.c:pm server r = taskcall(systask, SYS FORK, &m); 5 lib/sysutil/taskcall.c:pm server msgptr >m type = syscallnr; status = sendrec(who, msgptr);

21 351 Il flusso di una system call POSIX (kernel) 1 kernel/mpx386.s:kernel 1 s call: 2 ;... 3 push edx ; event set or flags bit map 4 push ebx ; pointer to user message 5 push eax ; PM PROC NR 6 push ecx ; SENDREC 7 call sys call ; sys call(call nr, src dst, m ptr, bit map) 2 kernel/proc.c:kernel 1 switch(function) { 2 case SENDREC: 3 / fall through / 4 case SEND: 5 / caller PM PROC NR, src dst SYSTASK / 6 result = (caller ptr, src dst e, m ptr, flags); 7 case RECEIVE: 8 / caller PM PROC NR, src dst SYSTASK / 9 result = (caller ptr, src dst e, m ptr, flags); 10 break;

22 352 Il flusso di una system call POSIX (System) 4 Completa 1 kernel/system.c:system Task result = ( call vec[call nr])(); 2 server/system.c:system Task map(sys FORK, do fork); 3 server/system/do fork.c:system Task DO (the kernel part of) FORK! i con i reply

23 do fork (in PM) Verifica se esiste spazio nella tabella dei processi mproc che contiene la mappa di memoria per ogni processo Verifica la quantità di memoria necessaria per allocare il nuovo processo (è uguale a quella del padre) e la sua disponibilità Crea una copia delle porzioni di memoria occupate dal processo padre Individua uno slot libero in mproc e copia il contenuto dello slot del processo padre Assegna un PID all interno di mproc,che sarà poi lo stesso usato per la tabella dei processi Chiama la kernel call sys fork (kernel) per aggiornare la process table Chiama anche tell fs per avvertire FS 353