SYS CALL viste a lezione.

From Sistemi Operativi
Revision as of 20:01, 3 December 2013 by Pirata (talk | contribs) (→‎SIGNAL)
Jump to navigation Jump to search

Controllo processi

FORK

Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre.

esempio1: 

#include <stdio.h>
#include <unistd.h>

void main (void){     
	if(fork()){
	printf("uno  %d  %d \n", getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre
        sleep(2);}   //se togliessimo lo sleep;il processo figlio stamperebbe come getppid() 1,perché essendo il padre terminato e lui rimasto orfano,il nuovo padre diventa init
	else
	printf("due %d %d  \n",getpid(), getppid() );
}

esempio2(una piccola osservazione sull'eredità del buffer): 

#include <stdio.h>
#include <unistd.h>

void main (void){
	printf("cucù! : ");      //notare la differenza se nella sringa metto \n 
	if(fork())
	printf("uno  %d  %d \n", getpid(), getppid() );
	else
	printf("due %d %d  \n",getpid(), getppid() );
}

esempio3(fork e malloc):
(sottolineerei che lo spazio di indirizzamento è di fatto separato: i due processi hanno una analoga visione dell'indirizzamento logico, che però è specifico di ogni processo e i dati sono memorizzati fisicamente in aree di memoria diverse. am_20131110) 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


void main (void){
	int *p;
	if( fork() ){
	p = malloc(sizeof(int));
	*p = 45;
	printf("%d %p  pid : %d  , ppid : %d \n",*p,p,getpid(),getppid());   
	sleep(2);
	}
	else {
	p = malloc(sizeof(int));
	printf("%d %p  pid : %d  , ppid : %d \n",*p,p,getpid(),getppid());  //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio         
	sleep(1);                                                           //perché condividono lo stesso spazio di indirizzamento
	}
}


_EXIT

Termina il proceso chiamante.

esempio1: 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main (int argc,char *argv[]){
	_exit(0);                     //Sys call che termina il processo chiamante
}

esempio2(atexit): 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

void at1(void){
	printf("at1 \n");
	}

void at2(void){
	printf("at2 \n");
	}


int main (int argc,char *argv[]){
	printf("brutal kill \n");
	atexit(at1);	//funzione di libreria che termina il processo passato come argomento
	atexit(at2); 
}

//le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione


WAIT

Aspetta che un processo cambi di stato.

esempio1: 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
	pid_t pid;
	if( pid = fork() ){
		int status;
		printf(" padre : %d  figlio : %d \n",getpid(),pid);
                sleep(10); 
		waitpid(pid,&status,0);
		printf(" exit status %d \n",WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio
	}                                                         //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.
	else {
		printf(" figlio : %d  padre : %d \n",getpid(),getppid());
		sleep(1);
		exit(1);
		}
}


esempio2: 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
	pid_t pid;
	if( pid = fork() ){
		int status;
		printf(" padre : %d  figlio : %d \n",getpid(),pid);
		sleep(5);
		waitpid(pid,&status,0);
		if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main
		printf(" exit status %d \n", WEXITSTATUS(status));
		else if(WIFSIGNALED(status) )  //Macro che restituisce true se il figlio é terminato da un segnale
			printf("signal : %d \n", WTERMSIG(status) );  //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio
	}
	else {
		int *p;
		printf(" figlio : %d  padre : %d \n",getpid(),getppid());
		sleep(1);
		p = (int *)42;
		*p = 43;	
		exit(2);
		}
}


EXEC

Esegue un programma. La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.

esempio1: 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
	pid_t pid;
	if( pid = fork() ){
		int status;
		printf(" padre : %d  figlio : %d \n",getpid(),pid);
		sleep(5);
		waitpid(pid,&status,0);
		if (WIFEXITED(status)) 
		printf(" exit status %d \n", WEXITSTATUS(status));
		else if( WIFSIGNALED(status) )  
			printf("signal : %d \n", WTERMSIG(status) ); 
	}
	else {
		char *args[] = {"ls","-l",(char *)0};
		execvp("ls",args); //funzione di libreria che prende in input il path(p) e un vettore(v).
	}
}

esempio2: 

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>

int main (int argc, char *argv[]){
	pid_t pid;
	if( pid = fork() ){
		int status;
		printf(" padre : %d  figlio : %d %s \n",getpid(),pid,argv[1]);
		sleep(5);
		waitpid(pid,&status,0);
		if (WIFEXITED(status)) 
		printf(" exit status %d \n", WEXITSTATUS(status));
		else if( WIFSIGNALED(status) )  
			printf("signal : %d \n", WTERMSIG(status) ); 
	}
	else {
		execvp(argv[2],argv+2);
	}
}



Gestione File

  • int open(const char *path, int oflag, ...);
  • int creat(const char *path, mode_t mode);
  • int close(int filedes);
  • off_t lseek(int filedes, off_t offset, int whence);
  • ssize_t read(int filedes, void *buf, size_t nbyte);
  • ssize_t write(int filedes, const void *buf, size_t nbyte);

Qualche esempio? Iniziamo con i file "con il buco" visti a lezione?


OPEN/WRITE/CLOSE

  • Open: apre e possibilmente crea un file o un device.
  • Write: scrive su il file descriptor.
  • Close: chiude il file descriptor.


Esempio1: 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>



int main ( int argc , char *argv[] ){
	int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); 
	write( fd , argv[2] , strlen( argv[2] ) );
	close( fd);
	}

LSEEK/READ

  • Lseek: sposta l'offset del file descriptor.
  • Read: legge da un file descriptor.


Esempio1(sparse file o file ciambella): 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>



int main ( int argc , char *argv[] ){
	int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); 
	write( fd , argv[2] , strlen( argv[2] ) );
	lseek( fd, 1000000 , SEEK_SET );
	write( fd , argv[2] , strlen( argv[2] ) );
	close( fd);
	}


Esempio2(copia di un file): 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define BUFFSIZE 1024

char buff[BUFFSIZE];		

	

int main ( int argc , char *argv[] ){
	int fin = open( argv[1] , O_RDONLY );
	int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); 
	ssize_t n;
	while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){
		write( fout , buff , n );
	}
	close( fin);
	close( fout);
	}


Esempio3(copia di uno sparse file): 

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define BUFFSIZE 1024             //la copia avviene per blocchi di 1024B

char buff[BUFFSIZE];

int isEmpty( char *s , int l ){
	int i;
	for( i = 0 ; i < l ; i++ )
		if( s[i] != 0 ) return (0);
	return(1);


# if 0
	for ( i = 0 ; ( i < l ) && ( s[i] != 0 ) ; i++ )
		;
	return ( i == l );             //codice più compatto 
	

	for( i = 0 ; i < l ; i++ )
		if( s[i] != 0 ) goto nonempty;
	return1;
nonempty:
	return0;                        //in stile kernel 
#endif
}		

	

int main ( int argc , char *argv[] ){
	int fin = open( argv[1] , O_RDONLY );
	int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); 
	ssize_t n;
	while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){
		if (isEmpty( buff , n ) )                       //il codice in questo esempio é ottimizzato per gli sparse file.
			lseek( fout , n , SEEK_CUR );
		else
		write( fout , buff , n );
	}
	close( fin);
	close( fout);
	}


Esempio4(Buffer ed efficienza): 

/*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte

dd if=/dev/urandom  of=casual  bs=1024  count=102400
for size in 128 256 512 1024 2048 4096
do 
time ./eseguibile casual ricasual $size
done
*/


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>


int isEmpty( char *s , int l ){
	int i;
	for( i = 0 ; i < l ; i++ )
		if( s[i] != 0 ) return (0);
	return(1);
}

	

int main ( int argc , char *argv[] ){
	int fin = open( argv[1] , O_RDONLY );
	int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); 
	int buffsize = atoi( argv[3] );
	char buff[buffsize];
	ssize_t n;
	while( ( n = read( fin , buff , buffsize ) ) != 0 ){
		if (isEmpty( buff , n ) )
			lseek( fout , n , SEEK_CUR );
		else
		write( fout , buff , n );
	}
	close( fin);
	close( fout);
	}

TRUNCATE

  • Truncate: tronca il file a una specifica lunghezza.

Esempio(viene usata per creare File Buco Nero): 

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc , char *argv[] ) {
	int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );
	ftruncate( fd , atoi( argv[2] ) );
	close( fd );
}

DUP

  • Dup: duplica il file descriptor.

Esempio: 

#include<stdio.h>
#include<fcntl.h>
#include <unistd.h>

int main( int argc , char *argv[]){
	int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );
	close(1);
	dup(fd);   //dup2(fd,1) produce lo stesso effetto
	printf("Hello World \n");
}


FUNZIONI SULLE DIRECTORY

Esempio1: 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>


int mystrcmp( const void *a , const void *b ){
	char **pa = (char **)a;
	char **pb = (char **)b;
	return strcmp( *pa , *pb );
}

	

int main ( int argc , char *argv[] ){
	DIR *d;
	struct dirent *de;
	char **names;
	int i , count = 0;
	d = opendir( argv[1] );     
	while( ( de = readdir(d) ) != NULL )
		count++;
	rewinddir(d);
	names = (char **)calloc( count , sizeof(char *) );
	count=0;
	while( ( de = readdir(d) ) != NULL )
		names[count++] = strdup( de->d_name );
	closedir(d);
	qsort( names , count , sizeof(char *) , mystrcmp );
	for( i = 0 ; i < count ; i++ )
		printf(" %s ", names[i] );
	printf("\n");
	}


Esempio2: 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<dirent.h>


int main( int argc , char *argv[] ){
	int count;
	int i;
	struct dirent **de;
	count = scandir( argv[1] , &de , NULL , alphasort );
	for ( i = 0 ; i < count ; i++ ){
		printf("%s ",de[i]->d_name);
		free(de[i]);
	}
	printf("\n");
	free(de);
}


Segnali

SIGNAL

Esempio1(programma riluttante a morire): 

#include<stdio.h>
#include<signal.h>

void no( int sn )
{
	printf("io non termino! %d\n" , sn );
}


int main( int arg , char *argv )
{
	signal( SIGTERM , no );
	signal( SIGINT , no );
	while(1){
		pause();
		printf("ciao\n");
	}
}


Esempio2(il figlio termina): 

#include<stdio.h>
#include<signal.h>
#include<sys/types.h>
#include<sys/wait.h>
#include <stdlib.h>


void child( int sn )
{
	int status;
	wait(&status);
	printf("il figlio termina! \n" );
}


int main( int arg , char *argv )
{
	signal( SIGCHLD , child );
	if ( fork() > 0 ){
	while(1)
		pause();
	}
	else {
		sleep(3);
		exit(1);
		} 
}

Correggetemi se ho scritto delle sciocchezze. -Pirata-

Retrieved from "https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&oldid=383"