LAB4 System call per gestione processi - homes.di.unimi.ithomes.di.unimi.it/sisop/lucidi/Lab4_SyscallProc_31-03-2003.pdf · Threads in Win 2000 •thread puo’ accedere a tutti gli

2002/2003 Pagani - Trentini Slide 1

Laboratorio di Sistemi Operativi

LAB4

System call per gestione processi


Agenda

• Linux– fork; exec; exit; wait; waitpid; nice (cenni);

gestione cloni in Linux

• Windows– CreateProcess; CreateThread; ExitProcess;

ExitThread; SetPriorityClass (cenni);SetThreadPriority (cenni)


Segnalazioni

• The Unix Programming FAQ (su web)

• The Art of Unix Programming– Eric Steven Raymond

– (beta scaricabile)

• Man Pages via web– http://www.cs.princeton.edu/cgi-

bin/man2html?PAGENAME


I problemi del multithreading

• Esempio Java...

0..* 1rompiballe

_vti_cnf

ThreadClient

-object:ProtectedObject

+Client+pause:void+run:void

ProtectedObject

-integers:int[]-sb:StringBuffer-pauses:boolean-clients:Vector

+ProtectedObject+longMethodThatModifiesObject:void+sum:int+toString:String+add:void+pause:void+pause:void+main:void


- Unix -


Booting Unix

cp

swapper

1) progr bootstrap esegueprocedura in partizione boote carica kernel

2) kernel crea ambiente perprocesso 0 e lo esegue (proc.livello kernel in modo kernel)

3) processo 0 crea processo 1 (proc. livello user in modo kernel)


Processi in Unix

• processi identificati da PID (PPID, PGID)

• swapper: esegue algoritmo di swap in/out

• init: progenitore di tutti i processi nel sistema

• proc. utente: associati con un utente ad un terminale

• proc. kernel: erogano servizi a livello kernel, eseguono inkernel mode

• proc. daemon: esistono sempre, eseguono funzioni diamministrazione in user mode– es: printer daemon, mail daemon, cron per batch


Gestione processi

• S.O. multi-utente time-sharing– scheduling round-robin con multi-level feedback

– priorita' positiva per proc. user, negativa per proc. kernel

– proc. si sospende quando: termina quanto, attende un evento, esisteproc. con priorita' "maggiore"

– S.O. mantiene info su processi per scheduling

• contesto kernel: u-area + (entry) process table

• u-area: kernel vede solo quella del proc. running

• process table: globale, ha una entry per ogni processoattivo nel sistema


Gestione processi

• u-area– puntatore a entry

proc.table– real/effective UID– working directory– file descriptor table– campo errori syscall– valore ritorno syscall– array routine gestione

signal– valori registri

• process table entry– indirizzo u-area– stato del processo– contesto utente– real/effective UID e GID– PID, PPID– descrittore evento per cui

proc. e' sleeping– parametri scheduling– array flag signal ricevuti

ma non gestiti


Unix scheduler

priorita' = base + nice + CPU_usage

per non penalizzare troppo proc. CPU-boundCPU-usage e'decrementato con iltempo

base dipende da ultimoevento atteso (favorisceI/O-bound)

code multiple, una per ogni livello di priorita'


Process scheduling

• algoritmo a due livelli:– low: scelta proc. da eseguire tra quelli ready in memoria

– high: sposta processi tra memoria e disco

• proc. in modo kernel non fanno context switch

• quando si verifica evento vengono svegliati tutti i procs inattesa per esso

• kernel manda in exec il proc ready da piu' tempo tra quellicon "maggiore" priorita'

• Linux: scheduling basato su thread, classificati in– real-time FIFO, real-time round-robin, time-sharing


int nice(int priority_change)

• aggiunge priority_change alla priorita' del proc.– incremento tra 0 e 39

– torna nuova priorita' - 20, o -1 se errore

– usa libreria unistd.h

• proc. puo' modificare solo la propria priorita'

• solo kernel puo' "aumentare" priorita' di un processo– es. quando accede a regione critica, esegue routine gestione

interrupt o syscall

• proc. in background/batch: nice con max. valore– comando (re)nice di shell


System Calls for Process Management

s is an error code; pid is a process IDresidual is the remaining time from the previous alarm


pid_t fork(void)

• genera figlio proc corrente, che ne eredita:

• figlio ha proprio PID, e PPID il PID del padre• figlio non ha signal pendenti• torna 0 al figlio e PID figlio al padre• usa unistd.h

UID / EUID GID / EGID PGID

ambiente descrittori file gestione segnali

valore nice working dir limite taglia file


fork• memoria: si incrementa #riferimenti a region

– set bit copy-on-write in page table

– se uno dei due proc. modifica la pagina, a quel puntokernel esegue replicazione

• figlio dovrebbe chiudere descrittori file inutili


void exit (int status)

• richiamata automaticamente a terminazione processo– se termina per errore, status ne ricorda la causa

• kernel disabilita i signal, chiude i file aperti, libera region

• se e' proc di ctrl di terminale: inviato segnale diterminazione a tutti i processi in foreground attivi nelterminale

• kernel salva info sulla terminazione in entry process table

• kernel manda notifica terminazione a proc genitore

• eventuali procs figli diventano figli di init


ESERCIZIO

• scrivere un programma C t.c. il processo crea unfiglio. Nel padre stampa il PID del figlio, attende10 sec. e poi termina. Nel figlio stampa che e' ilfiglio, attende 15 secondi e poi termina. Con ps -efmonitorare l'esistenza dei due processi.


int execv (const char *path, char * const argv[])

• fork: figlio ha stesso contesto (e codice) del padre

• exec modifica contesto cosi' che figlio esegua progr. nelfile path con gli argomenti elencati in argv

• esistono varianti– execve specifica anche ambiente

– execvp prende pointer a stringa contenente file eseguibile

– execl specifica lista argomenti

– execle specifica anche ambiente

– execlp prende pointer a stringa contenente file eseguibile

– tutte fanno riferimento a syscall exec


exec• contesto padre non piu'

accessibile

• file descriptor tablerimane invariata

• PID, PPID invariati

• UID, GID invariati

• EUID, EGID dipendonoda file eseguito

• pagine nuovo programmacaricate quando occorre

#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>main(){ int child_pid = 0; child_pid = fork(); sleep(15); if (child_pid != 0) printf("P: ID figlio %d

\n",child_pid); else execl("/bin/date","date",0);exit(0);}


Threads in Unix

• principali syscall definite da standard Posix

• non specificato se devono essere implementati in spaziokernel o utente

– es. problema: se in user space, thread bloccato bloccaanche tutti gli altri thread dello stesso processo

– def. syscall t.c. sono implementabili in entrambi i modi• se in kernel space: sono syscall

• se in user space: sono funzioni di libreria

• synchro usando mutex (~ semafori binari) o variabilicondizione


Threads in POSIX


Threads e syscall

• comportamento S.O. deve restare consistente– fork: bisogna ri-generare tutti i thread del processo?– I/O: se thread bloccato nel proc. padre in attesa input,

quale deve essere lo stato del thread nel figlio?• se non bloccato, cosa deve fare?

– condivisione file: se un thread nel padre e' bloccato sulettura da file, e un altro nel figlio chiude il file?

– errori: se errore che dovrebbe causare terminazionesingle-threaded process si verifica in un thread?

• implementazioni diverse possono avere differenticomportamenti


Linux threads (cenni)• Linux supporta thread in kernel space• thread creato con clone() specificando:

– da quale funzione deve iniziare esecuzione– gli argomenti passati alla funzione– il puntatore al proprio stack privato– flag che ne determinano le caratteristiche di

condivisione risorse (non supportati da altri Unix)


- Windows -


Jobs, Processes ...

•quote job: max.#procs , CPU time disponibile per proc e globale, max. uso memoria per proc. e globale•proc: 4GB memoria; negli ultimi 2 GB c’e’ sistema operativo

•S.O. non associa stato a processi; li identifica con ID•thread: entita’ schedulate (hanno stato associato)

•kernel mantiene: thread ID, user e kernel stack, access token, area memoria per variabili locali


Threads in Win 2000

• thread puo’ accedere a tutti gli oggetti del processo• kernel ha daemon threads per gestione sistema• scheduling a livello thread: kernel non ricorda a quale

processo un thread appartiene• fiber: thread “leggero” schedulato a livello user

– quando fiber si blocca, e’ schedulato un altro fiber dellostesso thread

• proc contiene almeno un thread, che contiene almeno unfiber


Processes and Threads


Job, Process, Thread & Fiber Mgmt. API Calls


API: CreateProcessBOOL CreateProcess( LPCTSTR lpApplicationName, // pointer to name of executable module LPTSTR lpCommandLine, // pointer to command line string LPSECURITY_ATTRIBUTES lpProcessAttributes, // pointer to process security attributes LPSECURITY_ATTRIBUTES lpThreadAttributes, // pointer to thread security attributes BOOL bInheritHandles, // flag eredita’ handles del creatore DWORD dwCreationFlags, // creation flags (priority, debugging, consoles) LPVOID lpEnvironment, // pointer to new environment block LPCTSTR lpCurrentDirectory, // pointer to current directory name LPSTARTUPINFO lpStartupInfo, // pointer to STARTUPINFO LPPROCESS_INFORMATION lpProcessInformation // ptr to PROCESS_INFORMATION );

• diverso approccio da UNIX (fork e’ senza parametri) ...– sicurezza: http://www.insecure.org/sploits/NT.syscalls.vulnerability.html

• gerarchia: non esplicita, ma def. da “chi” possiede handle


FunzionamentoCreateProcess

Per dettagli:http://www.microsoft.com/mspress/books/sampchap/4354a.asp

ctrl tipo file, NTCreateSession per mapping file in memoria <user mode>

NTCreateProcess: creato PCB <kernel mode>

NTCreateThread: creato thread suspended e suoi due stack


CreateThread• 6 parametri

– descrittore permessi per security; taglia iniziale stack; indirizzodi partenza; stato iniziale del thread; thread ID; parametridefiniti dall’utente

• thread possono comunicare via– pipe: byte o messaggi

– named pipe: anche per IPC in rete

– mailslot: anche per broadcast, inaffidabili

– socket, shared memory

• synchro: semafori, mutex, regioni critiche, eventi


Esempio di uso#include <iostream.h>#include <windows.h>

void main(void){ STARTUPINFO startupInfo; PROCESS_INFORMATION procInfo; // contiene handle a processo creato BOOL success;

GetStartupInfo(&startupInfo); success = CreateProcess (NULL, "notepad", NULL, NULL, FALSE, CREATE_NEW_CONSOLE,

NULL, NULL, &startupInfo, &procInfo);

if (! success)cerr << "Couldn't create process: " << GetLastError() << endl;

else { WaitForSingleObject (procInfo.hProcess, INFINITE); cout << “Notepad Terminated” << endl; }}


Scheduling• Non esiste un thread scheduler, ma e’ il thread

attivo che va ad eseguire il codice in modalita’kernel, quando necessario:– si blocca su un Dispatcher Object (semaforo, I/O, event,

Process,...)• salva proprio contesto, esegue codice scheduler per scegliere

prossimo, carica contesto nuovo thread

– fa una signal su un Object• ctrl che thread risvegliato non abbia priorita’ maggiore della

propria

– esaurisce il suo quanto• esegue scheduler: potrebbe essere riscelto lui


gestiti dal kernel...

Possibilidispatcher object

Win2K fully preemptive:thread puo’ dover sospendereesecuzione in qualsiasimomento perche’ diventaready thread con priorita’maggore


Stati dei thread in WinNT

next thread to execute:per sistemi multiprocessorcon processori preferiti


Scheduling (2)

• Ci sono altri due casi cui il codice dello schedulerdeve essere eseguito:– fine di una operazione di I/O

– scatto di un timer

• lo scheduler non viene eseguito pero’ durante lagestione dell’interrupt ma tramite una DPC...– garantisce che dispatching non avvenga in un momento

critico


Dispatch (Deferred) Delayed Call


Scheduling

Windows 2000 supports 32 priorities for threads


Win32 priorities -> Win2000

SetPriorityClass per priorita’ processoSetThreadPriority per priorita’ threadpriorita’ = valore base + valore corrente


Vista alternativa dellepriorita`

le classi di priorita’ sonoparzialmente sovrapposte


Priority Boosts

• Esistono quattro casi in cui viene incrementatoautomaticamente il livello di priorita`– Quando viene completata una operazione di I/O (entita’

incremento dipende da tipo periferica)– Dopo avere atteso su un evento o semaforo (entita’ dipende se e’ il

processo che e’ in finestra foreground )– Quando un GUI thread si sveglia per qualche attivita’– Quando un processo pronto non viene schedulato da parecchio

tempo (anti-starvation: portata a 15 per 2 quanti…)

• realtime thread non sono soggetti a boost– sono solo i thread di sistema (priorita’ 16 – 31)

• non si puo’ superare 15 con il boost


Boost e decay delle priorita’


Priority Inversion

il thread a priorita` 8 blocca indirettamente quello a priorita` 12...

Produttore

Consumatore


Il quanto di tempo

• clock ogni 10 msec. per monoprocessor e ogni 15msec. per multiprocessor

• statico– 6 per Win2000 Professional– 36 per Win2000 Server

• ogni clock viene decrementato di 3– viene decrementato di 1 ogni volta che esce da una wait...

• dinamico– i thread in foreground hanno un boost nel quanto di

tempo...


Casi in cui non si resetta il quanto• Quando ci sospende su un Object

– a meno di non essere un thread a priorita` maggiore di 14

• Quando si viene preempted– in questo caso si viene lasciati in cima alla coda di thread a

pari priorita`


Emulazione MS-DOS

• ntvdm per emulazione ambiente DOS(Virtual Dos Machine)– istruisce Win2K di rimandargli le syscall

invocate dal programma

– cerca di capire quale fosse lo scopo e emula

– vecchi programmi accedevano direttamente ahw: e’ generato un trap a ntvdm che invocaappropriata API o uccide programma


Win2K: processo boot

• caricamento master boot record• lettura settore boot a indirizzo indicato da MBR• esecuzione file Ntldr: configurazione in accordo a info

contenute in Boot.ini– caricamento hal.dll, ntoskrnl.exe, driver indicati in registry

• esecuzione ntoskrnl.exe: inizializzazione sistema– call a componenti executive per loro inizializzazione

• creazione 1o processo: session mngr (smss.exe)– start environment subsystem e login daemon– creazione servizi, user daemons, authentication mngr

• dopo login: load profilo utente da registry

Documents

LAB4 System call per gestione processi - homes.di.unimi.ithomes.di.unimi.it/sisop/lucidi/Lab4_SyscallProc_31-03-2003.pdf · Threads in Win 2000 •thread puo’ accedere a tutti gli