1 System Call che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2.

Slides:



Advertisements
Presentazioni simili
INFORMATICA Altre Istruzioni di I/O
Advertisements

PROCESS MANAGEMENT: STRUTTURE DATI
Shell: variabili di sistema PATH HOME USER PWD SHELL HOSTNAME HOSTTYPE Per visualizzare il valore di tutte le variabili dambiente si usa il comando set.
Programmazione concorrente
MATLAB.
MATLAB. Scopo della lezione Programmare in Matlab Funzioni Cicli Operatori relazionali Esercizi vari.
SC che operano su processi
1 Reti di Calcolatori Esercitazione 1 Implementazione di un superserver Unix di rete Vedi: W.R. Stevens, Unix Network Programming, Prentice Hall Copyright.
Shell Scripting. Shell e comandi La shell e' un programma che interpreta i comandi dell'utente. I comandi possono essere dati da terminale, oppure contenuti.
I segnali.
1 Directory Il formato delle directory varia nei vari FS utilizzati in ambito Unix Quando una directory viene aperta viene restituito un puntatore a un.
1 System Call per Comunicazione tra Processi Pipe.
Mappare file in memoria
SC che operano su file (1)
La ricorsione Simulazione. Il Main /* Programma che usa una funzione ricorsiva*/ #include #define MAX_N 8 main() int valore, dato; printf(Introduci n:
Caratteri e stringhe di caratteri
Argomenti dalla linea dei comandi Gli argomenti possono essere passati a qualsiasi funzione di un programma, compresa la main(), direttamente dalla linea.
Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di programmazione a.a. 2009/2010 Prof.ssa Chiara Petrioli.
DIPARTIMENTO DI ELETTRONICA E INFORMAZIONE File Marco D. Santambrogio – Ver. aggiornata al 9 Maggio 2012.
Informatica 2. Concetti fondamentali di programmazione Programmare vuol dire scrivere un algoritmo in un linguaggio che faccia funzionare un calcolatore.
Laboratorio di Linguaggi lezione VIII Marco Tarini Università dellInsubria Facoltà di Scienze Matematiche, Fisiche e Naturali di Varese Corso di Laurea.
Laboratorio di Linguaggi note sull'uso dell' IDE DevC++ Marco Tarini Università dellInsubria Facoltà di Scienze Matematiche, Fisiche e Naturali di Varese.
Processi: Sistemi Operativi I
Threads: Sistemi Operativi I Corso di Laurea in Ingegneria Informatica
I Thread.
memoria gestita staticamente:
A.A. 2010/2011Ambienti di Programmazione per il Software di Base1 (Es. – 6) Ambienti di Programmazione per il Software di Base Le Stringhe in C Input.
1 LINUX: struttura generale The layers of a UNIX system. User Interface.
Esercizi Puntatori, struct con campi puntatore, puntatori a struct, rapporto tra array e puntatori. FUNZIONI Passaggio di parametri per indirizzo, passaggio.
I File.
Sistemi Operativi - Introduzione 1 Il sistema operativo UNIX Dettagli e comandi avanzati Niccolò Battezzati Politecnico di Torino Dip. Automatica e Informatica.
Sistemi Operativi - Introduzione 1 Il sistema operativo UNIX Shell: uso avanzato e script Niccolò Battezzati Politecnico di Torino Dip. Automatica e Informatica.
Sistemi Operativi - Shell 1 Elementi di programmazione concorrente Niccolo` Battezzati Politecnico di Torino Dip. Automatica e Informatica.
Modulo 13: System call relative al File System
GESTIONE DEI FILE Per poter mantenere disponibili i dati tra le diverse esecuzioni di un programma (persi-stenza dei dati) è necessario poterli archi-viare.
Sistemi Operativi – La shell Salvatore Campagna Politecnico di Torino Dipartimento di Automatica.
Creazione progetto in C++/DEV
1 Scheduling in Windows 2000 Un thread entra in modalità kernel e chiama lo scheduler quando: Si blocca su un oggetto di sincronizzazione (semaforo, mutex,
Prof.ssa Chiara Petrioli -- Fondamenti di programmazione, a.a. 2009/2010 Corso di Fondamenti di programmazione a.a. 2009/2010 Prof.ssa Chiara Petrioli.
1 Gestione dei File. 2 Perché i file? Sono strutture dati persistenti Sono solitamente memorizzati sui dischi –Si usano dall'interno dei programmi Realizzano.
BIOINFO3 - Lezione 261 ESERCIZIO Esercizio. Leggere delle sequenze di DNA (una per riga, a partire da inizio riga) e stampare solo le sequenze lunghe più
BIOINFO3 - Lezione 221 Listruzione IF-ELSE prevede un secondo blocco di istruzioni da eseguire in alternativa al primo nel caso la condizione sia falsa.
Costruzione di una semplice Agenda telefonica Elettronica Esercizio sull'uso delle principali system call Unix.
1 I segnali. 2 Prima un po’ di teoria…... 3 Stati dei processi in UNIX Idle Sleeping Zombified Runnable Running Fork iniziata waitpid Fork terminata.
JAVA Per iniziare. Verificare installazione javac –version java –version Cercare i files e sistemare eventualmente il path.
Prima di iniziare… Durata attività: due lezioni frontali + una lezione laboratorio + compiti per casa Prerequisiti: elementi base architettura dei calcolatori.
T. MottaGenerazione e terminazione processi1 Creazione e terminazione dei processi Tommaso Motta
Prof.ssa Chiara Petrioli -- corso di programmazione 1, a.a. 2006/2007 Corso di Programmazione 1 a.a.2006/2007 Prof.ssa Chiara Petrioli Corso di Laurea.
Esercitazione su Vector. Permette di definire collezioni di dati generiche, che sono in grado di memorizzare elementi di ogni sottotipo di Object Definito.
Programmazione Web PHP e MySQL 1. 2Programmazione Web - PHP e MySQL Esempio: un blog.
1 SC che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2.
1 Chiamate di sistema Introduzione Errori : perror() Chiamate che lavorano su file.
Programmazione di sistema e gestione dei processi in C.
Ancora sulla shell. Shell e comandi La shell e' un programma che interpreta i comandi dell'utente. I comandi possono essere dati da terminale, oppure.
Il linguaggio C Puntatori e dintorni.
1 SC per IPC Pipe. 2 Pipe : file speciali utilizzati per connettere due processi con un canale di comunicazione Se B cerca di leggere da una pipe vuota.
Gestione dei segnali I segnali sono interrupt software.I segnali –interrompono i processi qualunque cosa stiano essi facendo al momento della generazione.
I segnali.
1.1 Il concetto di processo Un sistema operativo può eseguire una grande varietà di attività diverse:  sistemi batch – jobs;  sistemi time-shared – programmi.
1 Reti di Calcolatori Esercitazione 1 Implementazione di un superserver Unix di rete Vedi: W.R. Stevens, Unix Network Programming, Prentice Hall Copyright.
1 Processi e Thread Processi Thread Meccanismi di comunicazione fra processi (IPC) Problemi classici di IPC Scheduling Processi e thread in Unix Processi.
1 Processi e Thread Processi e thread in Unix. 2 UNIX/Linux Molte versioni di UNIX –trattiamo le caratteristiche più comuni) Ci riferiamo allo standard.
1 System Call che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2.
Nicola Gessa In questa sezione Come funziona la gestione dei processi in UNIX e quali interfacce UNIX fornisce per poter operare con i processi Esempi.
1 Laboratorio di Programmazione di Sistema - C Susanna Pelagatti Ricevimento: Me ,
1 System Call ancora Vediamo passo passo come funziona una SC.
Il C `e un linguaggio di programmazione di uso generale, originariamente sviluppato per la scrittura del sistema operativo Unix, ed oggi disponibile su.
Gaetano Anastasi Beatrice Miotti Lorenzo Guerriero Monica Pellegrinelli Massimiliano Sartor Giorgio Macauda SQLite Esempi di utilizzo della libreria in.
La famiglia di system call exec Laboratorio di Sistemi Operativi I
LINUX: struttura generale
Transcript della presentazione:

1 System Call che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2

2 Process identifier: getpid,getppid –pid indice del processo all’interno della tabella dei processi –ppid indice del processo padre all’interno della tabella dei processi –il kernel ha pid 0 e init ha pid 1 –si possono ottenere con pid_t getpid(void) pid_t getppid(void)

3 Creazione : fork() pid_t fork(void); –crea un nuovo processo con indice pid –lo spazio di indirizzamento del nuovo processo è un duplicato di quello del padre –padre e figlio hanno due tabelle dei descrittori di file diverse (il figlio ha una copia di quella del padre) –Ma condividono la tabella dei file aperti (e quindi anche il puntatore alla locazione corrente di ogni file)

4 Creazione : fork() (2) pid_t fork(void); –restituisce 0 al figlio e pid al padre, –oppure -1 (solo al padre) in caso di fallimento es. la tabella dei processi non ha più spazio...

5 Text Data Stack Area vuota heap Creazione di processi (2) Spazio di indirizzamento di padre e figlio dopo una fork terminata con successo padre Text Data Stack Area vuota heap figlio copia

6 Text Data Stack Area vuota heap Creazione di processi (3) Come prosegue l’esecuzione nei processi padre e figlio SI padre (pid=34) Text Data Stack Area vuota heap SI figlio (pid = 45) 0 &x&x &x&x 45 PC = istruzione successiva a fork

7 Creazione di processi (4) /* frammento che crea un nuovo processo */ int pid; /* pid del processo creato */ … IFERROR( pid = fork(),”main: creazione”); if ( pid ) { /* siamo nel padre */... } else { /* siamo nel figlio */... }

8 Terminazione : exit() void exit(int status); Prevede un parametro (status) con il quale in figlio puo’ inviare messaggi al padre sul suo stato di terminazione La exit ha il seguente effetto: –chiude tutti i descrittori di file e libera lo spazio di indirizzamento, –invia un segnale SIGCHLD al padre e salva il primo byte (0-255) di status nella tabella dei processi in attesa che il padre esegua wait/waitpid –se il processo padre è terminato, il processo ‘orfano’ viene adottato da init (cioè ppid viene settato a 1 ) –se eseguita nel main è equivalente ad una return

9 Attesa di terminazione del figlio pid_t wait(int *status) –Restituisce il pid del processo terminato, oppure un codice di errore <0 –Inoltre nella variabile status passata per riferimento vengono salvate informazioni sul tipo di terminazione del figlio il byte meno significativo ritornato con la exit() –Per decodificare le informazioni sullo stato del figlio si utilizzano delle maschere definite in –Ad esempio: WIFEXITED(status) restituisce vero se il figlio e’ terminato volontariamente WEXITSTATUS(status) restituisce lo stato di terminazione

10 Effetti della wait Supponiamo che il processo P abbia chiamato wait(&status) –Se tutti i figli del processo sono ancora in esecuzione allora il processo P rimane in attesa –Se almeno un figlio Q del processo P e’ terminato e il suo stato non e’ ancora stato rilevato (cioe’ Q e’ nello stato zombie) la wait ritorna immediamente il valore dello stato di terminazione di Q –Se P non ha figli, la wait non e’ bloccante e restituisce un codice di errore <0

11 Attesa di terminazione pid_t waitpid(pid_t pid,int *status,int options) –la waitpid permette di fare attese non bloccanti WNOHANG specificato nelle opzioni indica di non attendere se nessun figlio è ancora terminato –permette di attendere un figlio con un pid specifico ( pid )

12 Esempio int status ; /* conterra’ lo stato */ IFERROR( pid = fork(),”main: creazione”); if ( pid ) { /* siamo nel padre */ sleep(20); /* aspetta 10 secondi */ pid = wait(&status); if (WIFEXITED(status)) { /*!=0 se il figlio e’terminato normalmente, (exit o return) non ucciso da signal */ printf(“stato %d\n”, WEXITSTATUS(status)); } else { /* siamo nel figlio */ printf(“Processo %d, figlio.\n”,getpid()); exit(17); /*termina con stato 17 */ }

13 Esempio C osa accade se eseguiamo un main contenente il codice dell’esempio : $ a.out & -- avvio l’esecuzione in bg Processo 1246, figlio. -- stampato dal figlio

14 Esempio Prima che i 20 secondi siano finiti... $ a.out & -- avvio l’esecuzione in bg Processo 1246, figlio. -- stampato dal figlio $ ps -l … S UID PID PPID ………… CMD … Z …………… a.out -- il figlio e’ un processo zombie

15 Esempio Q uando il padre si risveglia ed esegue la wait()... $ a.out & -- avvio l’esecuzione in bg Processo 1246, figlio. -- stampato dal figlio $ ps -l … S UID PID PPID ………… CMD … Z …………… a.out -- il figlio e’ un processo zombie (Z) $ Stato stampato dal padre $

16 Differenziazione : le exec() execve –è l’unica chiamata di sistema vera execl, execlp,execle,execv, execvp –sono funzioni di libreria con differenze sul tipo di parametri –alla fine invocano la execve tutte i tipi di exec –differenziano un processo da padre rimpiazzando il suo spazio di indirizzamento con quello di un file eseguibile passato come parametro

17 Differenziazione : le exec() (2) execl, execlp,execle,execv, execvp, execve –è possibile richiedere che la exec() cerchi il file nelle directory specificate dalla variabile di ambiente PATH è ( p nel nome) –è possible passare un array di argomenti secondo il formato di argv[] ( v nel nome) –è possible passare un array di stringhe che descrivono l’environment ( e nel nome) –è possibile passare gli argomenti o l’environment come lista (terminato da NULL ) ( l nel nome)

18 Ambiente L’ambiente e’ una lista di stringhe variabile=valore (terminata da null) che descrive il valore delle variabili d’ambiente –Es. char *envp[] = {"PATH=/bin:/usr/bin:.", (char *) 0 }; L’ambiente di default e’ quello del processo corrente –Es. main(int argc, char *argv[], char *envp[]).

19 execlexeclpexecleexecvexecvpexecve argomenti a lista argomenti a vettore XXX XXX file completo ricerca su path X X XX X X ambiente a vettore uso var. environ del processo di partenza XX X XX X

20 Relazione tra versioni exec

21 Differenziazione : le exec() (3) execl, execlp,execle,execv, execvp, execve –le exec() non ritornano in caso di successo!!! –Restituiscono -1 in caso di fallimento non trova il file, il file non è eseguibile etc...

22 Effetti della exec Il processo dopo exec: –Mantiene la stessa process structure (salvo le informazioni relative al codice): Stesso pid Stesso pid del padre –Ha codice, dati globali, heap e stack nuovi –Mantiene la user area (a parte il program counter e le informazioni sul codice) e lo stack kernel: n particolare quindi mantiene le stesse risorse (es file aperti)

23 Esempio : una shell semplificata int pid, status; char * argv[]; while (TRUE) { /*ciclo infinito*/ type_prompt(); /* stampa prompt*/ argv = read_comm(); /*legge command line*/ IFERROR3(pid = fork(),”Nella fork”,continue); if (pid) {/* codice padre */ wait(&status); if (WIFEXITED(status)) …/*gest. stato*/ } else {/*codice figlio*/ IFERROR(execvp(argv[0],argv),”nella execvp”); }

24 Esempio di execv char * cmdArray[5]; // vettore passato alla execv cmdArray[0] = "/bin/bash"; cmdArray[1] = "-bash"; cmdArray[2] = "-c"; cmdArray[3] = "printenv"; //comando di esempio che stampa l'ambiente cmdArray[4] = NULL; //l'ultimo elemento deve essere sempre NULL execv(cmdArray[0],cmdArray);

25 Esempio execve #include main(int argc, char **argv, char **envp){ char *newargv[3]; int i; newargv[0] = "cat"; newargv[1] = "exec2.c"; newargv[2] = NULL; i = execve("/bin/cat", newargv, envp); perror("exec2: execve failed"); exit(1); }

26 Esempi di uso di execl/execlp execl("/bin/ls","ls", "-l", (char *)0); // eseguo il comando “ls –l” execlp("ls","ls", "-l", (char *)0); // eseguo il comando “ls –l” usando PATH // per cercare il file ls

27 Duplicazione dei descrittori di file: dup() e dup2() int dup(int oldfd); int dup2(int oldfd,int newfd); –creano entrambi una copia del descrittore di file oldfd, –entrambi i descrittori puntano alla stessa locazione della tabella dei file aperti e possono essere utilizzati per lavorare sullo stesso file –dup cerca la prima posizione libera –dup2 rende newfd una copia del file descriptor oldfd

28 Es: redirezione con dup() e dup2() Es. voglio ridirigere lo standard output (file descriptor 1) su un file pippo int fd;... IFERROR(fd=open(“pippo”,O_WRONLY|O_TRUNC|O_CREAT,0644), ”nella open”); dup2(fd,STDOUT); /* duplica fd sullo standard output*/ close(fd); /* fd non serve piu’ */ printf(“Questo viene scritto in pippo!”);...

29 Come la shell implementa la redirezione... Es. $ ls -l > pippo –Il processo shell si duplica con una fork() e si mette in attesa della terminazione del figlio con una wait –Il figlio apre in scrittura il file pippo (creandolo o troncandolo) –Il figlio duplica il descrittore di pippo con la dup2 sullo stdout e chiude il descrittore originario –Il figlio invoca una exec di ls -l, la quale conserva i descrittori dei file, e quindi va a scrivere in pippo ogni volta che usa il file descriptor 1 –Quando il figlio termina, il padre riprende la computazione con i sui descrittori di file invariati (padre e figlio hanno ognuno la propria tabella dei descrittori e casomai puntano alla stessa locazione della tabella dei file aperti)