PROCESS MANAGEMENT: STRUTTURE DATI

Sintesi fin qui Processi utente Memoria centrale Periferiche Residente Switcher System calls Interrupt Handlers I/O drivers Residente Daemon Processi utente Non residente Processo 1 Processo 2 Processo n Memoria centrale Periferiche

Immagine di un processo L’immagine di memoria di un processo è organizzata in tre regioni: Testo Dati Stack E’ rientrante, e può essere condiviso fra più processi Ogni regione è uno spazio di indirizzamento autonomo

Che cosa genera il compilatore C #include ... NON char buffer[1000]; INIZIALIZZATI int version=1; DATI main(int argc, char *argv[]) INIZIALIZZATI { int i; while ... ... exit (0); STACK } int fun(int n) { int j; if ... TESTO ... } 3 Il compilatore genera solo la dimensione: lo spazio verrà azzerato dal kernel all'esecuzione

Formato di un eseguibile Un eseguibile è costituito da un insieme di header e un insieme di sezioni, contenenti codice o dati: Main header, con magic number Header della Sezione 1 Header della Sezione 2 Sezione 1 Sezione 2

Sintesi fin qui Memoria centrale Periferiche Residente Non residente Switcher System calls Interrupt Handlers I/O drivers Residente Stack Stack Stack Non residente Dati Dati Dati Testo Testo Testo Processo 1 Processo 2 Processo n Memoria centrale Periferiche

Strutture dati per la gestione dei processi Process Table si trova nel kernel, ed è residente contiene una entry per ogni processo, ed è dimensionata staticamente al momento della configurazione del sistema per ogni processo contiene le informazioni che ne permettono la schedulazione, e che devono essere sempre residenti U-Area (user area) si trova nel kernel, ma non è residente contiene quelle informazioni necessarie al kernel per la gestione del processo, ma che non è necessario che siano sempre residenti in memoria Ready Queue Liste dei processi ready (una per ciascun livello di priorità)

Strutture dati per la gestione dei processi Process Table 1 2 3 4 … PID PPID UID del proprietario Stato del processo Flag di residenza Parametri di schedulazione (priorità, tempo di CPU usato, tempo di attesa) Dimensione del processo Maschere per i segnali …. U-Area

Strutture dati per la gestione dei processi Ptr alla Process Table entry Registers & PC save area Stack del kernel per il processo Info relative alla system call corrente File descriptors dei file aperti dal processo Parametri per operazioni di I/O Directory corrente e root directory Informazioni per l’accounting Puntatori alle region del processo …. 1 2 3 4 … Testo Dati Stack Processo Process Table Text Table U-Area Processo

Strutture dati per la gestione dei processi 1 2 -1 -2 Ready Q Priorità 1 Lista dei processi che hanno priorità 0 2 3 4 … Testo Dati Stack Processo Process Table Text Table U-Area

Sintesi fin qui Kernel Switcher U-Area Stack Dati Testo Processo 2 Processo n Processo 1 Process Table Ready queue Switcher Interrupt handlers System calls

MEMORY MANAGEMENT

Paginazione Le versioni non “antiche” di Unix utilizzano tecniche di paginazione Per eseguire un processo è sufficiente che in memoria siano presenti almeno: la sua u-area la sua tabella delle pagine Le pagine di testo, dati e stack sono portate dinamicamente in memoria dal kernel, una alla volta, quando servono (cioè a seguito di un page fault) Se u-area e tabella delle pagine non sono in memoria, ve le porta il processo swapper

Pagedaemon E’ un demone che viene eseguito periodicamente per controllare il numero di pagine libere in memoria: Se è troppo basso, libera qualche pagina Se è ok, ritorna inattivo

Swapper E’ un processo di sistema che: Se le pagine libere sono sotto il minimo, rimuove uno o più processi dalla memoria (in genere quelli inattivi da più tempo): SWAPOUT Verifica periodicamente la esistenza di processi pronti su disco e, se possibile, li carica in memoria (solo u-area e tabella delle pagine) (in genere quelli fuori da più tempo, a meno che non siano troppo grossi): SWAPIN

PROCESS MANAGEMENT: SYSTEM CALL

Processi in Unix In Unix, ogni processo viene creato dal kernel su richiesta di un altro processo (detto processo padre), mediante una apposita system call (fork) Esiste un processo iniziale (PID=0) che non ha padre, e che viene creato dal kernel al momento della inizializzazione del sistema Ogni processo si termina attraverso una apposita system call (exit)

Creazione di un processo In Unix un nuovo processo viene creato esclusivamente per duplicazione di un processo esistente, attraverso la system call: pid_t fork(void); che crea un processo “figlio” identico al padre, e restituisce: al figlio: 0 al padre: PID del figlio in caso di errore: -1 L’unica eccezione è il processo 0, che viene creato alla inizializzazione del sistema

Fork: esempio p = fork(); if p < 0 { /* la fork è fallita */ } else if p=0 { /* operazioni del figlio */ } else { /* operazioni del padre */ } In Unix non esiste alcuna system call per “creare un processo che esegue l’eseguibile x” Devo farlo utilizzando più system call…

Creazione di un processo Kernel Switcher Interrupt handlers System calls Process Table Ready queue Processo Figlio Dati Stack U-Area Processo Padre Testo Dati Stack U-Area P=0 P= n P=fork()

Che cosa fa la fork Alloca una entry nella Process Table per il nuovo processo Assegna un PID unico al nuovo processo e inizializza i campi della Process Table entry Crea una copia della immagine del processo padre (il testo non viene duplicato ma si incrementa un reference count) Incrementa opportuni contatori dei file aperti Inizializza i contatori di accounting nella u-area del nuovo processo Pone il nuovo processo nello stato di pronto Restituisce il PID del figlio al padre, 0 al figlio o -1 in caso di errore

exec (pathname, argomenti) Le system call exec exec (pathname, argomenti) sostituisce l’immagine del chiamante con il file eseguibile pathname, e lo manda in esecuzione passandogli gli argomenti p = fork(); if p < 0 { /* la fork è fallita */ } else if p=0 { /* operazioni del figlio */ } exec (…) else { /* operazioni del padre */ }

Creazione di un processo Kernel Switcher Interrupt handlers System calls Process Table Ready queue Processo Padre Testo Dati Stack U-Area U-Area Stack Dati Processo Figlio

Exec Kernel Switcher U-Area U-Area Stack Stack Dati Dati Testo Testo Interrupt handlers System calls Process Table Ready queue U-Area U-Area Stack Stack Dati Dati Testo Testo Processo Padre Processo Figlio

Terminazione di un processo In Unix un processo si termina attraverso la system call void _exit(int status); che: - termina il processo chiamante; - rende disponibile al processo padre il valore di status, mettendolo nella propria process table entry - (il padre potrà ottenerlo tramite la primitiva wait)

pid_t wait (int *status) sospende il processo chiamante fino a che uno dei suoi figli termina restituisce il PID del figlio terminato (di uno a caso se sono più di uno) o –1 se non ci sono figli assegna a status l’exit status del figlio

process table entry del figlio Exit: esempio padre … int st; …. wait ( &st ) figlio … exit (0) …. process table entry del figlio

Exit Kernel Switcher Interrupt handlers System calls Process Table Ready queue La process table entry del figlio non può essere rimossa fino a quando il valore di status in essa contenuto non è stato prelevato dal padre U-Area U-Area Stack Stack Dati Dati Testo Testo Processo Padre Processo Figlio

Zombie e orfani un processo terminato passa nello stato di zombie, e viene definitivamente rimosso dopo che il padre ha ricevuto il suo stato di terminazione con una wait un processo zombie occupa un insieme minimo di risorse (process table entry) un processo orfano (cioè il cui padre è terminato) viene “adottato” dal processo init, quindi un processo ha sempre un padre

Altri stati di un processo Zombie Exit Idle fork

INIZIALIZZAZIONE DEL SISTEMA

BOOTSTRAP All’accensione della macchina, l’hardware lancia il programma di boostrap … … che carica in memoria il blocco di boot da disco, il quale contiene un programma… …. che carica in memoria il kernel … … e quindi trasferisce il controllo a un entry point (start), che crea il processo 0

Inizializzazione del sistema /etc/getty /bin/login LOGIN SHELL exec fork swapper Processo Ø bootstrap /etc/init demoni ……. Inizializzazione del sistema inizializza le strutture dati del kernel crea processo 1 (init): fork+exec) Start crea un processo per ogni terminale attivo e i demoni: è il padre di tutti i processi – è in loop exec fork cmd 1 1 comando è la shell di login effettua il login inizializza il terminale kernel mode user mode

STRUTTURA DELLA SHELL

Shell: interfaccia utente $file args esecuzione in foreground <output> $file args& esecuzione in background $

Struttura generale della shell $file args<> <output> $ write (1, PROMPT); while ((n=read(0,buffer,80)=!0) { riconosci nome file e args; If ( (pid=fork()) ==0) { /* I/O redirection */ if (exec(file, args)==-1) exit (1) } procid=wait(status); If (status !=0) write (2, error); write(1,PROMPT) } FIGLIO PADRE Se il comando è eseguito in background, non viene eseguita la wait

COMUNICAZIONE FRA PROCESSI

Interprocess communication in Unix Unix fornisce diversi meccanismi: Segnali Pipes Sockets …

Che cos’è un segnale Un segnale è una notifica a un processo che è occorso un particolare evento: Un errore di floating point La morte di un figlio Una richiesta di terminazione … I segnali possono essere pensati come degli “interrupts software” I segnali possono essere inviati: da un processo a un altro processo da un processo a se stesso dal kernel a un processo Ogni segnale è identificato da un numero intero associato a un nome simbolico

Segnali in POSIX Segnale Significato (default) SIGABRT Abortisce un processo (termina con dump) SIGALRM Invia un segnale di "sveglia" (termina) SIGCHLD Lo stato di un figlio è cambiato (ignora) SIGCONT Continua un processo stoppato (continua o ignora) SIGFPE Floating Point Error (termina con dump) SIGHUP Hangup su un terminale (termina) SIGILL Istruzione di macchina illegale (termina con dump) SIGINT Premuto il tasto DEL per interrompere il processo (termina) SIGKILL Segnale per terminare un processo (non può essere ignorato) (termina) SIGPIPE Tentativo di scrivere su una pipe che non ha lettori (termina) SIGQUIT L'utente ha usato il tasto di quit del terminale (termina con dump) SIGSEGV Riferimento a un indirizzo di memoria non valido (termina con dump) SIGSTOP Per stoppare un processo (non può essere ignorato) (stoppa il processo) SIGTERM Segnale per terminare un processo (termina) SIGTSTP L'utente ha usato il tasto "suspend" del terminale (stoppa il processo) SIGTTIN Un processo in background tenta di leggere dal suo terminale di controllo (stoppa il processo) SIGTTOU Un processo in background tenta di scrivere sul su terminale di controllo (stoppa il processo) SIGUSR1 Disponibile per scopi definiti dall'applicazione SIGUSR2 Disponibile per scopi definiti dall'applicazione

System call per gestire i segnali kill (PID, sig#) invia il segnale specificato al processo o al gruppo di processi specificato sigaction (sig#, action, ..) associa a un segnale la sua funzione di trattamento (inizialmente: signal – non POSIX)

Come viene trattato un segnale Quando un processo riceve un segnale, può: Trattarlo mediante una specificata funzione (“handler”) Ignorarlo Attivare l’azione di default associata al segnale stesso (termina o sospendi il processo, ignora)

Esempio Per terminare o sospendere un processo in foreground, l’utente può premere i tasti CTRL-C o CTRL-Z (rispettivamente) Tale carattere viene acquisito dal driver del terminale, che notifica al processo il segnale SIGINT o SIGTSTP (rispettivamente) Per default, SIGINT termina il processo e SIGTSTP lo sospende NB: Tali segnali vengono inviati a tutto il gruppo di processi

Protezione Per motivi di protezione, deve valere almeno una delle seguenti condizioni: Il processo che riceve e il processo che invia il segnale devono avere lo stesso owner L’owner del processo che invia il segnale è il superuser

Strutture dati per la gestione dei segnali 1 2 3 4 ..… un bit per ogni segnale, che viene alzato dalla kill (viene ricordato solo l’ultimo segnale di ogni tipo) 1 2 3 4 … Testo Dati Stack Processo Process Table Text Table 1 2 3 4 ..… array di puntatori agli handler definiti dall’utente per ogni segnale (null=default) U-Area