Corso di Sistemi operativi - prima parte

GERARCHIA DEI PROCESSI

Il primo processo ad essere attivato (dal processo swapper) è init con PID=1, lui dovrà

gestire l’avvio di tutti i processi necessari a mantenere attivo il SO.

Questo processo crea diversi processi figli, che a loro volta possono crearne altri.

Si crea così una struttura ad albero

La maggior parte dei processi rimangono sempre attivi: partono all’inizio e vengono

deallocati quando si spegne la macchina.

L’avvio dei processi da parte del processo init avviene tramite un file chiamato

/etc/inittab.

init Init legge questo file contenente le direttive per l’avvio degli altri processi

Si occupa di attivare i terminali e iniziare la procedura di login, tali terminali sono

getty identificati con dei codici: tty1,tty2 e così via.

All’avvio di LINUX: Quando l’utente digita la password il

Per ogni terminale, init

init legge /etc/inittab processo getty lancia il processo login

creare una istanza di e gli passa le credenziali.

getty che stampa il

messaggio di login Il processo login verifica che l’username

Se la password è sbagliato fa visualizzare il esista e che la password sia corretta

messaggio di errore, se la password è (controlla nel file password contenuto

corretta lancia il processo Shell nella cartella etc)

Una volta avviata la SHell, uno de programmi principali che l’utente può eseguire è Terminal:

Permette di utilizzare la SHell tramite comandi da tastiera.

Ad ogni istanza del programma Terminal viene associato un identificativo detto pts, pseudo

terminal slave

PROCESSI SESSION LEADER

In alcuni casi, terminando un processo padre vuol dire terminare i relativi processi figli,

tuttavia, in Linux non è automatico questo meccanismo.

Di fatti, in Linux, se un processo è tale per cui una volta terminato terminano pure i figli, allora il

processo viene detto session leader.

Terminal è un processo session leader.

ESECUZIONE IN FOREGROUND

I comandi di Shell standard permettono di eseguire processi in maniera sequenziale, tali

processi, quindi, sono eseguiti in foreground.

ESECUZIONE IN BACKGROUND

In Linux, è possibile utilizzare il carattere & per poter eseguire processi in parallelo, la cui

esecuzione è detta in background: il processo viene eseguito in maniera concorrente rispetto

la SHell e gli altri processi in background.

Questo fa sì che si liberi il terminale per altri lavori.

COMANDI SHELL PER PROCESSI

Pstree Mostra i processi in esecuzione con l’indicazione dell’utente (-u) e del PID (-p)

Ps (Senza opzioni) Mostra i processi associati al terminare corrente

Opzioni:

l= modalità estesa;

a=mostra i processi per tutti gli utenti (relativi ad un terminale)

U=da sola, mostra i processi dell’utente da qualunque terminale

U=insieme ad altre opzioni mostra anche l’utente possessore de processo

X=mostra anche i processi non lanciati da terminale

r=mostra solo i processi in running

t=mostra solo i processi da terminale corrente

Top come ps ma run-time Ps fornisce diverse informazioni in dipendenza

delle opzioni

STATO DI UN PROCESSO

Lettera Stato.

pronto o in esecuzione

R In attesa. Viene interrotta

S all’arrivo di un segnale

In attesa. Può essere risvegliato

solo da ciò che sta attendendo

D (hardware, disk I/O)

In attesa. Sospeso da segnale di STOP

T (attesa di un segnale per il riavvio)

Z Zombie

FOREGROUND

S Session leader

API PER LA GESTIONE DEI PROCESSI

IDENTIFICAZIONE DI UN PROCESSO

All’identificatore di un processo (PID), sono associati altri Identificatori:

- Il processo che l’ha creato PPID;

- identificatore dell’utente e del gruppo, UID e GUID;

Se un processo vuole conoscere il proprio pid utilizza l’API getpid();

Se un processo vuole sapere l’identificatore del processo padre utilizza l’API getppid();

Se un processo vuole sapere qual è il suo utente o gruppo di appartenenza utilizza le API getuid();

e getgid();

Tutte queste API ritornando gli identificatori richiesti dal processo chiamante e i tipi dei valori

di ritorno sono pid_t, uid_t e gid_t che si possono trattare come int.

CREAZIONE DI UN PROCESSO

Per creare un nuovo processo si utilizza l’API fork(); attraverso cui un processo può chiedere al

Kernel di creare un processo figlio.

Quando il Kernel crea un processo figlio su richiesta del padre:

- il processo padre mantiene il suo PID, così come conserva il suo PCB;

-il processo figlio acquisisce un nuovo PID, e il Kernel crea un PCB relativo.

- il codice del processo figlio è identico a quello del processo padre: i due processi continuano la

loro esecuzione a partire dall’istruzione successiva alla fork(), i due programmi continuano in

maniera indipendente essendo due istanze diverse dopo la fork();

La fork() è una funzione senza parametri il cui tipo del valore di ritorno è pid_t; può tornare

-in caso di errore: -1

-in caso di successo:

Dato che il codice del padre viene duplicato,la fork() compare in entrambi i processi, quindi

Ritorna un valore diverso a seconda se si trova nel codice del figlio o in quello del padre.

- La fork() che si trova nel padre ritorna il PID del figlio che ha creato;

- la fork() che si trova nel figlio ritorna per definizione il valore 0;

I processi padre e figlio condividono:

- stesso codice;

- user ID (UID), group ID (GID);

- directory di lavoro

-permessi di lettura e scrittura

I processi padre e figlio NON CONDIVIDONO:

-PCB;

-variabili statiche;

-variabili locali;

Gestione dei dati

È chiaro che le variabili locali e statiche vengono replicate per ogni processo figlio quindi

nell’istante della clonazione il figlio eredita le variabili che inizialmente hanno gli stessi valori del

processo padre ma durante l’esecuzione le variabili assumono valori diverse, perchè i due

processi lavorano in maniera indipendente

GESTIONE DEI FILE

Riprendiamo la gestione dei file in Linux, nel contesto in cui un processo padre crea un

processo figlio per il quale, quindi, il Kernel predispone un nuovo PCB al cui interno si trova la

tabella di descrittori di file.

Padre e figlio hanno PCB diversi e quindi tabella di descrittori diverse.

Quando un processo richiede un’operazione su un file, il SO esegue il comando e ritorna il

descrittore di file per quel processo.

Ad ogni processo viene associata una tabella dei file aperti dal processo stesso costituita

dall’elenco dei suoi descrittori.

Ad ogni descrittore di file corrisponde un file pointer, puntatore alla posizione corrente del

relativo file.

Ad ogni file che viene aperto esiste una struttura caricata in memoria detta i-node che

contiene informazioni riguardanti il file.

Esiste una tabella che contiene tutti gli i-node di tutti i file aperti detta tabella degli i-node

Per la gestione dei file aperti da più processi il Kernel memorizza una tabella di file aperti da

tutti i processi, questa tabella ha un elemento per ogni processo attivo quindi avrà un numero

di elementi legato al numero di processi.

PROCESSO

SINGOLO Processo richiede operazione su un file al SO

So ritorna il descrittore del file per quel

°

Descrittore processo

IO Ad ogni processo viene associata una tabella

dei

Tabella "

aperti

file 12 di file aperti dal processo, contenente i

dal : descrittori di tali file

processo .

% Ad ogni descrittore di file corrisponde un file

pointer che punta alla posizione corrente nel file

Più processi possono aprire lo stesso file: avranno un descrittore diverso associato allo

stesso file.

Bisogna però garantire che ogni processo abbia un file pointer diverso altrimenti un

processo potrebbe modificare il file pointer e un altro processo è costretto a subire

questa modifica.

Quindi ogni processo che tratta lo stesso file deve avere un proprio file pointer e che

quindi possa scorrere il file a suo piacere senza interferenze da altri processi.

Come? I-node

In linux per ogni file si carica in memoria una struttura detta i-node che contiene

svariate informazioni: modalità di accesso, appartenenza, dimensione, tempo di creazione

o modifica e gli indirizzi utili per accedere al file fisico.

Il Kernel dunque si memorizza una tabella che contiene tutti gli i-node di tutti i file aperti detta

Tabella degli i-node, per ogni file aperto c’è associato un i-node

il Kernel memorizza una tabella di file aperti da tutti i processi, questa tabella ha un elemento

per ogni processo attivo quindi avrà un numero di elementi legato al numero di processi.

PIÙ PROCESSI INDIPENDENTI Due processi A e B vogliono usare lo stesso file:

Ogni processo ha il proprio PCB che contiene la

Descrittore propria tabella dei file aperti.

.

IO File pointer

dei

Tabella File pointer

" Allo stesso file, linux ha assegnato descrittore 12

Indirizzo ai

aperti

file 12 blocchi

fisici del file per A e descrittore 10 per B.

dal

processo 14 .

A 15 Al processo A con descrittore del file 12 è associato

un elemento della tabella dei file aperti da tutti i

processi a cui è associato il suo file pointer sul file.

Descrittore Tabella degli

Tabella dei i-node Il processo B con descrittore dello stesso file 10 ha

file aperti

da tutti i

: processi associato un altro elemento della tabella dei file

dei

Tabella aperti, a cui sarà associato il suo file pointer sul file.

aperti

file 12 Se un processo modifica un file modificherà il proprio file pointer, quello dell’altro

dal :

processo processo non viene modificato

15

B Entrambi gli elementi della tabella dei file aperti da tutti processi, dato che si

16 riferiscono allo stesso file, puntano allo stesso i-node: il file pointer è diverso, ma il

file, quindi anche l’indirizzo fisico è lo stesso.

PROCESSI IMPARENTATI

Nel caso di processi padre-figlio, per ogni processo figlio viene creato un nuovo PCB.

La tabella dei descrittori di file contenuta nel PCB del processo padre viene duplicata in ogni

PCB dei processi figlio: le tabelle risultano tutte identiche inizialmente, ovvero al momento della

creazione del singolo figlio.

Di conseguenza, i file aperti dal padre risultano aperti anche dal figlio e presentano lo stesso

descrittore. a causa di questa duplicazione, il processo

padre e il processo figlio puntano allo stesso

Descrittori elemento della tabella dei file aperti da tutti i

'

IO processi e, di conseguenza, avranno lo stesso

•

File pointer

dei

Tabella " file pointer.

aperti

file Indirizzo ai

12 blocchi Le operazioni su uno stesso file condotte da

fisici del file

dal processi imparentati modificano