Le syscall in Minix. Sistemi Operativi Lez. 27. Corso: Sistemi Operativi Danilo Bruschi A.A. 2010/2011

Transcript

1 Le syscall in Minix Sistemi Operativi Lez. 27

2 System Call Interfaccia tra le applicazioni ed il sistema operativo, per lo svolgimento di operazioni che coinvolgono dispositivi o strutture di memoria gestite dal sistema operativo Rendono la programmazione più semplice Incrementano la sicurezza del sistema Facilitano la portabilità del codice

3 Posix (Portable Operating system Interface) Standard che definisce l interfaccia utente e software verso applicazioni del sistema operativo Kernel API Comandi e utility L aderenza allo standard Posix è spesso garantita da librerie C che provvedono poi alla effettiva chiamata della syscall POSIX compliant = un sistema che offre le API di Posix

4 Architettura di un SO: minix

5 Organizzazione generale Ogni syscall è contraddistinta da un numero (definito in /usr/include/minix/callnr.h) Questo numero è inserito in un opportuno campo del messaggio che sarà inviato al server

6 Syscall nr.

7 Syscall lato server Ricevuta la richiesta d esecuzione della systema call dall applicazione ogni server ispeziona la struttura dati call_vec per decidere le attività da fare Ogni server dispone di un suo handler specifico per gestire ogni singola system call, questi handler hanno un nome del tipo do_nome syscall ad esempio do_fork

8 Struttura call_vec _PROTOTYPE (int (*call_vec[ncalls]), (void) ) = {! no_sys, /* 0 = unused */! do_pm_exit, /* 1 = exit */! do_fork, /* 2 = fork */! no_sys, /* 3 = read */! no_sys, /* 4 = write */! no_sys, /* 5 = open */! no_sys, /* 6 = close */! do_waitpid, /* 7 = wait */! no_sys, /* 8 = creat */! no_sys, /* 9 = link */! no_sys, /* 10 = unlink */! do_waitpid, /* 11 = waitpid */! no_sys, /* 12 = chdir */! do_time, /* 13 = time */!

9 Struttura generale di un server while( TRUE )! {! get_work(); /* wait for an MM!!!!!!!!!system call */!!!!...! result = (*call_vec [call_nr]) ();! reply(...);! }!

10 get_work () PRIVATE void get_work()! {! /* Wait for the next message and extract useful information from it. */! if (receive(any, &m_in)!= OK)! panic( FILE,"PM receive error", NO_NUM);! who_e = m_in.m_source;/* who sent the message */! if(pm_isokendpt(who_e, &who_p)!= OK)! panic( FILE, "PM got message from invalid endpoint", who_e);! call_nr = m_in.m_type; /* system call number */!

11 Kernel call Il system call handler del server, dopo lo svolgimento di una serie di operazioni determinate dal tipo di system call da gestire provvede a chiamare la kernel call di riferimento attraverso una sendrec a sys_task All interno del codice della kernel call si troverà la chiamata all handler effettivo della system call originale, il cui nome segue le convenzioni già usate per i server

12 Kernel call

13 Overview of System Task (2)

14

15 sys_task

16 Syscall handler PUBLIC int (*call_vec[nr_sys_calls])(message *m_ptr);!! #define map(call_nr, handler) \! {extern int dummy[nr_sys_calls>(unsigned) (call_nr-kernel_call)? 1:-1];} \!! call_vec[(call_nr-kernel_call)] = (handler)!

17 ESECUZIONE DELLA SYSCALL FORK()

18 Descrizione generale 1. L applicazione invia un messaggio FORK al memory manager richiedendo la creazione di un nuovo processo 2. Il memory manager alloca la memoria per il nuovo processo ed informa il system task del nuovo processo inviando un messaggio SYS_FORK 3. Il memory manager informa il file system della creazione del nuovo processo inviandogli un messaggio FORK 4. Al termine della creazione del processo il memory manager invia due messaggi di reply: 1. Al genitore con il PID del figlio 2. Al figlio con valore di ritorno 0 reply message to the parent (e) with a return

19 Schema fork() Interation Networks, by P. Ahton et al.

20 Esecuzione fork() if (fork()!= 0) Viene tradotta dal compilatore in una chiamata alla procedura di libreria lib/syscall/ fork.s (nel caso di eventuali parametri, gli stessi saranno passati via stack)

21 Lib sys/src/lib/syscall/fork.s:.sect.text.extern fork.define _fork.align 2 _fork: jmp fork Che a sua volta richiama la procedura fork(), che è definita nel file sys/src/lib/posix/fork.c

22 libc sys/src/lib/posix/fork.c #include < lib.h> #define fork _fork #include < unistd.h> PUBLIC pid_t fork() message m; return(_syscall(pm, FORK, &m)); Che richiama la funzione _syscall, indicando come destinatario dell attività richiesta il processo PM

23 _syscall #include < lib.h> PUBLIC int _syscall(who, syscallnr, msgptr) int who; int syscallnr; register message *msgptr; int status; msgptr->m_type = syscallnr; status = _sendrec(who, msgptr); if (status!= 0) { /* 'sendrec' itself failed. */ /* XXX - strerror doesn't know all the codes */ msgptr->m_type = status; } if (msgptr->m_type < 0) { errno = -msgptr->m_type; return(-1); } return(msgptr->m_type);

24 _sendrec /sys/src/lib/i386/rts/_sendrec.c sendrec: push ebp mov ebp, esp push ebx mov eax, SRCDEST(ebp) mov ebx, MESSAGE(ebp) mov ecx, BOTH int SYSVEC pop ebx pop ebp ret! eax = dest-src! ebx = message pointer! _sendrec(srcdest, ptr)! trap to the kernel

25 _sendrec lib/i386/rts/ _sendrec sect.text;.sect.rom;.sect.data;.sect.bss 301.define send, receive, sendrec 302! See../h/com.h for C definitions 303 SEND = RECEIVE = BOTH = SYSVEC = SRCDEST = MESSAGE = 12

26 _s_call: _p_s_call: cld! set direction flag to a known value sub esp, 6*4! skip RETADR, eax, ecx, edx, ebx, est push ebp! stack already points into proc table push esi push edi o16 push ds o16 push es o16 push fs o16 push gs mov dx, ss mov ds, dx mov es, dx incb (_k_reenter) mov esi, esp! assumes P_STACKBASE == 0 mov esp, k_stktop xor ebp, ebp! for stacktrace! end of inline save! now set up parameters for sys_call() push ebx! pointer to user message push eax! src/dest push ecx! SEND/RECEIVE/BOTH call _sys_call! sys_call(function, src_dest, m_ptr)

27

28

29 minisend Prepara il messaggio per PM, che prima o poi lo preleverà attraverso una receive Nel file include/minix/callnr.h, alla fork() è assegnato il numero 2 : #define FORK 2 Nel file pm/table.c, la struttura dati call_vec associa alla syscall fork() la procedura: do_fork, /* 2 = fork */

30 PM main.c 0047 /*====================================================================*! * main *! 00049*=====================================================================*/! PUBLIC int main()! {! /* Main routine of the process manager. */! int result, s, proc_nr;! struct mproc *rmp;! sigset_t sigset;! 00056! pm_init(); /* initialize process manager tables */! 00058! /* This is PM's main loop- get work and do it, forever and forever. */! while (TRUE) {! get_work(); /* wait for an PM system call */! 00062!

31 mproc EXTERN struct mproc {!! struct mem_map mp_seg[nr_local_segs]; /* points to text, data, stack */! char mp_exitstatus; /* storage for status when process exits */! char mp_sigstatus; /* storage for signal # for killed procs */! pid_t mp_pid; /* process id */! int mp_endpoint; /* kernel endpoint id */! pid_t mp_procgrp; /* pid of process group (used for signals) */! pid_t mp_wpid; /* pid this process is waiting for */! int mp_parent; /* index of parent process */! 00021!! /* Child user and system times. Accounting done on child exit. */! clock_t mp_child_utime; /* cumulative user time of children */! clock_t mp_child_stime; /* cumulative sys time of children */! 00025!! /* Real and effective uids and gids. */! uid_t mp_realuid; /* process' real uid */! uid_t mp_effuid; /* process' effective uid */! gid_t mp_realgid; /* process' real gid */! gid_t mp_effgid; /* process' effective gid */!

32 mproc /* File identification for sharing. */! ino_t mp_ino; /* inode number of file */! dev_t mp_dev; /* device number of file system */! time_t mp_ctime; /* inode changed time */! 00036! /* Signal handling information. */! sigset_t mp_ignore; sigset_t mp_catch; /* 1 means ignore the signal, 0 means don't */! /* 1 means catch the signal, 0 means don't */! sigset_t mp_sig2mess; /* 1 means transform into notify message */! sigset_t mp_sigmask; /* signals to be blocked */! sigset_t mp_sigmask2; /* saved copy of mp_sigmask */! sigset_t mp_sigpending; /* pending signals to be handled */! struct sigaction mp_sigact[_nsig + 1]; /* as in sigaction(2) */! vir_bytes mp_sigreturn; /* address of C library sigreturn function */! struct timer mp_timer; /* watchdog timer for alarm(2) */! 00047! /* Backwards compatibility for signals. */! sighandler_t mp_func; /* all sigs vectored to a single user fcn */! 00050! unsigned mp_flags; /* flag bits */! vir_bytes mp_procargs; /* ptr to proc's initial stack arguments */! struct mproc *mp_swapq; /* queue of procs waiting to be swapped in */! message mp_reply; /* reply message to be sent to one */! 00055! /* Scheduling priority. */! signed int mp_nice; /* nice is PRIO_MIN..PRIO_MAX, standard 0. */! 00058! char mp_name[proc_name_len]; /* process name */! } mproc[nr_procs];!

33 priv

34 pm/do_fork() Legge in input il valore di mp che punta al PCB (contenuto in PM) del processo che ha eseguito la fork() Verifica se ci sono posizioni libere nella tabella dei processi mproc! Determina la quantità di memoria necessaria per la generazione del processo figlio (vanno replicati solo segmento Stack e dati) Copia il PCB del padre nella posizione libera di mproc! Assegna al processo figlio un nuovo Pid! Invia messaggi a systask e FS

35 Pm/do_fork /*======================================================================*! * do_fork *! *=====================================================================*/! PUBLIC int do_fork()! {! /* The process pointed to by 'mp' has forked. Create a child process. */! register struct mproc *rmp; register struct mproc *rmc; /* pointer to parent */! /* pointer to child */! int child_nr, s;! phys_clicks prog_clicks, child_base;! phys_bytes prog_bytes, parent_abs, child_abs; /* Intel only */! pid_t new_pid;! static int next_child;! int n = 0, r;!

36 Caricamento PCB figlio do {! next_child = (next_child+1) % NR_PROCS;! n++;! } while((mproc[next_child].mp_flags & IN_USE) && n <= NR_PROCS);! if(n > NR_PROCS)! 00078! panic( FILE,"do_fork finds wrong child slot", next_child);! 00082! rmc = &mproc[next_child];! /* Set up the child and its memory map; copy its 'mproc' slot from parent. */! child_nr = (int)(rmc - mproc); /* slot number of the child */! procs_in_use++;! *rmc = *rmp; /* copy parent's process slot to child's */! rmc->mp_parent = who_p; /* record child's parent */! /* inherit only these flags */! rmc->mp_flags &= (IN_USE SEPARATE PRIV_PROC DONT_SWAP);! rmc->mp_child_utime = 0 /* reset administration */! rmc->mp_child_stime = 0; /* reset administration */

37 Messaggi a sys_task e FS /* Tell kernel and file system about the (now successful) FORK. */! if(! (r=sys_fork(who_e, child_nr, &rmc->mp_endpoint))!= OK)!! {! panic( FILE,"do_fork can't sys_fork", r);! }!! tell_fs(fork, who_e, rmc->mp_endpoint, rmc->mp_pid);!

38 sys_fork() #include "syslib.h"! 00002! PUBLIC int sys_fork(parent, child, child_endpoint)! int parent; /* process doing the fork */! int child; /* which proc has been created by the fork */! int *child_endpoint;! {! /* A process has forked. Tell the kernel. */! 00009! message m;! int r;! 00012! m.pr_endpt = parent;! m.pr_slot = child;! r = _taskcall(systask, SYS_FORK, &m);! *child_endpoint = m.pr_endpt;! return r;! }!

39 sys/src/lib/syslib/taskcall.c: _taskcall #include < lib.h> #include < minix/syslib.h> PUBLIC int _taskcall(who, syscallnr, msgptr) int who; int syscallnr; register message *msgptr; int status; msgptr->m_type = syscallnr; status = _sendrec(who, msgptr); if (status!= 0) return(status); return(msgptr->m_type);

40 sys_task /*==========================================================================*! 0006* sys_task *! *========================================================================*/! PUBLIC void sys_task()! {! /* Main entry point of sys_task. Get the message and dispatch on type. */! static message m;! register int result;! register struct proc *caller_ptr;! unsigned int call_nr;! int s;! 00070! /* Initialize the system task. */! initialize();! 00073! while (TRUE) {! /* Get work. Block and wait until a request message arrives. */! receive(any, &m);! call_nr = (unsigned) m.m_type - KERNEL_CALL;! who_e = m.m_source;! okendpt(who_e, &who_p);! caller_ptr = proc_addr(who_p);!

41 system task }! else {! result = (*call_vec[call_nr])(&m); /* handle the system call */! }! 00097! /* Send a reply, unless inhibited by a handler function. Use the kernel! * function lock_send() to prevent a system call trap. The destination! * is known to be blocked waiting for a message.! */! if (result!= EDONTREPLY) {! m.m_type = result; /* report status of call */! if (OK!= (s=lock_send(m.m_source, &m))) {! kprintf("system, reply to %d failed: %d\n", m.m_source, s);! }! }!

42 do_fork /*=========================================================================*! * do_fork *! *========================================================================*/! PUBLIC int do_fork(m_ptr)! register message *m_ptr; /* pointer to request message */! {! /* Handle sys_fork(). PR_ENDPT has forked. The child is PR_SLOT. */! register struct proc *rpc; /* child process pointer */! struct proc *rpp; /* parent process pointer */! int i, gen;! int p_proc;! ! old_ldt_sel = rpc->p_ldt_sel; /* backup local descriptors */! 44 *rpc = *rpp; /* copy 'proc' struct */! 45.!

43 do-fork rpc->p_rts_flags = NO_MAP; /* inhibit process from running */! rpc->p_rts_flags &= ~(SIGNALED SIG_PENDING P_STOP);! sigemptyset(&rpc->p_pending);! 00058! rpc->p_reg.retreg = 0; /* child sees pid = 0 to know it is child */! rpc->p_user_time = 0; /* set all the accounting times to 0 */! rpc->p_sys_time = 0;! 00062! /* Parent and child have to share the quantum that the forked process had,! * so that queued processes do not have to wait longer because of the fork.! * If the time left is odd, the child gets an extra tick.! */! rpc->p_ticks_left = (rpc->p_ticks_left + 1) / 2;! rpp->p_ticks_left = rpp->p_ticks_left / 2;!

44 e alla fine do_fork restituisce il controllo a: sys_task, che invia una send a taskcall, che terminando restituisce il controllo a sys_fork che terminando rientra su: pm/do_fork che invia una reply al processo figlio, per rientrare poi su: PM (main.c) che provvede ad inviare una reply all applicazione che ha originariamente richiesto la fork