https://so.v2.cs.unibo.it/wiki/api.php?action=feedcontributions&feedformat=atom&user=Pirata 2026-05-05T08:12:54Z User contributions MediaWiki 1.35.5 https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaTeorica_2012.07.16&diff=515 2014-03-28T16:54:11Z

<p>Pirata: </p> <hr /> <div>[http://www.cs.unibo.it/~renzo/so/compiti/2012-07-16.tot.pdf Link Testo]<br /> &lt;h2&gt;Esercizio C.2&lt;/h2&gt;<br /> <br /> Mia Soluzione:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #define RED 0<br /> #define BLUE 1<br /> //restituisce 1 se c'e piu del 75% blue o 75% di red<br /> //restituisce 0 se non c'e una maggiornza<br /> int media(color){<br /> int mediared;<br /> int localinto = into;<br /> if (color != NULL){<br /> localinto[color]++;<br /> }<br /> mediared = ((100*localinto[0])/(localinto[0]+localinto[1]));<br /> if(mediared &gt;=75 || mediared &lt; 25){<br /> return 1;//75% di rossi o di blue<br /> }else{<br /> return 0;// non c'e maggioranza <br /> }<br /> }<br /> <br /> monitor limcol{<br /> <br /> conditon oktoenter[2];<br /> int into[2];<br /> <br /> enter(color){<br /> if(media(color) != 1){// attendo perche' non c'e una maggioranza<br /> oktoenter[color].wait();<br /> }<br /> into[color]++;<br /> }<br /> <br /> exit(color){<br /> into[color]--;<br /> if(media(1-color) == 1){<br /> oktoenter[1-color].signal();<br /> }else if(media(color) == 1){<br /> oktoenter[color].signal();<br /> }<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> - Midolo<br /> <br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #define ROSSO 0<br /> #define BLU 1<br /> <br /> monitor limcol {<br /> condition oktoenter<br /> int running[2] // numero di processi rossi [0] e blu [1] in esecuzione<br /> queue waiting // coda dei colori dei processi in attesa<br /> <br /> /* restituisce true se aggiungendo un processo del colore passato viene rispettato il 75%<br /> dei processi di un colore */<br /> bool morethan75p(colore) { <br /> return (running[colore]+1&gt;=running[1-colore]*3 || (running[colore]+1)*3&lt;=running[1-colore])<br /> }<br /> <br /> // risveglia un processo del colore passato se è possibile farlo<br /> void checkwakeup() {<br /> if (waiting.empty() == false) {<br /> colore=waiting.head() // head resituisce l'elemento in testa senza rimuoverlo<br /> if (morethan75p(colore)) { <br /> waiting.dequeue()<br /> oktoenter.signal()<br /> }<br /> }<br /> }<br /> <br /> procedure entry enter(colore) {<br /> if (morethan75p(colore)==false) {<br /> waiting.enqueue(colore)<br /> oktoenter.wait()<br /> }<br /> running[colore]++<br /> checkwakeup()<br /> }<br /> <br /> procedure entry exit(colore) {<br /> running[colore]--<br /> checkwakeup()<br /> }<br /> }<br /> <br /> /* la politica FIFO impedisce che si verifichi starvation, perché nel caso pessimo un processo<br /> che vuole entrare dovrà attendere fino a che tutti quelli in esecuzione terminino */<br /> &lt;/syntaxhighlight&gt;<br /> Daniele Cortesi<br /> <br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> define RED 0<br /> define BLUE 1<br /> int majorcolor = -1<br /> int numproc[2] = 0,0<br /> cond oktoenter[2]<br /> cond oktoexit[2]<br /> <br /> <br /> monitor limcol{<br /> procedure entry enter(COL){<br /> if(COL == majorcolor){<br /> numproc[COL]++<br /> if(((proc[majorcolor])*100/(numproc[COL] + numproc[1-COL] + 1)) &gt;= 75)<br /> oktoenter[1-COL].signal()<br /> }<br /> else if(COL == 1-majorcolor){<br /> if((proc[majorcolor]*100/(numproc[COL] + numproc[1-COL] + 1)) &lt; 75)<br /> oktoenter[COL].wait()<br /> if(majorcolor == -1)<br /> majorcolor == COL<br /> numproc[COL]++<br /> }<br /> else{<br /> numproc[COL]++<br /> majorcolor = COL<br /> }<br /> }<br /> <br /> procedure entry exit(COL){<br /> if(numproc[COL] + numproc[1-COL] == 1){<br /> majorcolor = -1<br /> numproc[COL]--<br /> oktoenter[1-COL].signal()<br /> }<br /> else if(COL == majorcolor){<br /> if(((proc[majorcolor] - 1)*100/(numproc[COL] + numproc[1-COL] - 1)) &lt; 75){<br /> oktoexit[COL].wait()<br /> numproc[COL]--<br /> }<br /> }<br /> else if(COL == 1-majorcolor){<br /> numproc[COL]--<br /> if(((proc[majorcolor])*100/(numproc[COL] + numproc[1-COL] - 1)) &gt;= 75)<br /> oktoexit[1-COL].signal()<br /> }<br /> }<br /> }<br /> <br /> <br /> &lt;/syntaxhighlight&gt;<br /> Fede<br /> <br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> define RED 0<br /> define BLU 1<br /> <br /> limcol{<br /> /*variable*/<br /> int array[2] = 0,0;<br /> color major = -1;<br /> /*condition*/<br /> condition oktoenter[2];<br /> condition oktoleave[2];<br /> <br /> <br /> procedure entry enter( color ){<br /> if ( majorcolor == -1 ) <br /> majorcolor = color;<br /> if ( majorcolor == (1-color) &amp;&amp; newmajorcolor%(color) &lt; 75% )<br /> oktoenter[color].wait();<br /> array[color]++; <br /> if ( majorcolor == -1 ) //se un processo si risveglia nel monitor vuoto deve impostare majorcolor<br /> majorcolor = color;<br /> if ( newmajorcolor%(1-color) &gt;= 75% ) <br /> oktoenter[1-color].signal();<br /> }<br /> <br /> procedure entry exit( color ){<br /> if ( majorcolor == color &amp;&amp; majorcolor_less1%(color) &gt; 75% )<br /> oktoleave[color].wait();<br /> array[color]--;<br /> if ( !colorsempty() )<br /> if ( majorcolor_less1%(color) &gt;= 75% )<br /> oktoleave[1-color].signal();<br /> else{<br /> majorcolor == -1;<br /> oktoenter[1-color].signal();<br /> }<br /> }<br /> <br /> <br /> /*<br /> newmajorcolor%(color) calcola la nuova % del colore maggiore aggiungendo color<br /> majorcolor_less1%(color) calcola la nuova % del colore maggiore togliendo color<br /> */<br /> &lt;/syntaxhighlight&gt;<br /> Pir@t@</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2014.01.23&diff=491 2014-03-23T14:07:08Z

<p>Pirata: </p> <hr /> <div>[C esercizi 1 e 2]<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 1: Linguaggio C (obbligatorio): (20 punti)<br /> *Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo n). <br /> *Il programma deve stampare come output il numero di caratteri presenti nella n-ma riga del file se il file e' un file regolare di testo, non deve stampare nulla negli altri casi.<br /> *Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel range 1-127.<br /> *Per controllare se il file e' “regolare” usare la system call lstat<br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> <br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ //check if the file is a regular file of text,it means that every byte has a value between 1-127<br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); //sets the file's cursor at the beginning,otherwise the linean program cannot find the line<br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> void linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) //iterates until at the nline and when is reached then checks if the buffer contains something<br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); //every time the nline is buffered,when exits from the cicle, the buffer contains the nline <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> printf( &quot;The file %s in line %d has : %d char\n&quot; , path , n , ( strlen( bufline ) - 1 ) ); //strlen also consider the carriage return<br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[2] );<br /> linean( argv[1] , n );<br /> return(0);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 2: completamento (10 punti)<br /> *Si scriva un programma C chiamato “lineandir”. Il risultato del programma, stampato su standard output, deve essere un solo<br /> *numero intero: la somma del numero di caratteri presenti nelle n-me righe di tutti i file regolari, di testo, non nascosti (il primo<br /> *carattere deve essere diverso da punto) della directory corrente. <br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> int istextfile( FILE *fd );<br /> int linean( char *path , int line );<br /> void lineandir( char *dir , int line );<br /> <br /> <br /> <br /> <br /> <br /> void lineandir( char *dir , int line ){<br /> int count , i;<br /> int sumline;<br /> struct dirent **de;<br /> sumline = 0;<br /> count = scandir( dir , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ )<br /> {<br /> if ( de[i]-&gt;d_name[0] != '.' ) //doesn't consider the hidden files<br /> sumline = sumline + linean( de[i]-&gt;d_name , line );<br /> free(de[i]);<br /> }<br /> printf(&quot;The sum of char for every regular text file's nline in the current directory is: %d\n&quot; , sumline );<br /> free(de);<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ <br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); <br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> /*linean is modified so it can return the value of the char in the nline */<br /> int linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) <br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> return( ( strlen( bufline ) - 1 ) ); <br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[1] );<br /> lineandir( &quot;./&quot; , n );<br /> return(0);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> [Bash esercizio 3]<br /> &lt;syntaxhighlight lang=&quot;Bash&quot;&gt;<br /> #Esercizio 3: Script bash o Python: (10 punti):<br /> #Il comando che dovrete implementare come script shell o programma python e' updatedir. Updatedir prende due directorycome parametri.<br /> #updatedir dira dirb deve copiare in dirb tutti i file regolari che sono in dira e non in dirb. Se un file regolare e' presente con lo stesso nome sia in<br /> #dira sia in dirb, il file deve essere copiato dalla dira alla dirb solo se i contenuti differiscono.<br /> <br /> #! /bin/bash<br /> <br /> <br /> for file in &quot;$1&quot;/*; do<br /> if [[ -f $file ]] ; then #checks if the file is regular<br /> thereisnotfile=1 #variable that identify if the file is also in dir2<br /> for file2 in &quot;$2&quot;/*; do<br /> if [[ -f $file2 ]] ; then<br /> if [[ $file2 != $file ]] ; then #checks if the file is only in dir1 and not in dir2<br /> continue<br /> else<br /> thereisnotfile=0 #the file is in both dir<br /> fi<br /> if [[ $thereisnotfile -eq 0 ]]; then <br /> if [[ $(md5sum &quot;$file&quot;) != $(md5sum &quot;$file2&quot;) ]] ; then #checks if the file in dir1 is different of file in dir2 by md5sum <br /> bn=$(basename &quot;$file&quot;)<br /> cp $file &quot;$2&quot;/&quot;$bn&quot;<br /> thereisnotfile=2 #is set in this way for not continue to iterate<br /> fi<br /> fi<br /> fi<br /> done<br /> if [[ $thereisnotfile -eq 1 ]]; then<br /> bn=$(basename &quot;$file&quot;)<br /> cp $file &quot;$2&quot;/&quot;$bn&quot;<br /> fi<br /> fi<br /> done<br /> &lt;/syntaxhighlight&gt; <br /> Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2014.01.23&diff=490 2014-03-23T14:06:10Z

<p>Pirata: </p> <hr /> <div>[C esercizi 1 e 2]<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 1: Linguaggio C (obbligatorio): (20 punti)<br /> *Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo n). <br /> *Il programma deve stampare come output il numero di caratteri presenti nella n-ma riga del file se il file e' un file regolare di testo, non deve stampare nulla negli altri casi.<br /> *Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel range 1-127.<br /> *Per controllare se il file e' “regolare” usare la system call lstat<br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> <br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ //check if the file is a regular file of text,it means that every byte has a value between 1-127<br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); //sets the file's cursor at the beginning,otherwise the linean program cannot find the line<br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> void linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) //iterates until at the nline and when is reached then checks if the buffer contains something<br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); //every time the nline is buffered,when exits from the cicle, the buffer contains the nline <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> printf( &quot;The file %s in line %d has : %d char\n&quot; , path , n , ( strlen( bufline ) - 1 ) ); //strlen also consider the carriage return<br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[2] );<br /> linean( argv[1] , n );<br /> return(0);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 2: completamento (10 punti)<br /> *Si scriva un programma C chiamato “lineandir”. Il risultato del programma, stampato su standard output, deve essere un solo<br /> *numero intero: la somma del numero di caratteri presenti nelle n-me righe di tutti i file regolari, di testo, non nascosti (il primo<br /> *carattere deve essere diverso da punto) della directory corrente. <br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> int istextfile( FILE *fd );<br /> int linean( char *path , int line );<br /> void lineandir( char *dir , int line );<br /> <br /> <br /> <br /> <br /> <br /> void lineandir( char *dir , int line ){<br /> int count , i;<br /> int sumline;<br /> struct dirent **de;<br /> sumline = 0;<br /> count = scandir( dir , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ )<br /> {<br /> if ( de[i]-&gt;d_name[0] != '.' ) //doesn't consider the hidden files<br /> sumline = sumline + linean( de[i]-&gt;d_name , line );<br /> free(de[i]);<br /> }<br /> printf(&quot;The sum of char for every regular text file's nline in the current directory is: %d\n&quot; , sumline );<br /> free(de);<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ <br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); <br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> /*linean is modified so it can return the value of the char in the nline */<br /> int linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) <br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> return( ( strlen( bufline ) - 1 ) ); <br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[1] );<br /> lineandir( &quot;./&quot; , n );<br /> return(0);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> &lt;syntaxhighlight lang=&quot;Bash&quot;&gt;<br /> [Bash esercizio 3]<br /> #Esercizio 3: Script bash o Python: (10 punti):<br /> #Il comando che dovrete implementare come script shell o programma python e' updatedir. Updatedir prende due directorycome parametri.<br /> #updatedir dira dirb deve copiare in dirb tutti i file regolari che sono in dira e non in dirb. Se un file regolare e' presente con lo stesso nome sia in<br /> #dira sia in dirb, il file deve essere copiato dalla dira alla dirb solo se i contenuti differiscono.<br /> <br /> #! /bin/bash<br /> <br /> <br /> for file in &quot;$1&quot;/*; do<br /> if [[ -f $file ]] ; then #checks if the file is regular<br /> thereisnotfile=1 #variable that identify if the file is also in dir2<br /> for file2 in &quot;$2&quot;/*; do<br /> if [[ -f $file2 ]] ; then<br /> if [[ $file2 != $file ]] ; then #checks if the file is only in dir1 and not in dir2<br /> continue<br /> else<br /> thereisnotfile=0 #the file is in both dir<br /> fi<br /> if [[ $thereisnotfile -eq 0 ]]; then <br /> if [[ $(md5sum &quot;$file&quot;) != $(md5sum &quot;$file2&quot;) ]] ; then #checks if the file in dir1 is different of file in dir2 by md5sum <br /> bn=$(basename &quot;$file&quot;)<br /> cp $file &quot;$2&quot;/&quot;$bn&quot;<br /> thereisnotfile=2 #is set in this way for not continue to iterate<br /> fi<br /> fi<br /> fi<br /> done<br /> if [[ $thereisnotfile -eq 1 ]]; then<br /> bn=$(basename &quot;$file&quot;)<br /> cp $file &quot;$2&quot;/&quot;$bn&quot;<br /> fi<br /> fi<br /> done<br /> &lt;/syntaxhighlight&gt; <br /> Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2014.01.23&diff=489 2014-03-23T13:58:02Z

<p>Pirata: </p> <hr /> <div>[C esercizi 1 e 2]<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 1: Linguaggio C (obbligatorio): (20 punti)<br /> *Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo n). <br /> *Il programma deve stampare come output il numero di caratteri presenti nella n-ma riga del file se il file e' un file regolare di testo, non deve stampare nulla negli altri casi.<br /> *Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel range 1-127.<br /> *Per controllare se il file e' “regolare” usare la system call lstat<br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> <br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ //check if the file is a regular file of text,it means that every byte has a value between 1-127<br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); //sets the file's cursor at the beginning,otherwise the linean program cannot find the line<br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> void linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) //iterates until at the nline and when is reached then checks if the buffer contains something<br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); //every time the nline is buffered,when exits from the cicle, the buffer contains the nline <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> printf( &quot;The file %s in line %d has : %d char\n&quot; , path , n , ( strlen( bufline ) - 1 ) ); //strlen also consider the carriage return<br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[2] );<br /> linean( argv[1] , n );<br /> return(0);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 2: completamento (10 punti)<br /> *Si scriva un programma C chiamato “lineandir”. Il risultato del programma, stampato su standard output, deve essere un solo<br /> *numero intero: la somma del numero di caratteri presenti nelle n-me righe di tutti i file regolari, di testo, non nascosti (il primo<br /> *carattere deve essere diverso da punto) della directory corrente. <br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> int istextfile( FILE *fd );<br /> int linean( char *path , int line );<br /> void lineandir( char *dir , int line );<br /> <br /> <br /> <br /> <br /> <br /> void lineandir( char *dir , int line ){<br /> int count , i;<br /> int sumline;<br /> struct dirent **de;<br /> sumline = 0;<br /> count = scandir( dir , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ )<br /> {<br /> if ( de[i]-&gt;d_name[0] != '.' ) //doesn't consider the hidden files<br /> sumline = sumline + linean( de[i]-&gt;d_name , line );<br /> free(de[i]);<br /> }<br /> printf(&quot;The sum of char for every regular text file's nline in the current directory is: %d\n&quot; , sumline );<br /> free(de);<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ <br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); <br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> /*linean is modified so it can return the value of the char in the nline */<br /> int linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) <br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> return( ( strlen( bufline ) - 1 ) ); <br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[1] );<br /> lineandir( &quot;./&quot; , n );<br /> return(0);<br /> }<br /> &lt;/syntaxhighlight&gt; <br /> Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2014.01.23&diff=488 2014-03-23T13:50:34Z

<p>Pirata: Created page with &quot;[C esercizi 1 e 2] &lt;syntaxhighlight lang=&quot;C&quot;&gt; /* *Esercizio 1: Linguaggio C (obbligatorio): (20 punti) *Scrivere un programma in C “linean” che prenda come parametro il pa...&quot;</p> <hr /> <div>[C esercizi 1 e 2]<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*<br /> *Esercizio 1: Linguaggio C (obbligatorio): (20 punti)<br /> *Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo n). <br /> *Il programma deve stampare come output il numero di caratteri presenti nella n-ma riga del file se il file e' un file regolare di testo, non deve stampare nulla negli altri casi.<br /> *Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel range 1-127.<br /> *Per controllare se il file e' “regolare” usare la system call lstat<br /> */<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;errno.h&gt;<br /> <br /> <br /> <br /> #define BUFFSIZE 200<br /> <br /> <br /> <br /> <br /> int istextfile( FILE *fd ){ //check if the file is a regular file of text,it means that every byte has a value between 1-127<br /> int c;<br /> while ( (c = getc ( fd ) ) != EOF &amp;&amp; c &lt;= 127 );<br /> rewind(fd); //sets the file's cursor at the beginning,otherwise the linean program cannot find the line<br /> return ( (c == EOF)? 1 : 0 );<br /> }<br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> <br /> void linean( char *path , int line ){<br /> FILE *fd;<br /> struct stat buf;<br /> char bufline[BUFFSIZE];<br /> char *res;<br /> int n = line;<br /> res = NULL;<br /> lstat( path , &amp;buf );<br /> if ( S_ISREG( buf.st_mode ) )<br /> {<br /> fd = fopen( path , &quot;r&quot; );<br /> if ( fd == NULL )<br /> {<br /> perror( &quot;Error to open the file\n&quot; );<br /> exit(1);<br /> }<br /> if ( istextfile( fd ) )<br /> {<br /> while ( ( line &gt; 0 ) ) //iterates until at the nline and when is reached then checks if the buffer contains something<br /> {<br /> res = fgets(bufline, BUFFSIZE , fd ); //every time the nline is buffered,when exits from the cicle, the buffer contains the nline <br /> line--;<br /> }<br /> if ( res != NULL ) <br /> {<br /> printf( &quot;The file %s in line %d has : %d char\n&quot; , path , n , ( strlen( bufline ) - 1 ) ); //strlen also consider the carriage return<br /> }<br /> else<br /> printf( &quot;Error: isn't possible to find the line\n&quot; );<br /> }<br /> else<br /> printf( &quot;Error is not a regular file of text\n&quot; );<br /> <br /> fclose(fd);<br /> <br /> }<br /> else<br /> printf( &quot;The file %s isn't a regular file\n&quot; , path );<br /> <br /> <br /> }<br /> <br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int n = atoi( argv[2] );<br /> linean( argv[1] , n );<br /> return(0);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Main_Page&diff=487 2014-03-23T13:46:07Z

<p>Pirata: </p> <hr /> <div>Questo &amp;egrave; il Wiki del Corso di Sistemi Operativi<br /> <br /> [[Esercizi a caso del Prof.]]<br /> <br /> [[Decalogo di Programmazione Concorrente]]<br /> <br /> [[Python Programma tieni punteggio.]]<br /> <br /> [[Comandi visti alle lezioni.]]<br /> <br /> [[SYS CALL viste a lezione.]]<br /> <br /> [[Parametri con getopt().]]<br /> <br /> [[Funzione con numero variabile di parametri.]]<br /> <br /> [[stampf - implementazione ridotta della printf.]]<br /> <br /> [[Producer&amp;Consumer MP.]]<br /> <br /> [[ProvaPratica 2014.01.23]]<br /> <br /> [[ProvaPratica 2013.09.13]]<br /> <br /> [[ProvaPratica 2013.07.18]]<br /> <br /> [[ProvaPratica 2013.06.21]]<br /> <br /> [[ProvaPratica 2013.05.29]]<br /> <br /> [[ProvaPratica 2013.02.15]]<br /> <br /> [[ProvaPratica 2013.01.25]]<br /> <br /> [[ProvaTeoria_2011.07.25]]<br /> <br /> [[ProvaTeorica_2014.01.22]]<br /> <br /> [[ProvaTeorica_2012.02.09]]<br /> <br /> [[ProvaTeorica_2012.05.24]]<br /> <br /> [[ProvaTeorica_2012.06.15]]<br /> <br /> [[ProvaTeorica_2012.09.18]]<br /> <br /> [[ProvaTeorica_2013.02.15]]<br /> <br /> [[ProvaTeorica_2011.02.11]]<br /> <br /> [[ProvaTeorica 2013.07.19]]<br /> <br /> [[ProvaTeorica 2013.01.24]]<br /> ----<br /> Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2013.09.13&diff=486 2014-03-23T13:34:42Z

<p>Pirata: </p> <hr /> <div>[C esercizio 1 e 2]<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> <br /> /***********************************************************************<br /> * Prova Pratica di Laboratorio di Sistemi Operativi *<br /> * 13 settembre 2013 *<br /> * Esercizio 1+2 *<br /> * *<br /> * URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.09.13.pdf *<br /> * Autore: Eduardo Santarelli *<br /> ************************************************************************/<br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;dirent.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> /* An entry in the hash table. */<br /> typedef struct fileEntry{<br /> <br /> const char *filename;<br /> struct fileEntry *next;<br /> <br /> } fileEntry;<br /> <br /> <br /> /* Global variables */<br /> fileEntry **table = NULL;<br /> int table_size;<br /> <br /> /* Hash function. Calculates XOR of 8-bytes blocks *<br /> * (actually, sizeof(long int)) read from the input file */<br /> unsigned int hash(const char *fname){<br /> <br /> FILE *f;<br /> unsigned long int hash_val = 0;<br /> unsigned long int tmp = 0;<br /> <br /> f = fopen(fname, &quot;r&quot;);<br /> fread(&amp;hash_val, sizeof(unsigned long int), 1, f);<br /> <br /> while((fread(&amp;tmp, sizeof(unsigned long int), 1, f) == 1))<br /> hash_val = hash_val^tmp;<br /> <br /> fclose(f);<br /> return hash_val;<br /> <br /> }<br /> <br /> <br /> /* Creates a table of struct fileEntry elements, based on the hash values of the files *<br /> * detected by scandir. If a collision is detected, the new entry is pointed by the *<br /> * 'next' field of the current last element*/<br /> void populate_table(struct dirent *dir_list[], int n){<br /> <br /> int i;<br /> <br /> table_size = 2*n; <br /> table = (fileEntry**)calloc(table_size, sizeof(fileEntry));<br /> if(!table) abort();<br /> <br /> for(i=0; i&lt;n; i++){<br /> unsigned int index;<br /> fileEntry *entry = NULL;<br /> <br /> entry = (fileEntry*)malloc(sizeof(fileEntry));<br /> if(!entry) abort();<br /> <br /> index = hash(dir_list[i]-&gt;d_name)%table_size;<br /> if(table[index] == NULL){<br /> entry-&gt;filename = dir_list[i]-&gt;d_name;<br /> entry-&gt;next = NULL;<br /> table[index] = entry;<br /> }<br /> else{<br /> entry-&gt;filename = dir_list[i]-&gt;d_name;<br /> entry-&gt;next = table[index];<br /> table[index] = entry;<br /> }<br /> }<br /> <br /> <br /> }<br /> <br /> <br /> /* Compares two files */<br /> int fcompare(const char *f1, const char *f2){<br /> <br /> FILE *f, *g;<br /> int file1, file2; <br /> <br /> f = fopen(f1, &quot;r&quot;);<br /> g = fopen(f2, &quot;r&quot;);<br /> <br /> while(fread(&amp;file1, sizeof(int), 1, f) &amp;&amp; fread(&amp;file2, sizeof(int), 1, g)){<br /> if(file1!=file2){<br /> fclose(f);<br /> fclose(g);<br /> return 0;<br /> }<br /> }<br /> fclose(f);<br /> fclose(g);<br /> return 1;<br /> <br /> }<br /> <br /> <br /> /* This function scans the file table. If an entry contains more than one file, *<br /> * it compares all them. If a duplicate is found, the first file is removed, *<br /> * and a hard link is created with the deleted file's name, pointing to the *<br /> * second, identical, file. */<br /> void deduplicate(){<br /> <br /> int i;<br /> <br /> for(i=0; i&lt;table_size; i++){<br /> while(table[i] != NULL &amp;&amp; table[i]-&gt;next != NULL){<br /> <br /> fileEntry *file1, *file2;<br /> file1 = table[i];<br /> file2 = table[i]-&gt;next;<br /> while(file2 != NULL){<br /> if(fcompare(file1-&gt;filename, file2-&gt;filename)){<br /> unlink(file1-&gt;filename);<br /> link(file2-&gt;filename, file1-&gt;filename);<br /> printf(&quot;%s -&gt; %s\n&quot;, file1-&gt;filename, file2-&gt;filename);<br /> break;<br /> }<br /> file2 = file2-&gt;next;<br /> }<br /> table[i] = table[i]-&gt;next;<br /> }<br /> }<br /> }<br /> <br /> <br /> /*selector function for scandir() */<br /> int exclude(const struct dirent *dir){<br /> <br /> if(dir-&gt;d_type != DT_REG)<br /> return 0;<br /> else<br /> return 1;<br /> <br /> }<br /> <br /> <br /> int main(int argc, char *argv[]){<br /> <br /> struct dirent **entries = NULL;<br /> int num_files;<br /> <br /> num_files = scandir(&quot;.&quot;, &amp;entries, exclude, alphasort);<br /> <br /> populate_table(entries, num_files);<br /> deduplicate();<br /> <br /> return EXIT_SUCCESS;<br /> <br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ------<br /> <br /> [Python esercizio 3]<br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> #!/usr/bin/env python3<br /> <br /> # Prova Pratica di Laboratorio di Sistemi Operativi<br /> # 13 settembre 2013<br /> # Esercizio 3<br /> #<br /> # URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.09.13.pdf *<br /> # Autore: Eduardo Santarelli<br /> <br /> <br /> class LineCounter:<br /> <br /> def __init__(self, fileList):<br /> # A list containing the char-per-line<br /> # count for the specified files.<br /> # Value for line 1 is in result[0] and so on.<br /> self.result = []<br /> self.files = fileList # List of files to elaborate.<br /> self.getLinesCount()<br /> <br /> # Count the chars for each lines of specified file,<br /> # add the result to the relevant field in self.result,<br /> # if already present, append the value to the<br /> # end of the list if not.<br /> def countLines(self, file):<br /> i = 0<br /> fd = open(file)<br /> for line in fd:<br /> lineLength = len(line)<br /> # If an entry for the current line does<br /> # not exist, append the value to the end of the list<br /> try:<br /> self.result[i] += lineLength<br /> except IndexError:<br /> self.result.append(lineLength)<br /> i = i+1<br /> fd.close()<br /> <br /> # Call self.countLines() for each file in self.files<br /> # in order to build the self.result list<br /> def getLinesCount(self):<br /> for entry in self.files:<br /> self.countLines(entry)<br /> <br /> # Print the items in self.result, each preceded by the<br /> # corresponding line number.<br /> def printLines(self):<br /> i = 1<br /> for value in self.result:<br /> print(&quot;{:d}: {:d}&quot;.format(i, value))<br /> i = i+1<br /> <br /> <br /> import os<br /> <br /> lc = LineCounter(os.listdir(os.getcwd()))<br /> lc.printLines()<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> [Bash esercizio 3]<br /> &lt;syntaxhighlight lang=&quot;Bash&quot;&gt;<br /> #Esercizio 3: Script bash o Python: (10 punti):<br /> #Sia data una directory che contiene file di testo.<br /> #Scopo dell'esercizio e' di contare i caratteri delle corrispondenti righe di testo di tutti i file della directory, si vuole cioe' sapere<br /> #il numero totale di caratteri presenti nelle prime righe di tutti i file, nelle seconde linee, ecc.<br /> #$ ccpl mydir<br /> #1 234<br /> #2 21<br /> #3 333<br /> # .....<br /> #l'ouput significa che se contiamo tutti i caratteri contenuti nella prima riga di tutti i file in mydir otteniamo 234 (mydir/file1<br /> #puo' avere 40 caratteri nella prima riga, mydir/file2 ne puo' avere 20, ecc... procedendo per tutti i file di mydir la somma fa 234)<br /> <br /> #! bin/bash<br /> <br /> <br /> nline=1<br /> touch fileresult<br /> paste $1/* &gt; fileresult #merges every file's line from the directory passed to the file fileresult<br /> while read line; do<br /> count=$(echo $line | wc -m) #counts the number of char in each line of fileresult<br /> echo $nline $count<br /> nline=$(($nline + 1)) <br /> done &lt; fileresult<br /> rm fileresult<br /> &lt;/syntaxhighlight&gt;<br /> Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Producer%26Consumer_MP.&diff=484 2014-03-21T19:31:39Z

<p>Pirata: Created page with &quot;&lt;syntaxhighlight lang=&quot;C&quot;&gt; MP-sincrono dato quello asincrono Producer(){ produce(x); asend(x,Consumer); while(1){ areceive(Consumer); produce(x); asend(x,Consumer); ...&quot;</p> <hr /> <div>&lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> MP-sincrono dato quello asincrono<br /> <br /> Producer(){<br /> produce(x);<br /> asend(x,Consumer);<br /> while(1){<br /> areceive(Consumer);<br /> produce(x);<br /> asend(x,Consumer);<br /> }<br /> }<br /> <br /> <br /> Consumer(){<br /> while(1){<br /> x = areceive(Producer);<br /> consume(x);<br /> asend(ACK,Producer);<br /> }<br /> }<br /> <br /> <br /> <br /> <br /> MP-asincrono dato quello sincrono<br /> <br /> #include &lt;slideconcorrenzapg201.h&gt;<br /> <br /> Producer(){<br /> while(1){<br /> produce(x);<br /> asend(x,Consumer); <br /> }<br /> <br /> Consumer(){<br /> while(1){<br /> x=areceive(Producer);<br /> consume(x);<br /> }<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> Fede&amp;Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Main_Page&diff=483 2014-03-21T19:27:04Z

<p>Pirata: </p> <hr /> <div>Questo &amp;egrave; il Wiki del Corso di Sistemi Operativi<br /> <br /> [[Esercizi a caso del Prof.]]<br /> <br /> [[Decalogo di Programmazione Concorrente]]<br /> <br /> [[Python Programma tieni punteggio.]]<br /> <br /> [[Comandi visti alle lezioni.]]<br /> <br /> [[SYS CALL viste a lezione.]]<br /> <br /> [[Parametri con getopt().]]<br /> <br /> [[Funzione con numero variabile di parametri.]]<br /> <br /> [[stampf - implementazione ridotta della printf.]]<br /> <br /> [[Producer&amp;Consumer MP.]]<br /> <br /> [[ProvaPratica 2013.09.13]]<br /> <br /> [[ProvaPratica 2013.07.18]]<br /> <br /> [[ProvaPratica 2013.06.21]]<br /> <br /> [[ProvaPratica 2013.05.29]]<br /> <br /> [[ProvaPratica 2013.02.15]]<br /> <br /> [[ProvaPratica 2013.01.25]]<br /> <br /> [[ProvaTeoria_2011.07.25]]<br /> <br /> [[ProvaTeorica_2014.01.22]]<br /> <br /> [[ProvaTeorica_2012.02.09]]<br /> <br /> [[ProvaTeorica_2012.05.24]]<br /> <br /> [[ProvaTeorica_2012.06.15]]<br /> <br /> [[ProvaTeorica_2012.09.18]]<br /> <br /> [[ProvaTeorica_2013.02.15]]<br /> <br /> [[ProvaTeorica_2011.02.11]]<br /> <br /> [[ProvaTeorica 2013.07.19]]<br /> <br /> [[ProvaTeorica 2013.01.24]]<br /> ----<br /> Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Main_Page&diff=482 2014-03-21T19:26:00Z

<p>Pirata: </p> <hr /> <div>Questo &amp;egrave; il Wiki del Corso di Sistemi Operativi<br /> <br /> [[Esercizi a caso del Prof.]]<br /> <br /> [[Decalogo di Programmazione Concorrente]]<br /> <br /> [[Python Programma tieni punteggio.]]<br /> <br /> [[Comandi visti alle lezioni.]]<br /> <br /> [[SYS CALL viste a lezione.]]<br /> <br /> [[Parametri con getopt().]]<br /> <br /> [[Funzione con numero variabile di parametri.]]<br /> <br /> [[stampf - implementazione ridotta della printf.]]<br /> <br /> [[Producer&amp;Consumer MP]]<br /> <br /> [[ProvaPratica 2013.09.13]]<br /> <br /> [[ProvaPratica 2013.07.18]]<br /> <br /> [[ProvaPratica 2013.06.21]]<br /> <br /> [[ProvaPratica 2013.05.29]]<br /> <br /> [[ProvaPratica 2013.02.15]]<br /> <br /> [[ProvaPratica 2013.01.25]]<br /> <br /> [[ProvaTeoria_2011.07.25]]<br /> <br /> [[ProvaTeorica_2014.01.22]]<br /> <br /> [[ProvaTeorica_2012.02.09]]<br /> <br /> [[ProvaTeorica_2012.05.24]]<br /> <br /> [[ProvaTeorica_2012.06.15]]<br /> <br /> [[ProvaTeorica_2012.09.18]]<br /> <br /> [[ProvaTeorica_2013.02.15]]<br /> <br /> [[ProvaTeorica_2011.02.11]]<br /> <br /> [[ProvaTeorica 2013.07.19]]<br /> <br /> [[ProvaTeorica 2013.01.24]]<br /> ----<br /> Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Producer%26Consumer_MP-asincrono&diff=481 2014-03-21T19:25:38Z

<p>Pirata: </p> <hr /> <div>&lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> MP-sincrono dato quello asincrono <br /> <br /> Producer(){<br /> produce(x);<br /> asend(x,Consumer);<br /> while(1){<br /> areceive(Consumer);<br /> produce(x);<br /> asend(x,Consumer);<br /> }<br /> }<br /> <br /> <br /> Consumer(){<br /> while(1){<br /> x = areceive(Producer);<br /> consume(x);<br /> asend(ACK,Producer);<br /> }<br /> }<br /> <br /> <br /> <br /> <br /> MP-asincrono dato quello sincrono<br /> <br /> #include &lt;slideconcorrenzapg201.h&gt;<br /> <br /> Producer(){<br /> while(1){<br /> produce(x);<br /> asend(x,Consumer); <br /> }<br /> <br /> Consumer(){<br /> while(1){<br /> x=areceive(Producer);<br /> consume(x);<br /> }<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> Fede &amp; Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Producer%26Consumer_MP-asincrono&diff=480 2014-03-21T17:08:31Z

<p>Pirata: </p> <hr /> <div>&lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> MP-sincrono dato quello asincrono <br /> <br /> Procuder(){<br /> produce(x);<br /> asend(x,Consumer);<br /> while(1){<br /> areceive(Consumer);<br /> produce(x);<br /> asend(x,Consumer);<br /> }<br /> }<br /> <br /> <br /> Consumer(){<br /> while(1){<br /> x = areceive(Producer);<br /> consume(x);<br /> asend(ACK,Producer);<br /> }<br /> }<br /> <br /> <br /> <br /> <br /> MP-asincrono dato quello sincrono<br /> <br /> #include &lt;slideconcorrenzapg201.h&gt;<br /> <br /> Procuder(){<br /> while(1){<br /> produce(x);<br /> asend(x,Consumer); <br /> }<br /> <br /> Consumer(){<br /> while(1){<br /> x=areceive(Producer);<br /> consume(x);<br /> }<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> Fede &amp; Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Producer%26Consumer_MP-asincrono&diff=479 2014-03-21T17:05:03Z

<p>Pirata: </p> <hr /> <div>&lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> MP-asincrono <br /> <br /> Procuder(){<br /> produce(x);<br /> asend(x,Consumer);<br /> while(1){<br /> areceive(Consumer);<br /> produce(x);<br /> asend(x,Consumer);<br /> }<br /> }<br /> <br /> <br /> Consumer(){<br /> while(1){<br /> x = areceive(Producer);<br /> consume(x);<br /> asend(ACK,Producer);<br /> }<br /> }<br /> <br /> <br /> <br /> <br /> MP-asincrono dato quello sincrono<br /> <br /> #include &lt;slideconcorrenzapg201.h&gt;<br /> <br /> Procuder(){<br /> while(1){<br /> produce(x);<br /> asend(x,Consumer); <br /> }<br /> <br /> Consumer(){<br /> while(1){<br /> x=areceive(Producer);<br /> consume(x);<br /> }<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> Fede &amp; Pirata</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Producer%26Consumer_MP-asincrono&diff=478 2014-03-21T17:04:23Z

<p>Pirata: Created page with &quot;&lt;syntaxhighlight lang=&quot;C&quot;&gt; MP-asincrono Procuder(){ produce(x); asend(x,Consumer); while(1){ areceive(Consumer); produce(x); asend(x,Consumer); } } Consumer(){ ...&quot;</p> <hr /> <div>&lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> MP-asincrono <br /> <br /> Procuder(){<br /> produce(x);<br /> asend(x,Consumer);<br /> while(1){<br /> areceive(Consumer);<br /> produce(x);<br /> asend(x,Consumer);<br /> }<br /> }<br /> <br /> <br /> Consumer(){<br /> while(1){<br /> x = areceive(Producer);<br /> consume(x);<br /> asend(ACK,Producer);<br /> }<br /> }<br /> <br /> <br /> <br /> <br /> MP-asincrono dato quello sincrono<br /> <br /> #include &lt;slideconcorrenzapg201.h&gt;<br /> <br /> Procuder(){<br /> while(1){<br /> produce(x);<br /> asend(x,Consumer); <br /> }<br /> <br /> Consumer(){<br /> while(1){<br /> x=areceive(Producer);<br /> consume(x);<br /> }<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Main_Page&diff=477 2014-03-21T17:02:44Z

<p>Pirata: </p> <hr /> <div>Questo &amp;egrave; il Wiki del Corso di Sistemi Operativi<br /> <br /> [[Esercizi a caso del Prof.]]<br /> <br /> [[Decalogo di Programmazione Concorrente]]<br /> <br /> [[Python Programma tieni punteggio.]]<br /> <br /> [[Comandi visti alle lezioni.]]<br /> <br /> [[SYS CALL viste a lezione.]]<br /> <br /> [[Parametri con getopt().]]<br /> <br /> [[Funzione con numero variabile di parametri.]]<br /> <br /> [[stampf - implementazione ridotta della printf.]]<br /> <br /> [[Producer&amp;Consumer MP-asincrono]]<br /> <br /> [[ProvaPratica 2013.09.13]]<br /> <br /> [[ProvaPratica 2013.07.18]]<br /> <br /> [[ProvaPratica 2013.06.21]]<br /> <br /> [[ProvaPratica 2013.05.29]]<br /> <br /> [[ProvaPratica 2013.02.15]]<br /> <br /> [[ProvaPratica 2013.01.25]]<br /> <br /> [[ProvaTeoria_2011.07.25]]<br /> <br /> [[ProvaTeorica_2014.01.22]]<br /> <br /> [[ProvaTeorica_2012.02.09]]<br /> <br /> [[ProvaTeorica_2012.05.24]]<br /> <br /> [[ProvaTeorica_2012.06.15]]<br /> <br /> [[ProvaTeorica_2012.09.18]]<br /> <br /> [[ProvaTeorica_2013.02.15]]<br /> <br /> [[ProvaTeorica_2011.02.11]]<br /> <br /> [[ProvaTeorica 2013.07.19]]<br /> <br /> [[ProvaTeorica 2013.01.24]]<br /> ----<br /> Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=384 2013-12-04T10:48:16Z

<p>Pirata: /* SIGNAL */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparse file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparse file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparse file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===FUNZIONI SULLE DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;stdlib.h&gt;<br /> #include&lt;string.h&gt;<br /> #include&lt;dirent.h&gt;<br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int count;<br /> int i;<br /> struct dirent **de;<br /> count = scandir( argv[1] , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ ){<br /> printf(&quot;%s &quot;,de[i]-&gt;d_name);<br /> free(de[i]);<br /> }<br /> printf(&quot;\n&quot;);<br /> free(de);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ==Segnali==<br /> ===SIGNAL===<br /> <br /> Esempio1(programma riluttante a morire):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;signal.h&gt;<br /> <br /> void no( int sn )<br /> {<br /> printf(&quot;io non termino! %d\n&quot; , sn );<br /> }<br /> <br /> <br /> int main( int argc , char *argv )<br /> {<br /> signal( SIGTERM , no );<br /> signal( SIGINT , no );<br /> while(1){<br /> pause();<br /> printf(&quot;ciao\n&quot;);<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(il figlio termina):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;signal.h&gt;<br /> #include&lt;sys/types.h&gt;<br /> #include&lt;sys/wait.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> <br /> void child( int sn )<br /> {<br /> int status;<br /> wait(&amp;status);<br /> printf(&quot;il figlio termina! \n&quot; );<br /> }<br /> <br /> <br /> int main( int argc , char *argv )<br /> {<br /> signal( SIGCHLD , child );<br /> if ( fork() &gt; 0 ){<br /> while(1)<br /> pause();<br /> }<br /> else {<br /> sleep(3);<br /> exit(1);<br /> } <br /> }<br /> &lt;/syntaxhighlight&gt;<br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=383 2013-12-03T19:01:13Z

<p>Pirata: /* SIGNAL */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparse file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparse file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparse file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===FUNZIONI SULLE DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;stdlib.h&gt;<br /> #include&lt;string.h&gt;<br /> #include&lt;dirent.h&gt;<br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int count;<br /> int i;<br /> struct dirent **de;<br /> count = scandir( argv[1] , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ ){<br /> printf(&quot;%s &quot;,de[i]-&gt;d_name);<br /> free(de[i]);<br /> }<br /> printf(&quot;\n&quot;);<br /> free(de);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ==Segnali==<br /> ===SIGNAL===<br /> <br /> Esempio1(programma riluttante a morire):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;signal.h&gt;<br /> <br /> void no( int sn )<br /> {<br /> printf(&quot;io non termino! %d\n&quot; , sn );<br /> }<br /> <br /> <br /> int main( int arg , char *argv )<br /> {<br /> signal( SIGTERM , no );<br /> signal( SIGINT , no );<br /> while(1){<br /> pause();<br /> printf(&quot;ciao\n&quot;);<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(il figlio termina):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;signal.h&gt;<br /> #include&lt;sys/types.h&gt;<br /> #include&lt;sys/wait.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> <br /> void child( int sn )<br /> {<br /> int status;<br /> wait(&amp;status);<br /> printf(&quot;il figlio termina! \n&quot; );<br /> }<br /> <br /> <br /> int main( int arg , char *argv )<br /> {<br /> signal( SIGCHLD , child );<br /> if ( fork() &gt; 0 ){<br /> while(1)<br /> pause();<br /> }<br /> else {<br /> sleep(3);<br /> exit(1);<br /> } <br /> }<br /> &lt;/syntaxhighlight&gt;<br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=382 2013-12-03T18:41:44Z

<p>Pirata: /* SEGNALI */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparse file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparse file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparse file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===FUNZIONI SULLE DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;stdlib.h&gt;<br /> #include&lt;string.h&gt;<br /> #include&lt;dirent.h&gt;<br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int count;<br /> int i;<br /> struct dirent **de;<br /> count = scandir( argv[1] , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ ){<br /> printf(&quot;%s &quot;,de[i]-&gt;d_name);<br /> free(de[i]);<br /> }<br /> printf(&quot;\n&quot;);<br /> free(de);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ==Segnali==<br /> ===SIGNAL===<br /> <br /> Esempio1(programma riluttante a morire):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;signal.h&gt;<br /> <br /> void no( int sn )<br /> {<br /> printf(&quot;io non termino! %d\n&quot; , sn );<br /> }<br /> <br /> <br /> int main( int arg , char *argv )<br /> {<br /> signal( SIGTERM , no );<br /> signal( SIGINT , no );<br /> while(1){<br /> pause();<br /> printf(&quot;ciao\n&quot;);<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=381 2013-12-03T18:41:24Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparse file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparse file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparse file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===FUNZIONI SULLE DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;stdlib.h&gt;<br /> #include&lt;string.h&gt;<br /> #include&lt;dirent.h&gt;<br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int count;<br /> int i;<br /> struct dirent **de;<br /> count = scandir( argv[1] , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ ){<br /> printf(&quot;%s &quot;,de[i]-&gt;d_name);<br /> free(de[i]);<br /> }<br /> printf(&quot;\n&quot;);<br /> free(de);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ==SEGNALI==<br /> ===SIGNAL===<br /> <br /> Esempio1(programma riluttante a morire):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;signal.h&gt;<br /> <br /> void no( int sn )<br /> {<br /> printf(&quot;io non termino! %d\n&quot; , sn );<br /> }<br /> <br /> <br /> int main( int arg , char *argv )<br /> {<br /> signal( SIGTERM , no );<br /> signal( SIGINT , no );<br /> while(1){<br /> pause();<br /> printf(&quot;ciao\n&quot;);<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2013.05.29&diff=380 2013-12-03T18:16:57Z

<p>Pirata: </p> <hr /> <div>[Python 3]<br /> <br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> '''<br /> Prova Pratica di Laboratorio di Sistemi Operativi<br /> 29 maggio 2013<br /> Esercizio 3<br /> <br /> URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.05.29.pdf<br /> <br /> @author: Tommaso Ognibene<br /> '''<br /> <br /> import os, sys<br /> <br /> def Main(argv):<br /> # Check number of arguments<br /> if len(argv) != 2:<br /> print(&quot;The function requires one argument to be passed in.&quot;)<br /> return<br /> <br /> # Check parameters<br /> topDir = str(sys.argv[1])<br /> if not os.path.isdir(topDir):<br /> print(&quot;The parameter should be an existing directory.&quot;)<br /> return<br /> <br /> # Build a dictionary with key-value pair {file extension - total size}<br /> extensionSize = { }<br /> GetSize(topDir, extensionSize)<br /> <br /> # Print results<br /> PrintResults(extensionSize)<br /> <br /> def GetSize(topDir, extensionSize):<br /> for dirPath, dirNames, files in os.walk(topDir):<br /> for file in files:<br /> # 'example.mp3' -&gt; ['example', 'mp3']<br /> # 'example.tar.gz' -&gt; ['example', 'tar', 'gz']<br /> parts = file.split('.')<br /> # ['example', 'mp3'] -&gt; ['mp3']<br /> # ['example', 'tar', 'gz'] -&gt; ['tar', 'gz']<br /> parts = parts[1:]<br /> # ['mp3'] -&gt; '.mp3'<br /> # ['tar', 'gz'] -&gt; '.tar.gz'<br /> fileExtension = &quot;.{0}&quot;.format(&quot;.&quot;.join(str(part) for part in parts))<br /> <br /> # Compute the size in Bytes and update the dictionary<br /> filePath = os.path.join(dirPath, file) <br /> fileSize = os.path.getsize(filePath)<br /> extensionSize[fileExtension] = extensionSize.get(fileExtension, 0) + fileSize<br /> <br /> # Print results<br /> def PrintResults(extensionSize):<br /> for key, value in sorted(extensionSize.items()):<br /> print('{0}: {1} Bytes.'.format(key, value))<br /> <br /> if __name__ == &quot;__main__&quot;:<br /> sys.exit(Main(sys.argv))<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ----<br /> <br /> mia versione<br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> import os, sys, copy<br /> <br /> def dotsubstr(a):#restituisce la sottostringa .suffisso<br /> #fcd = os.listdir('{0}'.format(arg1))<br /> i=0<br /> try:<br /> while a[i]!='.':<br /> i=i+1<br /> return a[i:]<br /> except IndexError:<br /> return -1<br /> <br /> def compliarg(li,arg):#restituisce una lista di tutti gli elementi contenenti la sottostringa arg come suffisso<br /> res=[]<br /> while li != []:<br /> a=li.pop()<br /> if a.endswith(arg): res.append(a)<br /> return res<br /> <br /> def listremintsect(l2,l1):#restituisce una lista res = l1 - intersezione di l1 ed l2<br /> res=[]<br /> while l1 != []:<br /> a=l1.pop()<br /> if not a in l2: res.append(a)<br /> return res<br /> <br /> def createpathlist(c,path):#restituisce una lista di path 'path' relativi ai file contenuti in c.<br /> res = []<br /> while c != []:<br /> res.append('{0}/{1}'.format(path,c.pop()))<br /> return res<br /> <br /> def totsizes(d): #data una lista d di path restituisce la somma di tutti i size di d<br /> res = 0<br /> while d != []:<br /> a = d.pop()<br /> if os.path.isfile('{0}'.format(a)):<br /> res = res + os.path.getsize('{0}'.format(a))<br /> return res<br /> <br /> def listsubstr(arg): #ritorna un dizionario del tipo diz[str(suffisso)] = int(size relativo al suffisso)<br /> res = {}<br /> fcd = os.listdir('{0}'.format(arg))<br /> while fcd != []:<br /> fcdtmp=copy.deepcopy(fcd) #BUGGONE SENZA COPY!!!!!!<br /> a = fcd.pop()<br /> b = dotsubstr(a)<br /> if b == -1: continue<br /> else: pass<br /> c = compliarg(fcdtmp,b)<br /> s=copy.deepcopy(c) #!!!!!!!!!!!!!!!!!!!!!!!!!<br /> d = createpathlist(c,arg)<br /> res[b] = totsizes(d)<br /> <br /> fcd = listremintsect(s,fcd)<br /> <br /> return res<br /> <br /> <br /> try:<br /> res = listsubstr(sys.argv[1])<br /> a=list(res.keys())<br /> while a != []:<br /> b = a.pop()<br /> print('{0}:\t{1}'.format(b,res[b]))<br /> except OSError:<br /> print(&quot;Could not solve path&quot;)<br /> <br /> &lt;/syntaxhighlight&gt;<br /> -fede<br /> <br /> <br /> <br /> ----<br /> <br /> Esercizio 1: Linguaggio C<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;sys/eventfd.h&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> #define BUFFSIZE 10<br /> <br /> int main(int argc, char *argv[]){<br /> int efd,n,i;<br /> char buf1[BUFFSIZE];<br /> char buf2[BUFFSIZE];<br /> <br /> do{<br /> efd = eventfd(0,0);<br /> }while(efd&lt;0);<br /> <br /> while(1){<br /> if(fork()){ /*padre*/<br /> read(0,buf1,sizeof(buf1)); /*0 indica lo standard input*/<br /> write(efd, buf1, sizeof(buf1));<br /> }<br /> <br /> else{ /*figlio*/<br /> read(efd, buf2, sizeof(buf2));<br /> n=atoi(buf2);<br /> for(i=0; i&lt;n; i++) printf(&quot;x\n&quot;);<br /> }<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> GiuliaN. con grande aiuto da parte dei colleghi<br /> <br /> <br /> <br /> <br /> Esercizio 1:(visto a lezione , soluzione del Prof. Davoli Pirata_20131203)<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;sys/eventfd.h&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdint.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> #define BUFFSIZE 10<br /> <br /> int main(int argc, char *argv[]){<br /> int efd , n , i;<br /> uint64_t a , b;<br /> if ( ( efd = eventfd( 0 , EFD_SEMAPHORE ) ) &lt; 0 )<br /> exit( 1 );<br /> if ( fork() &gt; 0 ){<br /> while ( 1 ) {<br /> uint64_t a;<br /> scanf( &quot;%lld&quot; , &amp;a );<br /> write( efd , &amp;a , sizeof( a ) );<br /> }<br /> }<br /> else {<br /> while ( 1 ) {<br /> uint64_t b;<br /> read( efd , &amp;b , sizeof( b ) );<br /> printf( &quot;x\n&quot; );<br /> }<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> Esercizio 3 in bash(Pirata &amp; Fede):<br /> <br /> &lt;syntaxhighlight lang=&quot;bash&quot;&gt;<br /> #! /bin/bash<br /> <br /> for f in &quot;$1&quot;/*.* ; do<br /> somma=0<br /> ext=${f##*.}<br /> for file in *.&quot;$ext&quot;<br /> do<br /> somma=$(expr $somma + $(stat -c%s &quot;$file&quot;))<br /> done<br /> echo -n &quot;size of file with extension &quot;$ext&quot; : &quot;<br /> echo &quot;$somma&quot;<br /> done<br /> &lt;/syntaxhighlight&gt;<br /> Per (Pirata &amp; Fede) -Bash-: ci siamo quasi...però forse rifate gli stessi calcoli un po' di volte in più del necessario ;-) (am_20131127).<br /> <br /> <br /> ----<br /> <br /> [Esercizio 3 in Python (ancora)]<br /> <br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> #!/usr/bin/env python3<br /> #<br /> # Prova Pratica di Lab SO 2013.05.29<br /> # Es. 3<br /> # Eduardo Santarelli<br /> #####################################<br /> <br /> import os, sys<br /> <br /> # return the suffix of file named fname, if present.<br /> # return boolean value False otherwise<br /> def get_suffix(fname):<br /> if '.' in fname:<br /> separator = fname.find('.')<br /> return fname[separator : ]<br /> else:<br /> return False <br /> <br /> # Place a file in a dictionary. Each key corresponds<br /> # to a specific suffix, its value is a list of all the<br /> # file with that suffix<br /> def build_dict(item, suffix):<br /> if suffix in all_files:<br /> all_files[suffix].append(item)<br /> else:<br /> all_files[suffix] = []<br /> all_files[suffix].append(item)<br /> <br /> # For each suffix key in the dictionary,<br /> # calculates the total size of the files<br /> # in the corresponding list<br /> def size_of_entry(file_list):<br /> size = 0<br /> for item in file_list:<br /> size += os.path.getsize(item)<br /> return size<br /> <br /> # This dictionary will contain a key for each suffix,<br /> # associated with a list of all the files ending with<br /> # that suffix<br /> all_files = dict()<br /> <br /> # Go to target directory and build a list containing all filenames<br /> try:<br /> target_dir = sys.argv[1]<br /> except:<br /> target_dir = '.'<br /> os.chdir(target_dir)<br /> dir_list = os.listdir('.')<br /> <br /> # For each file call get_suffix and then build_dict<br /> # (unless get_suffix returns False)<br /> for item in dir_list:<br /> suffix = get_suffix(item)<br /> if not suffix:<br /> pass<br /> else:<br /> build_dict(item, suffix)<br /> <br /> for key in all_files :<br /> print(&quot;{0}: {1} Bytes&quot;.format(key, size_of_entry(all_files[key])))<br /> &lt;/syntaxhighlight&gt;<br /> -Eduardo<br /> --edit: dir_list = os.listdir(target_dir) non funzionava bene coi path relativi.<br /> Ora os.listdir('.') dovrebbe andare bene.</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2013.05.29&diff=379 2013-12-03T18:16:06Z

<p>Pirata: </p> <hr /> <div>[Python 3]<br /> <br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> '''<br /> Prova Pratica di Laboratorio di Sistemi Operativi<br /> 29 maggio 2013<br /> Esercizio 3<br /> <br /> URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.05.29.pdf<br /> <br /> @author: Tommaso Ognibene<br /> '''<br /> <br /> import os, sys<br /> <br /> def Main(argv):<br /> # Check number of arguments<br /> if len(argv) != 2:<br /> print(&quot;The function requires one argument to be passed in.&quot;)<br /> return<br /> <br /> # Check parameters<br /> topDir = str(sys.argv[1])<br /> if not os.path.isdir(topDir):<br /> print(&quot;The parameter should be an existing directory.&quot;)<br /> return<br /> <br /> # Build a dictionary with key-value pair {file extension - total size}<br /> extensionSize = { }<br /> GetSize(topDir, extensionSize)<br /> <br /> # Print results<br /> PrintResults(extensionSize)<br /> <br /> def GetSize(topDir, extensionSize):<br /> for dirPath, dirNames, files in os.walk(topDir):<br /> for file in files:<br /> # 'example.mp3' -&gt; ['example', 'mp3']<br /> # 'example.tar.gz' -&gt; ['example', 'tar', 'gz']<br /> parts = file.split('.')<br /> # ['example', 'mp3'] -&gt; ['mp3']<br /> # ['example', 'tar', 'gz'] -&gt; ['tar', 'gz']<br /> parts = parts[1:]<br /> # ['mp3'] -&gt; '.mp3'<br /> # ['tar', 'gz'] -&gt; '.tar.gz'<br /> fileExtension = &quot;.{0}&quot;.format(&quot;.&quot;.join(str(part) for part in parts))<br /> <br /> # Compute the size in Bytes and update the dictionary<br /> filePath = os.path.join(dirPath, file) <br /> fileSize = os.path.getsize(filePath)<br /> extensionSize[fileExtension] = extensionSize.get(fileExtension, 0) + fileSize<br /> <br /> # Print results<br /> def PrintResults(extensionSize):<br /> for key, value in sorted(extensionSize.items()):<br /> print('{0}: {1} Bytes.'.format(key, value))<br /> <br /> if __name__ == &quot;__main__&quot;:<br /> sys.exit(Main(sys.argv))<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ----<br /> <br /> mia versione<br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> import os, sys, copy<br /> <br /> def dotsubstr(a):#restituisce la sottostringa .suffisso<br /> #fcd = os.listdir('{0}'.format(arg1))<br /> i=0<br /> try:<br /> while a[i]!='.':<br /> i=i+1<br /> return a[i:]<br /> except IndexError:<br /> return -1<br /> <br /> def compliarg(li,arg):#restituisce una lista di tutti gli elementi contenenti la sottostringa arg come suffisso<br /> res=[]<br /> while li != []:<br /> a=li.pop()<br /> if a.endswith(arg): res.append(a)<br /> return res<br /> <br /> def listremintsect(l2,l1):#restituisce una lista res = l1 - intersezione di l1 ed l2<br /> res=[]<br /> while l1 != []:<br /> a=l1.pop()<br /> if not a in l2: res.append(a)<br /> return res<br /> <br /> def createpathlist(c,path):#restituisce una lista di path 'path' relativi ai file contenuti in c.<br /> res = []<br /> while c != []:<br /> res.append('{0}/{1}'.format(path,c.pop()))<br /> return res<br /> <br /> def totsizes(d): #data una lista d di path restituisce la somma di tutti i size di d<br /> res = 0<br /> while d != []:<br /> a = d.pop()<br /> if os.path.isfile('{0}'.format(a)):<br /> res = res + os.path.getsize('{0}'.format(a))<br /> return res<br /> <br /> def listsubstr(arg): #ritorna un dizionario del tipo diz[str(suffisso)] = int(size relativo al suffisso)<br /> res = {}<br /> fcd = os.listdir('{0}'.format(arg))<br /> while fcd != []:<br /> fcdtmp=copy.deepcopy(fcd) #BUGGONE SENZA COPY!!!!!!<br /> a = fcd.pop()<br /> b = dotsubstr(a)<br /> if b == -1: continue<br /> else: pass<br /> c = compliarg(fcdtmp,b)<br /> s=copy.deepcopy(c) #!!!!!!!!!!!!!!!!!!!!!!!!!<br /> d = createpathlist(c,arg)<br /> res[b] = totsizes(d)<br /> <br /> fcd = listremintsect(s,fcd)<br /> <br /> return res<br /> <br /> <br /> try:<br /> res = listsubstr(sys.argv[1])<br /> a=list(res.keys())<br /> while a != []:<br /> b = a.pop()<br /> print('{0}:\t{1}'.format(b,res[b]))<br /> except OSError:<br /> print(&quot;Could not solve path&quot;)<br /> <br /> &lt;/syntaxhighlight&gt;<br /> -fede<br /> <br /> <br /> <br /> ----<br /> <br /> Esercizio 1: Linguaggio C<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;sys/eventfd.h&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> #define BUFFSIZE 10<br /> <br /> int main(int argc, char *argv[]){<br /> int efd,n,i;<br /> char buf1[BUFFSIZE];<br /> char buf2[BUFFSIZE];<br /> <br /> do{<br /> efd = eventfd(0,0);<br /> }while(efd&lt;0);<br /> <br /> while(1){<br /> if(fork()){ /*padre*/<br /> read(0,buf1,sizeof(buf1)); /*0 indica lo standard input*/<br /> write(efd, buf1, sizeof(buf1));<br /> }<br /> <br /> else{ /*figlio*/<br /> read(efd, buf2, sizeof(buf2));<br /> n=atoi(buf2);<br /> for(i=0; i&lt;n; i++) printf(&quot;x\n&quot;);<br /> }<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> GiuliaN. con grande aiuto da parte dei colleghi<br /> <br /> <br /> <br /> <br /> Esercizio 1:(visto a lezione , soluzione del Prof. Davoli Pirata_20131203)<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;sys/eventfd.h&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdint.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> #define BUFFSIZE 10<br /> <br /> int main(int argc, char *argv[]){<br /> int efd , n , i;<br /> uint64_t a , b;<br /> if ( ( efd = eventfd( 0 , EFD_SEMAPHORE ) ) &lt; 0 )<br /> exit( 1 );<br /> if ( fork() &gt; 0 ){<br /> while ( 1 ) {<br /> uint64_t a;<br /> scanf( &quot;%lld&quot; , &amp;a );<br /> write( efd , &amp;a , sizeof( a ) );<br /> }<br /> }<br /> else {<br /> while ( 1 ) {<br /> uint64_t b;<br /> read( efd , &amp;b , sizeof( b ) );<br /> //for ( i = 0 ; i &lt; b ; i++ ) <br /> printf( &quot;x\n&quot; );<br /> }<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> Esercizio 3 in bash(Pirata &amp; Fede):<br /> <br /> &lt;syntaxhighlight lang=&quot;bash&quot;&gt;<br /> #! /bin/bash<br /> <br /> for f in &quot;$1&quot;/*.* ; do<br /> somma=0<br /> ext=${f##*.}<br /> for file in *.&quot;$ext&quot;<br /> do<br /> somma=$(expr $somma + $(stat -c%s &quot;$file&quot;))<br /> done<br /> echo -n &quot;size of file with extension &quot;$ext&quot; : &quot;<br /> echo &quot;$somma&quot;<br /> done<br /> &lt;/syntaxhighlight&gt;<br /> Per (Pirata &amp; Fede) -Bash-: ci siamo quasi...però forse rifate gli stessi calcoli un po' di volte in più del necessario ;-) (am_20131127).<br /> <br /> <br /> ----<br /> <br /> [Esercizio 3 in Python (ancora)]<br /> <br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> #!/usr/bin/env python3<br /> #<br /> # Prova Pratica di Lab SO 2013.05.29<br /> # Es. 3<br /> # Eduardo Santarelli<br /> #####################################<br /> <br /> import os, sys<br /> <br /> # return the suffix of file named fname, if present.<br /> # return boolean value False otherwise<br /> def get_suffix(fname):<br /> if '.' in fname:<br /> separator = fname.find('.')<br /> return fname[separator : ]<br /> else:<br /> return False <br /> <br /> # Place a file in a dictionary. Each key corresponds<br /> # to a specific suffix, its value is a list of all the<br /> # file with that suffix<br /> def build_dict(item, suffix):<br /> if suffix in all_files:<br /> all_files[suffix].append(item)<br /> else:<br /> all_files[suffix] = []<br /> all_files[suffix].append(item)<br /> <br /> # For each suffix key in the dictionary,<br /> # calculates the total size of the files<br /> # in the corresponding list<br /> def size_of_entry(file_list):<br /> size = 0<br /> for item in file_list:<br /> size += os.path.getsize(item)<br /> return size<br /> <br /> # This dictionary will contain a key for each suffix,<br /> # associated with a list of all the files ending with<br /> # that suffix<br /> all_files = dict()<br /> <br /> # Go to target directory and build a list containing all filenames<br /> try:<br /> target_dir = sys.argv[1]<br /> except:<br /> target_dir = '.'<br /> os.chdir(target_dir)<br /> dir_list = os.listdir('.')<br /> <br /> # For each file call get_suffix and then build_dict<br /> # (unless get_suffix returns False)<br /> for item in dir_list:<br /> suffix = get_suffix(item)<br /> if not suffix:<br /> pass<br /> else:<br /> build_dict(item, suffix)<br /> <br /> for key in all_files :<br /> print(&quot;{0}: {1} Bytes&quot;.format(key, size_of_entry(all_files[key])))<br /> &lt;/syntaxhighlight&gt;<br /> -Eduardo<br /> --edit: dir_list = os.listdir(target_dir) non funzionava bene coi path relativi.<br /> Ora os.listdir('.') dovrebbe andare bene.</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=ProvaPratica_2013.05.29&diff=361 2013-11-26T22:42:02Z

<p>Pirata: </p> <hr /> <div>[Python 3]<br /> <br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> '''<br /> Prova Pratica di Laboratorio di Sistemi Operativi<br /> 29 maggio 2013<br /> Esercizio 3<br /> <br /> URL: http://www.cs.unibo.it/~renzo/so/pratiche/2013.05.29.pdf<br /> <br /> @author: Tommaso Ognibene<br /> '''<br /> <br /> import os, sys<br /> <br /> def Main(argv):<br /> # Check number of arguments<br /> if len(argv) != 2:<br /> print(&quot;The function requires one argument to be passed in.&quot;)<br /> return<br /> <br /> # Check parameters<br /> topDir = str(sys.argv[1])<br /> if not os.path.isdir(topDir):<br /> print(&quot;The parameter should be an existing directory.&quot;)<br /> return<br /> <br /> # Build a dictionary with key-value pair {file extension - total size}<br /> extensionSize = { }<br /> GetSize(topDir, extensionSize)<br /> <br /> # Print results<br /> PrintResults(extensionSize)<br /> <br /> def GetSize(topDir, extensionSize):<br /> for dirPath, dirNames, files in os.walk(topDir):<br /> for file in files:<br /> # 'example.mp3' -&gt; ['example', 'mp3']<br /> # 'example.tar.gz' -&gt; ['example', 'tar', 'gz']<br /> parts = file.split('.')<br /> # ['example', 'mp3'] -&gt; ['mp3']<br /> # ['example', 'tar', 'gz'] -&gt; ['tar', 'gz']<br /> parts = parts[1:]<br /> # ['mp3'] -&gt; '.mp3'<br /> # ['tar', 'gz'] -&gt; '.tar.gz'<br /> fileExtension = &quot;.{0}&quot;.format(&quot;.&quot;.join(str(part) for part in parts))<br /> <br /> # Compute the size in Bytes and update the dictionary<br /> filePath = os.path.join(dirPath, file) <br /> fileSize = os.path.getsize(filePath)<br /> extensionSize[fileExtension] = extensionSize.get(fileExtension, 0) + fileSize<br /> <br /> # Print results<br /> def PrintResults(extensionSize):<br /> for key, value in sorted(extensionSize.items()):<br /> print('{0}: {1} Bytes.'.format(key, value))<br /> <br /> if __name__ == &quot;__main__&quot;:<br /> sys.exit(Main(sys.argv))<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ----<br /> <br /> mia versione<br /> &lt;syntaxhighlight lang=&quot;Python&quot;&gt;<br /> import os, sys, copy<br /> <br /> def dotsubstr(a):#restituisce la sottostringa .suffisso<br /> #fcd = os.listdir('{0}'.format(arg1))<br /> i=0<br /> try:<br /> while a[i]!='.':<br /> i=i+1<br /> return a[i:]<br /> except IndexError:<br /> return -1<br /> <br /> def compliarg(li,arg):#restituisce una lista di tutti gli elementi contenenti la sottostringa arg come suffisso<br /> res=[]<br /> while li != []:<br /> a=li.pop()<br /> if a.endswith(arg): res.append(a)<br /> return res<br /> <br /> def listremintsect(l2,l1):#restituisce una lista res = l1 - intersezione di l1 ed l2<br /> res=[]<br /> while l1 != []:<br /> a=l1.pop()<br /> if not a in l2: res.append(a)<br /> return res<br /> <br /> def createpathlist(c,path):#restituisce una lista di path 'path' relativi ai file contenuti in c.<br /> res = []<br /> while c != []:<br /> res.append('{0}/{1}'.format(path,c.pop()))<br /> return res<br /> <br /> def totsizes(d): #data una lista d di path restituisce la somma di tutti i size di d<br /> res = 0<br /> while d != []:<br /> a = d.pop()<br /> if os.path.isfile('{0}'.format(a)):<br /> res = res + os.path.getsize('{0}'.format(a))<br /> return res<br /> <br /> def listsubstr(arg): #ritorna un dizionario del tipo diz[str(suffisso)] = int(size relativo al suffisso)<br /> res = {}<br /> fcd = os.listdir('{0}'.format(arg))<br /> while fcd != []:<br /> fcdtmp=copy.deepcopy(fcd) #BUGGONE SENZA COPY!!!!!!<br /> a = fcd.pop()<br /> b = dotsubstr(a)<br /> if b == -1: continue<br /> else: pass<br /> c = compliarg(fcdtmp,b)<br /> s=copy.deepcopy(c) #!!!!!!!!!!!!!!!!!!!!!!!!!<br /> d = createpathlist(c,arg)<br /> res[b] = totsizes(d)<br /> <br /> fcd = listremintsect(s,fcd)<br /> <br /> return res<br /> <br /> <br /> try:<br /> res = listsubstr(sys.argv[1])<br /> a=list(res.keys())<br /> while a != []:<br /> b = a.pop()<br /> print('{0}:\t{1}'.format(b,res[b]))<br /> except OSError:<br /> print(&quot;Could not solve path&quot;)<br /> <br /> &lt;/syntaxhighlight&gt;<br /> -fede<br /> <br /> <br /> <br /> ----<br /> <br /> Esercizio 1: Linguaggio C<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;sys/eventfd.h&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> #define BUFFSIZE 10<br /> <br /> int main(int argc, char *argv[]){<br /> int efd,n,i;<br /> char buf1[BUFFSIZE];<br /> char buf2[BUFFSIZE];<br /> <br /> do{<br /> efd = eventfd(0,0);<br /> }while(efd&lt;0);<br /> <br /> while(1){<br /> if(fork()){ /*padre*/<br /> read(0,buf1,sizeof(buf1)); /*0 indica lo standard input*/<br /> write(efd, buf1, sizeof(buf1));<br /> }<br /> <br /> else{ /*figlio*/<br /> read(efd, buf2, sizeof(buf2));<br /> n=atoi(buf2);<br /> for(i=0; i&lt;n; i++) printf(&quot;x\n&quot;);<br /> }<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> GiuliaN. con grande aiuto da parte dei colleghi<br /> <br /> <br /> <br /> Esercizio 3 in bash(Pirata &amp; Fede):<br /> <br /> &lt;syntaxhighlight lang=&quot;bash&quot;&gt;<br /> #! /bin/bash<br /> <br /> for f in *.*<br /> do<br /> somma=0<br /> ext=${f##*.}<br /> for file in *.$ext<br /> do<br /> somma=$(expr $somma + $(stat -c%s &quot;$file&quot;))<br /> done<br /> echo -n &quot;size of file with extension $ext : &quot;<br /> echo &quot;$somma&quot;<br /> done<br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=329 2013-11-24T15:55:23Z

<p>Pirata: /* DIRECTORY */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparsify file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===FUNZIONI SULLE DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;stdlib.h&gt;<br /> #include&lt;string.h&gt;<br /> #include&lt;dirent.h&gt;<br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int count;<br /> int i;<br /> struct dirent **de;<br /> count = scandir( argv[1] , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ ){<br /> printf(&quot;%s &quot;,de[i]-&gt;d_name);<br /> free(de[i]);<br /> }<br /> printf(&quot;\n&quot;);<br /> free(de);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=328 2013-11-24T15:54:37Z

<p>Pirata: /* DIRECTORY */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparsify file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;stdlib.h&gt;<br /> #include&lt;string.h&gt;<br /> #include&lt;dirent.h&gt;<br /> <br /> <br /> int main( int argc , char *argv[] ){<br /> int count;<br /> int i;<br /> struct dirent **de;<br /> count = scandir( argv[1] , &amp;de , NULL , alphasort );<br /> for ( i = 0 ; i &lt; count ; i++ ){<br /> printf(&quot;%s &quot;,de[i]-&gt;d_name);<br /> free(de[i]);<br /> }<br /> printf(&quot;\n&quot;);<br /> free(de);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=326 2013-11-24T15:20:12Z

<p>Pirata: /* DUP */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparsify file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===DIRECTORY===<br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;dirent.h&gt;<br /> <br /> <br /> int mystrcmp( const void *a , const void *b ){<br /> char **pa = (char **)a;<br /> char **pb = (char **)b;<br /> return strcmp( *pa , *pb );<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> DIR *d;<br /> struct dirent *de;<br /> char **names;<br /> int i , count = 0;<br /> d = opendir( argv[1] ); <br /> while( ( de = readdir(d) ) != NULL )<br /> count++;<br /> rewinddir(d);<br /> names = (char **)calloc( count , sizeof(char *) );<br /> count=0;<br /> while( ( de = readdir(d) ) != NULL )<br /> names[count++] = strdup( de-&gt;d_name );<br /> closedir(d);<br /> qsort( names , count , sizeof(char *) , mystrcmp );<br /> for( i = 0 ; i &lt; count ; i++ )<br /> printf(&quot; %s &quot;, names[i] );<br /> printf(&quot;\n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=324 2013-11-24T14:31:19Z

<p>Pirata: /* LSEEK/READ */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> <br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparsify file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=323 2013-11-24T14:30:43Z

<p>Pirata: /* LSEEK/READ */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024<br /> <br /> char buff[BUFFSIZE]; <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio3(copia di uno sparsify file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=321 2013-11-24T00:41:39Z

<p>Pirata: /* DUP */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio3(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd); //dup2(fd,1) produce lo stesso effetto<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=320 2013-11-24T00:39:27Z

<p>Pirata: /* LSEEK */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK/READ===<br /> <br /> <br /> *Lseek: sposta l'offset del file descriptor.<br /> *Read: legge da un file descriptor.<br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio3(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd);<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=319 2013-11-24T00:37:47Z

<p>Pirata: /* OPEN/WRITE/CLOSE/LSEEK/TRUNCATE */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> <br /> <br /> Esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===LSEEK===<br /> *Lseek: sposta l'offset del file descriptor.<br /> <br /> Esempio1(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Esempio2(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> Esempio3(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> ===TRUNCATE===<br /> <br /> <br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> Esempio(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> ===DUP===<br /> <br /> *Dup: duplica il file descriptor.<br /> <br /> Esempio:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include&lt;stdio.h&gt;<br /> #include&lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> int main( int argc , char *argv[]){<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> close(1);<br /> dup(fd);<br /> printf(&quot;Hello World \n&quot;);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=318 2013-11-23T23:48:01Z

<p>Pirata: /* OPEN/WRITE/CLOSE/LSEEK/TRUNCATE */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK/TRUNCATE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> *Lseek: sposta l'offset del file descriptor.<br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> esempio5(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=317 2013-11-23T23:47:12Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK/TRUNCATE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> *Lseek: sposta l'offset del file descriptor.<br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio4(Buffer ed efficienza):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> /*eseguire lo script di cui sotto in modo da osservare come il buffer modifichi l'efficienza della copia per blocchi di byte<br /> <br /> dd if=/dev/urandom of=casual bs=1024 count=102400<br /> for size in 128 256 512 1024 2048 4096<br /> do <br /> time ./eseguibile casual ricasual $size<br /> done<br /> */<br /> <br /> <br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> }<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> int buffsize = atoi( argv[3] );<br /> char buff[buffsize];<br /> ssize_t n;<br /> while( ( n = read( fin , buff , buffsize ) ) != 0 ){<br /> if (isEmpty( buff , n ) )<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio5(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=316 2013-11-23T23:30:59Z

<p>Pirata: /* OPEN/WRITE/CLOSE/LSEEK/TRUNCATE */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK/TRUNCATE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> *Lseek: sposta l'offset del file descriptor.<br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> esempio4(viene usata per creare File Buco Nero):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=297 2013-11-23T13:11:31Z

<p>Pirata: /* OPEN/WRITE/CLOSE/LSEEK/TRUNCATE */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK/TRUNCATE===<br /> <br /> *Open: apre e possibilmente crea un file o un device.<br /> *Write: scrive su il file descriptor.<br /> *Close: chiude il file descriptor.<br /> *Lseek: sposta l'offset del file descriptor.<br /> *Truncate: tronca il file a una specifica lunghezza.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> esempio4:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=296 2013-11-23T13:10:46Z

<p>Pirata: /* OPEN/WRITE/CLOSE/LSEEK/TRUNCATE */</p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK/TRUNCATE===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor.<br /> Close: chiude il file descriptor.<br /> Lseek: sposta l'offset del file descriptor.<br /> Truncate: tronca il file a una specifica lunghezza.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> esempio4:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=295 2013-11-23T13:09:51Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK/TRUNCATE===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor.<br /> Close: chiude il file descriptor.<br /> Lseek: sposta l'offset del file descriptor.<br /> Truncate: tronca il file a una specifica lunghezza.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio4:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> <br /> int main( int argc , char *argv[] ) {<br /> int fd = open( argv[1] , O_WRONLY | O_CREAT | O_TRUNC , 0666 );<br /> ftruncate( fd , atoi( argv[2] ) );<br /> close( fd );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=277 2013-11-21T23:14:44Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> <br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor.<br /> Close: chiude il file descriptor.<br /> Lseek: sposta l'offset del file descriptor.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=276 2013-11-21T23:12:23Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-<br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor.<br /> Close: chiude il file descriptor.<br /> Lseek: sposta l'offset del file descriptor.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio3(copia di un file):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> #define BUFFSIZE 1024 //la copia avviene per blocchi di 1024B<br /> <br /> char buff[BUFFSIZE];<br /> <br /> int isEmpty( char *s , int l ){<br /> int i;<br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) return (0);<br /> return(1);<br /> <br /> <br /> # if 0<br /> for ( i = 0 ; ( i &lt; l ) &amp;&amp; ( s[i] != 0 ) ; i++ )<br /> ;<br /> return ( i == l ); //codice più compatto <br /> <br /> <br /> for( i = 0 ; i &lt; l ; i++ )<br /> if( s[i] != 0 ) goto nonempty;<br /> return1;<br /> nonempty:<br /> return0; //in stile kernel <br /> #endif<br /> } <br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fin = open( argv[1] , O_RDONLY );<br /> int fout = open( argv[2] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> ssize_t n;<br /> while( ( n = read( fin , buff , BUFFSIZE ) ) != 0 ){<br /> if (isEmpty( buff , n ) ) //il codice in questo esempio é ottimizzato per gli sparsify file.<br /> lseek( fout , n , SEEK_CUR );<br /> else<br /> write( fout , buff , n );<br /> }<br /> close( fin);<br /> close( fout);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=272 2013-11-21T22:15:03Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-<br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor.<br /> Close: chiude il file descriptor.<br /> Lseek: sposta l'offset del file descriptor.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2(sparsify file o file ciambella):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> lseek( fd, 1000000 , SEEK_SET );<br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=271 2013-11-21T22:06:08Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-<br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE/LSEEK===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor passato.<br /> Close: chiude il file descriptor passato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=270 2013-11-21T22:00:10Z

<p>Pirata: </p> <hr /> <div>==Controllo processi==<br /> ===FORK===<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===_EXIT===<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===WAIT===<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> ===EXEC===<br /> Esegue un programma.<br /> La famiglia di funzioni exec() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-<br /> <br /> ==Gestione File==<br /> * int open(const char *path, int oflag, ...);&lt;br/&gt;<br /> * int creat(const char *path, mode_t mode);<br /> * int close(int filedes);<br /> * off_t lseek(int filedes, off_t offset, int whence);<br /> * ssize_t read(int filedes, void *buf, size_t nbyte);<br /> * ssize_t write(int filedes, const void *buf, size_t nbyte);<br /> <br /> Qualche esempio? Iniziamo con i file &quot;con il buco&quot; visti a lezione?<br /> <br /> <br /> <br /> ===OPEN/WRITE/CLOSE===<br /> <br /> Open: apre e possibilmente crea un file o un device.<br /> Write: scrive su il file descriptor passato.<br /> Close: chiude il file descriptor passato.<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/stat.h&gt;<br /> #include &lt;fcntl.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;string.h&gt;<br /> <br /> <br /> <br /> int main ( int argc , char *argv[] ){<br /> int fd = open( argv[1] , O_RDWR | O_CREAT | O_TRUNC ,0666); <br /> write( fd , argv[2] , strlen( argv[2] ) );<br /> close( fd);<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=185 2013-11-10T13:50:00Z

<p>Pirata: </p> <hr /> <div>* FORK<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *_EXIT<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> * WAIT<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *EXECVE<br /> Esegue un programma.<br /> La famiglia di funzioni exe() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Funzione_con_numero_variabile_di_parametri.&diff=184 2013-11-10T13:49:17Z

<p>Pirata: </p> <hr /> <div>Esempio di funzione che prende in argomento un numero variable di parametri:<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdarg.h&gt;<br /> <br /> void foo(int narg, ... ) //narg é il numero di argomenti che verranno passati<br /> {<br /> int i;<br /> va_list ap; //Il tipo di dato va_list é una lista di variabili<br /> va_start(ap,narg); // Macro che inizializza ap<br /> for ( i = 0 ; i &lt; narg ; i++) {<br /> int this = va_arg( ap , int ); //Macro che dice il tipo e il valore che deve<br /> printf(&quot; %d &quot;, this); //avere il prossimo argomento della chiamata<br /> }<br /> printf(&quot;\n&quot;);<br /> va_end(ap); //Macro che chiude la macro di inizializzazione <br /> }<br /> <br /> int main ( int argc , char *argv)<br /> {<br /> foo( 3 , 1 , 2 , 3 );<br /> foo( 4 , 0 , 54 , 32 , 88 );<br /> foo( 2 , 3 , 4 );<br /> foo( 0 );<br /> foo( 1 , 42 );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> -Pirata-</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Funzione_con_numero_variabile_di_parametri.&diff=183 2013-11-10T13:48:27Z

<p>Pirata: </p> <hr /> <div>Esempio di funzione che prende in argomento un numero variable di parametri:<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdarg.h&gt;<br /> <br /> void foo(int narg, ... ) //narg é il numero di argomenti che verranno passati<br /> {<br /> int i;<br /> va_list ap; //Il tipo di dato va_list é una lista di variabili<br /> va_start(ap,narg); // Macro che inizializza ap<br /> for ( i = 0 ; i &lt; narg ; i++) {<br /> int this = va_arg( ap , int ); //Macro che dice il tipo e il valore che deve<br /> printf(&quot; %d &quot;, this); //avere il prossimo argomento della chiamata<br /> }<br /> printf(&quot;\n&quot;);<br /> va_end(ap); //Macro che chiude la macro di inizializzazione <br /> }<br /> <br /> int main ( int argc , char *argv)<br /> {<br /> foo( 3 , 1 , 2 , 3 );<br /> foo( 4 , 0 , 54 , 32 , 88 );<br /> foo( 2 , 3 , 4 );<br /> foo( 0 );<br /> foo( 1 , 42 );<br /> }<br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Funzione_con_numero_variabile_di_parametri.&diff=182 2013-11-10T13:47:21Z

<p>Pirata: Created page with &quot;Esempio di funzione che prende in argomento un numero variable di parametri: &lt;syntaxhighlight lang=&quot;C&quot;&gt; #include &lt;stdio.h&gt; #include &lt;stdarg.h&gt; void foo(int narg, ... ) { in...&quot;</p> <hr /> <div>Esempio di funzione che prende in argomento un numero variable di parametri:<br /> <br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdarg.h&gt;<br /> <br /> void foo(int narg, ... )<br /> {<br /> int i;<br /> va_list ap; //Il tipo di dato va_list é una lista di variabili<br /> va_start(ap,narg); // Macro che inizializza ap<br /> for ( i = 0 ; i &lt; narg ; i++) {<br /> int this = va_arg( ap , int ); //Macro che dice il tipo e il valore che deve<br /> printf(&quot; %d &quot;, this); //avere il prossimo argomento della chiamata<br /> }<br /> printf(&quot;\n&quot;);<br /> va_end(ap); //Macro che chiude la macro di inizializzazione <br /> }<br /> <br /> int main ( int argc , char *argv)<br /> {<br /> foo( 3 , 1 , 2 , 3 );<br /> foo( 4 , 0 , 54 , 32 , 88 );<br /> foo( 2 , 3 , 4 );<br /> foo( 0 );<br /> foo( 1 , 42 );<br /> }<br /> &lt;/syntaxhighlight&gt;</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=Main_Page&diff=181 2013-11-10T13:43:16Z

<p>Pirata: </p> <hr /> <div>Questo &amp;egrave; il Wiki del Corso di Sistemi Operativi<br /> <br /> [[Esercizi a caso del Prof.]]<br /> <br /> [[Python Programma tieni punteggio.]]<br /> <br /> [[Comandi visti alle lezioni.]]<br /> <br /> [[SYS CALL viste a lezione.]]<br /> <br /> [[Parametri con getopt().]]<br /> <br /> [[Funzione con numero variabile di parametri.]]<br /> <br /> ----<br /> Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=180 2013-11-10T11:03:08Z

<p>Pirata: </p> <hr /> <div>* FORK<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *_EXIT<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> * WAIT<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,&amp;status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *EXECVE<br /> Esegue un programma.<br /> La famiglia di funzioni exe() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d %s \n&quot;,getpid(),pid,argv[1]);<br /> sleep(5);<br /> waitpid(pid,&amp;status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> execvp(argv[2],argv+2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> (Pirata)</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=179 2013-11-10T10:47:33Z

<p>Pirata: </p> <hr /> <div>* FORK<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *_EXIT<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> * WAIT<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *EXECVE<br /> Esegue un programma.<br /> La famiglia di funzioni exe() rimpiazza l'immagine del processo corrente con l'immagine di un nuovo processo.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,status,0);<br /> if (WIFEXITED(status)) <br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if( WIFSIGNALED(status) ) <br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); <br /> }<br /> else {<br /> char *args[] = {&quot;ls&quot;,&quot;-l&quot;,(char *)0};<br /> execvp(&quot;ls&quot;,args); //funzione di libreria che prende in input il path(p) e un vettore(v).<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> (Pirata)</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=178 2013-11-10T10:22:52Z

<p>Pirata: </p> <hr /> <div>* FORK<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *_EXIT<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> * WAIT<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //Macro che restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> (Pirata)</div>

Pirata https://so.v2.cs.unibo.it/wiki/index.php?title=SYS_CALL_viste_a_lezione.&diff=177 2013-11-10T10:04:50Z

<p>Pirata: </p> <hr /> <div>* FORK<br /> Crea un nuovo processo duplicando il processo chiamante. Il nuovo processo , chiamato figlio, é un duplicato esatto del processo chiamante , chiamato padre. <br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){ <br /> if(fork()){<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() ); // getpid() stampa il pid del processo corrente , getppid() stampa il pid del processo padre<br /> 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<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(una piccola osservazione sull'eredità del buffer):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> void main (void){<br /> printf(&quot;cucù! : &quot;); //notare la differenza se nella sringa metto \n <br /> if(fork())<br /> printf(&quot;uno %d %d \n&quot;, getpid(), getppid() );<br /> else<br /> printf(&quot;due %d %d \n&quot;,getpid(), getppid() );<br /> }<br /> <br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio3(fork e malloc):&lt;br/&gt;<br /> '''(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)'''<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;unistd.h&gt;<br /> <br /> <br /> void main (void){<br /> int *p;<br /> if( fork() ){<br /> p = malloc(sizeof(int));<br /> *p = 45;<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); <br /> sleep(2);<br /> }<br /> else {<br /> p = malloc(sizeof(int));<br /> printf(&quot;%d %p pid : %d , ppid : %d \n&quot;,*p,p,getpid(),getppid()); //i puntatori restituiranno lo stesso indirizzo di memoria sia per il padre che per il figlio <br /> sleep(1); //perché condividono lo stesso spazio di indirizzamento<br /> }<br /> } <br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> *_EXIT<br /> Termina il proceso chiamante.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> int main (int argc,char *argv[]){<br /> _exit(0); //Sys call che termina il processo chiamante<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> esempio2(atexit):<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> <br /> void at1(void){<br /> printf(&quot;at1 \n&quot;);<br /> }<br /> <br /> void at2(void){<br /> printf(&quot;at2 \n&quot;);<br /> }<br /> <br /> <br /> int main (int argc,char *argv[]){<br /> printf(&quot;brutal kill \n&quot;);<br /> atexit(at1); //funzione di libreria che termina il processo passato come argomento<br /> atexit(at2); <br /> }<br /> <br /> //le funzioni passate ad atexit vengono eseguite in modo inverso rispetto all'invocazione<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> * WAIT<br /> Aspetta che un processo cambi di stato.<br /> <br /> esempio1:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(10); <br /> waitpid(pid,status,0);<br /> printf(&quot; exit status %d \n&quot;,WEXITSTATUS(status)); //Macro che restituisce l' exit status del figlio,cioè gli otto bit meno significativi dello status che il figlio<br /> } //specifica in una chiamata di _exit o exit o come argomento di ritorno del main.<br /> else {<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> exit(1);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> <br /> esempio2:<br /> &lt;syntaxhighlight lang=&quot;C&quot;&gt;<br /> #include &lt;stdio.h&gt;<br /> #include &lt;unistd.h&gt;<br /> #include &lt;stdlib.h&gt;<br /> #include &lt;sys/types.h&gt;<br /> #include &lt;sys/wait.h&gt;<br /> <br /> int main (int argc, char *argv[]){<br /> pid_t pid;<br /> if( pid = fork() ){<br /> int status;<br /> printf(&quot; padre : %d figlio : %d \n&quot;,getpid(),pid);<br /> sleep(5);<br /> waitpid(pid,status,0);<br /> if (WIFEXITED(status)) //Macro che restituisce true se il figlio termina normalmente, cioé chiamando _exit o exit oppure tramite il return del main<br /> printf(&quot; exit status %d \n&quot;, WEXITSTATUS(status));<br /> else if(WIFSIGNALED(status) ) //Macro che restituisce true se il figlio é terminato da un segnale<br /> printf(&quot;signal : %d \n&quot;, WTERMSIG(status) ); //restituisce il numero del segnale che causa la terminazione del processo figlio<br /> }<br /> else {<br /> int *p;<br /> printf(&quot; figlio : %d padre : %d \n&quot;,getpid(),getppid());<br /> sleep(1);<br /> p = (int *)42;<br /> *p = 43; <br /> exit(2);<br /> }<br /> }<br /> &lt;/syntaxhighlight&gt;<br /> <br /> Correggetemi se ho scritto delle sciocchezze.<br /> (Pirata)</div>

Pirata