PROCESS MANAGEMENT: STRUTTURE DATI. Sintesi fin qui Residente Processo 2Processo n Daemon Processo 1...
45
PROCESS MANAGEMENT: STRUTTURE DATI
-
Upload
vegliantino-palumbo -
Category
Documents
-
view
218 -
download
2
Transcript of PROCESS MANAGEMENT: STRUTTURE DATI. Sintesi fin qui Residente Processo 2Processo n Daemon Processo 1...
PROCESS MANAGEMENT: STRUTTURE DATI
Sintesi fin qui
Res
iden
te
Processo 2 Processo n
DaemonDaemon
Processo 1
Non
res
iden
te
Memoria centrale Periferiche
Processi utente
SwitcherSwitcher
System calls Interrupt Handlers I/O drivers
Immagine di un processo
• L’immagine di memoria di un processo è organizzata in tre regioni:
Testo
Dati
StackE’ rientrante, e può essere condiviso fra più processi
• Ogni regione è uno spazio di indirizzamento autonomo
Che cosa genera il compilatore C
#include ...char buffer[1000];
int version=1;
main(int argc, char *argv[]){ int i;
while ......exit (0);
}
int fun(int n){ int j;
if ......
}
DA
TI
INIZIALIZZATI
NONINIZIALIZZATI
STACK
TESTO
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
Res
iden
teN
on r
esid
ente
Memoria centrale Periferiche
SwitcherSwitcher
System calls Interrupt Handlers I/O drivers
Processo 2
Testo
Dati
Stack
Processo n
Testo
Dati
Stack
Processo 1
Testo
Dati
Stack
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
0
2
3
4 …
U-Area
• 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
• ….
• 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
•….
Strutture dati per la gestione dei processi
1
0
2
3
4 …Process Table
U-Area
Testo
Dati
Stack
Processo
Text Table
Strutture dati per la gestione dei processi
1
0
2
3
4 …Process Table
U-Area
Testo
Dati
Stack
Processo
Text Table
Lista dei processi che hanno priorità 0
0
1
2
-1
-2
Ready Q
Pri
ori
tà
Ker
nel
Sintesi fin qui
Processo 2
Testo
Dati
Stack
U-Area
Processo n
Testo
Dati
Stack
U-Area
Processo 1
Testo
Dati
Stack
U-Area
Process Table
Ready queue
SwitcherSwitcher
Interrupt handlersSystem 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 processoIn 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: 0al padre: PID del figlioin 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…
Ker
nel
Creazione di un processo
Processo Padre
Testo
Dati
Stack
U-Area
Process Table
Ready queue
SwitcherSwitcher
Interrupt handlersSystem calls
Processo Figlio
Dati
Stack
U-Area P=0P= 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
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 */ }
Ker
nel
Creazione di un processo
Processo Figlio
Dati
Stack
U-Area
Processo Padre
Testo
Dati
Stack
U-Area
Process Table
Ready queue
SwitcherSwitcher
Interrupt handlersSystem calls
Ker
nel
Exec
Processo Figlio
Dati
Stack
Processo Padre
Testo
Dati
Stack
U-Area
Process Table
Ready queue
SwitcherSwitcher
Interrupt handlersSystem calls
Testo
U-Area
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)
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
Exit: esempio
padre
…
int st;
….
wait ( &st )
…
figlio
…
exit (0)
….
0
0process table entry del figlio
Ker
nel
Exit
Processo Figlio
Dati
Stack
Processo Padre
Testo
Dati
Stack
U-Area
Process Table
Ready queue
SwitcherSwitcher
Interrupt handlersSystem calls
Testo
U-Area
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
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
Running
AsleepReady
attesa evento
evento occorso
quanto di tempo esaurito
schedulazione
ZombieExit
Idlefork
Altri stati di un processo
INIZIALIZZAZIONEDEL 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
Start
1/etc/getty /bin/login
LOGIN SHELL
exec execfork exec
/etc/getty /bin/loginLOGIN SHELL
exec execfork exec
/etc/getty /bin/loginLOGIN SHELL
exec execfork exec
fork exec
swapper
Processo Ø
bootstrap
/etc/init
fork
execdemoni
…….
• crea un processo per ogni terminale attivo e i demoni: è il padre di tutti i processi – è in loop
1
• inizializza le strutture dati del kernel• crea processo 1 (init): fork+exec)
kernel mode user mode
inizializza il terminale
effettua il login
è la shell di login
execfork
cmd
comando
STRUTTURA DELLA SHELL
Shell: interfaccia utente
$file args esecuzione in foreground
<output>
$file args& esecuzione in background
$
Struttura generale della shell
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
$file args<><output>$
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 POSIXSegnale Significato (default)
1. SIGABRT Abortisce un processo (termina con dump)2. SIGALRM Invia un segnale di "sveglia" (termina)3. SIGCHLD Lo stato di un figlio è cambiato (ignora)4. SIGCONT Continua un processo stoppato (continua o ignora)5. SIGFPE Floating Point Error (termina con dump)6. SIGHUP Hangup su un terminale (termina)7. SIGILL Istruzione di macchina illegale (termina con dump)8. SIGINT Premuto il tasto DEL per interrompere il processo (termina)9. SIGKILL Segnale per terminare un processo (non può essere ignorato) (termina)10. SIGPIPE Tentativo di scrivere su una pipe che non ha lettori (termina)11. SIGQUIT L'utente ha usato il tasto di quit del terminale (termina con dump)12. SIGSEGV Riferimento a un indirizzo di memoria non valido (termina con dump)13. SIGSTOP Per stoppare un processo (non può essere ignorato) (stoppa il processo)14. SIGTERM Segnale per terminare un processo (termina)15. SIGTSTP L'utente ha usato il tasto "suspend" del terminale (stoppa il processo)16. SIGTTIN Un processo in background tenta di leggere dal suo terminale di controllo
(stoppa il processo)17. SIGTTOU Un processo in background tenta di scrivere sul su terminale di controllo
(stoppa il processo)18. SIGUSR1 Disponibile per scopi definiti dall'applicazione19. 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ò:
1. Trattarlo mediante una specificata funzione (“handler”)
2. Ignorarlo
3. 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:
1. Il processo che riceve e il processo che invia il segnale devono avere lo stesso owner
2. L’owner del processo che invia il segnale è il superuser
Strutture dati per la gestione dei segnali
1
0
2
3
4 …Process Table
U-Area
Testo
Dati
Stack
Processo
Text Table
1 2 3 4 ..…
un bit per ogni segnale, che viene alzato dalla kill(viene ricordato solo l’ultimo segnale di ogni tipo)
0 1 1 0 000
1 2 3 4 ..…
array di puntatori agli handler definiti dall’utente per ogni segnale (null=default)
