Sistemi Operativi. 7 Gestione dei processi in Unix

Transcript

1 Gestione dei processi in Unix Creazione e terminazione dei processi: fork: crea un nuovo processo duplicando il processo chiamante exec: attiva l esecuzione di un programma memorizzato in un file eseguibile. wait: sospende l esecuzione di un processo in attesa del completamento di un altro processo ad esso legato. exit termina un processo. Sincronizzazione e comunicazione in Unix: Segnali: trasferiscono ad un processo l indicazione che un determinato evento si è verificato. Pipe: struttura dinamica, creata ed usata dal processo che la genera. Fifo: struttura simile alla Pipe, ma statica. Sopravvive ai processi che la usano. Ad ogni segnale è associato un nome simbolico usato dall utente e un numero intero usato dal sistema. La corrispondenza è stabilita nel file signal.h Un processo può specificare una specifica azione da intraprendere all arrivo di un segnale (tramite la system call signal). La signal deve essere chiamata prima che il segnale sia ricevuto, altrimenti, si ha il comportamento di default (terminazione). Unix fornisce altre primitive per la gestione dei segnali: installazione di un allarme: ALARM(sec) (non è bloccante) sospensione in attesa di un qualunque segnale: PAUSE. sospensione temporizzata: SLEEP(sec) invio di segnali ad altri processi: KILL(pid,sig) Pipe: canale di comunicazione unidirezionale: accessibile ad un estremo in lettura ed all altro estremo in scrittura. Gestione Fifo, dimensione fissa (es byte) Sincronizzazione tra processi con pipe: un processo che legge si blocca se la pipe è vuota. un processo che scrive si blocca se la pipe è piena. Sintassi: int retval, fd[2]; retval = pipe(fd); fd[0] identificatore del file aperto in lettura, fd[1] identificatore del file aperto in scrittura. Comunicazione con pipe nella gerarchia di processi: tra processi figli (ereditano il pipe dal padre) tra un processo padre e un processo figlio. Politecnico di Torino Pagina 1 di 8

2 Gestione dei file. Apertura: create e open. L apertura di un file provoca: l allocazione di un elemento nella prima posizione libera dalla tabella dei file aperti del processo. l inserimento di un nuovo record nella tabella dei file aperti di sistema. la copia dell i-node nella tabella dei file attivi (se il file non è già stato aperto da un altro processo). Apertura di file già esistenti: int fd, flags; char *nomefile; fd=open(nomefile,flags); flags esprimono le modalità di accesso: O_RDONLY, O_WRONLY, O_RDWR ecc. definite in fcntl.h. fd = file descriptor. Apertura di nuovi file: fd=creat(nomefile,perm); perm rappresenta i 12 bit di protezione. se un file esiste già viene sovrascritto. Lettura e scrittura di file Accesso attraverso la specifica del file descriptor. Ogni operazione di lettura o scrittura agisce sequenzialmente sul file, a partire dalla posizione corrente del puntatore (I/O pointer). Possibilità di alternare operazioni di lettura e scrittura. Atomicità delle singole operazioni. Read: int fd,n,let; char *buf; let=read(fd,buf,n); buf: area in cui trasferire i byte letti, let: numero di byte effettivamente letti, è previsto un EOF (^D). Write: int fd,n,scritti; char *buf; scritti=write(fd,buf,n); se scritti è < n -> errore Accesso diretto: per spostare l I/O pointer: int fd,offset,origine,dest; dest=lseek(fd,offset,origine); offset = spostamento in byte dall origine, origine: 0 inizio file, 1 posizione corr., 2 fine file. Chiusura file: int fd,rit; rit=close(fd); rit = risultato dell operazione. Politecnico di Torino Pagina 2 di 8

3 Esercizi Esercizio 1 Si scriva un programma C per ambiente Unix in cui due processi, uno padre e l altro figlio, concorrono a realizzare un meccanismo di codifica di stringhe di caratteri. Il processo padre legge da tastiera una stringa di 5 caratteri che possono essere solo lettere minuscole; tale stringa è passata al processo figlio che legge dal file permut.dat le corrispondenti codifiche per i caratteri della stringa. Infine, il figlio stampa su video la stringa codificata. Si assuma che nel file permut.dat vi siano, una per riga (si supponga ci siano 21 righe), corrispondenze di questo tipo: ag bt cv du eo etc. In pratica il carattere a nella stringa originale deve essere sostituito con una g, il carattere b con una t ecc. Si usino il più possibile chiamate di sistema a basso livello (fork, read, write etc). #include <fcntl.h> main() int pid, canale[2],status,fp,ind; char buf[5],lettere[26][2]; pipe(canale); pid=fork(); if(pid > 0) /*CODICE PADRE*/ close(canale[0]); read(0,buf,5); write(canale[1],buf,5); wait(&status); /*CODICE FIGLIO*/ close(canale[1]); fp=open("permut.dat",o_rdonly); for(ind=0;ind<26;ind++) read(fp,&lettere[ind][0],3); close(fp); Politecnico di Torino Pagina 3 di 8

4 read(canale[0],buf,5); for(ind=0;ind<5;ind++) buf[ind]=lettere[(buf[ind]-'a')][1]; write(1,buf,5); Esercizio 2 Si realizzi un programma C per ambiente Unix in cui due processi concorrono a determinare il fattoriale di due numeri minori a 10 introdotti da tastiera. Il processo padre legge i due numeri da tastiera e passa il primo al processo figlio il quale calcola il fattoriale. Il figlio restituisce il risultato al padre che gli passa il secondo numero; mentre il figlio calcola il secondo fattoriale il padre scrive il primo risultato nel file fattorial.txt creato con permessi Quando il figlio ha terminato anche il secondo calcolo, passa il risultato al padre che lo scrive sempre nel file fattorial.txt. #include <fcntl.h> #define PERM 0666 main() int pid, canale[2], canale2[2], status,fp,valore,fatt; char num1[3],num2[3]; pipe(canale); pipe(canale2); pid=fork(); if(pid > 0) close(canale[0]); close(canale2[1]); fp=creat("fattorial.txt",perm); read(0,num1,2); read(0,num2,2); write(canale[1],num1,3); read(canale2[0],num1,3); write(fp,num1,3); write(canale[1],num2,3); read(canale2[0],num2,3); write(fp,num2,3); close(fp); wait(&status); Politecnico di Torino Pagina 4 di 8

5 close(canale[1]); close(canale2[0]); read(canale[0],num1,3); sscanf(num1,"%d",&valore); fatt=1; while(valore > 1) fatt *= valore; valore --; sprintf(num1,"%d\n",fatt); write(canale2[1],num1,3); read(canale[0],num2,3); sscanf(num2,"%d",&valore); fatt=1; while(valore > 1) fatt *= valore; valore --; sprintf(num2,"%d\n",fatt); write(canale2[1],num2,3); Esercizio 3 Scrivere un programma in linguaggio C per ambiente Unix che generi due processi uno padre e uno figlio. Il processo padre legge da tastiera una stringa lunga al massimo 10 caratteri, dopodiché la passa al processo figlio che converte maiuscole in minuscole e viceversa (simboli diversi da lettere compresi nella stringa devono rimanere inalterati). Dopo la conversione, il processo figlio crea un file result.dat con permessi 766 e vi scrive la stringa convertita. Per realizzare il programma si utilizzino solamente le system call a basso livello (read, write, execl etc.). #include <fcntl.h> #define PERM 0766 main() char buf[10]; int pid, canale[2],status; int i, scarto, filedes, car; pipe(canale); pid = fork(); Politecnico di Torino Pagina 5 di 8

6 if(pid > 0) close(canale[0]); read(0,buf,10); write(canale[1],buf,10); wait(&status); close(canale[1]); read(canale[0],buf,10); car=strlen(buf); for(i=0;i<car;i++) if((buf[i] >= 'A') && (buf[i] <= 'Z')) buf[i]=tolower(buf[i]); if ((buf[i] >= 'a') && (buf[i]<='z')) buf[i]=toupper(buf[i]); filedes = creat("result.dat",perm); write(filedes,buf,car); write(1,buf,car); close(filedes); Esercizio 4 Si realizzi un programma C per ambiente Unix tale che vengano generati due processi: uno padre e uno figlio. Padre e figlio comunicano mediante pipe. Il padre genera 10 valori interi casuali minori di 100 e li passa al figlio che a sua volta li scrive nel file random.dat (creato con permessi 0640), uno per riga. Si faccia, il più possibile, uso delle system call di basso livello (read, write, pipe etc.). #include <fcntl.h> #define PERM 0640 main() int pid,pip[2],fd,valore,status,i; char buf[3]; pipe(pip); pid = fork(); if(pid==0) Politecnico di Torino Pagina 6 di 8

7 fd = creat("random.dat",perm); close(pip[1]); for(i=0;i<10;i++) read(pip[0],buf,3); write(fd,buf,3); close(fd); close(pip[0]); for(i=0;i<10;i++) valore = rand()%100; sprintf(buf,"%d\n",valore); printf("%d\n",valore); write(pip[1],buf,3); wait(&status); return; Esercizio 5 Si scriva un programma C per ambiente Unix tale che venga emulata una struttura di processi organizzati master slave; si supponga di dover gestire 3 slave. Ogni slave deve mandare un segnale di tipo SIGUSR1 al master; tale messaggio può essere mandato solo previa autorizzazione del master mediante un segnale di tipo SIGUSR2. Quando il master ha ricevuto tutti e tre i messaggi, uccide gli slave con un messaggio di tipo SIGKILL. #include <signal.h> void azione(void) printf("ricevuto segnale dal padre\n"); void azione2(void) printf("ricevuto segnale da un figlio\n"); void main() int pid1, pid2, pid3; signal(sigusr2,azione); pid1=fork(); if(pid1==0) Politecnico di Torino Pagina 7 di 8

8 kill(getppid(),sigusr1); pid2=fork(); if(pid2==0) kill(getppid(),sigusr1); pid3=fork(); if(pid3==0) kill(getppid(),sigusr1); signal(sigusr1,azione2); kill(pid1,sigusr2); signal(sigusr1,azione2); kill(pid2,sigusr2); signal(sigusr1,azione2); kill(pid3,sigusr2); kill(pid1,sigkill); kill(pid2,sigkill); kill(pid3,sigkill); Politecnico di Torino Pagina 8 di 8