Sistemi Operativi - User contributions [en]

Prova Pratica 18-06-2015

2015-06-30T10:20:15Z

MV:

==Esercizio1==
<source lang="text">
Usando signalfd (e non signal o sigaction) scrivere due programmi tx e rx.
Rx deve essere attivato per primo e per prima cosa stampa il suo pid e aspetta.
Tx ha due parametri: il pid del ricevente rx e una stringa.
Rx deve stampare la stringa passata come secondo parametro e uscire. La stringa deve essere spedita usando solo segnali.
Ogni bit di ogni carattere deve essere inviato usando SIGUSR1 se vale 1 e SIGUSR2 se vale 0.
Al ricevimento di ogni bit rx spedisce un segnale di acknowledgement a tx che provvede a spedire il successivo
</source>

<source lang="c">
// Esercizio1: Tx

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/signalfd.h>

#define EXIT_WITH_ERROR(function) \
{ \
printf("Error %i in ",errno); \
printf(function); \
printf(": %s\n",strerror(errno)); \
exit(EXIT_FAILURE); \
}

int main(int argc, char *argv[])
{
pid_t rx;
char *str;
sigset_t mask;
int sfd;
struct signalfd_siginfo siginfo;

if(argc != 3)
{
printf("Usage: Tx rx string\n");
exit(1);
}

if(sscanf(argv[1],"%i",&rx) != 1)
EXIT_WITH_ERROR("sscanf");
str = argv[2];

// setto il sigset_t a contenere SIGUSR1 (sara' l'acknowledgement)
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);

// annullo l'azione standard per SIGUSR1
if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
EXIT_WITH_ERROR("sigprocmask")

sfd = signalfd(-1, &mask, 0);
if (sfd == -1)
EXIT_WITH_ERROR("signalfd");

while(1)
{
int i;
char c = *str;

// invia i bit del carattere (dal piu' al meno significativo)
for(i=7; i>=0; i--)
{
if((c>>i)&1) // prendo l'i-esimo bit di c:
{ // SIGUSR1 se e' 1
if(kill(rx,SIGUSR1) == -1)
EXIT_WITH_ERROR("kill")
}
else // SIGUSR2 se invece e' 0
{
if(kill(rx,SIGUSR2) == -1)
EXIT_WITH_ERROR("kill")
}

// attendo SIGUSR1 da Rx
int len = read(sfd, &siginfo, sizeof(struct signalfd_siginfo));
if(len != sizeof(struct signalfd_siginfo))
EXIT_WITH_ERROR("read")
}
if(c == 0) // esce se ha appena inviato fine-stringa
break;
str++;
}
return 0;
}
</source>

<source lang="c">
// Esercizio1: Rx

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/signalfd.h>

#define EXIT_WITH_ERROR(function) \
{ \
printf("Error %i in ",errno); \
printf(function); \
printf(": %s\n",strerror(errno)); \
exit(EXIT_FAILURE); \
}

int main(int argc, char *argv[])
{
pid_t mypid;
sigset_t mask;
int sfd;
struct signalfd_siginfo siginfo;
char c;

mypid = getpid();
printf("%i\n",mypid);

// setto il sigset_t
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);
sigaddset(&mask, SIGUSR2);

// annullo l'azione standard per SIGUSR1 e SIGUSR2
if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
EXIT_WITH_ERROR("sigprocmask")

sfd = signalfd(-1, &mask, 0);
if (sfd == -1)
EXIT_WITH_ERROR("signalfd")

do
{
int i;
c = 0;

// riceve 8 segnali per ogni carattere
for(i=7; i>=0; i--)
{
int len = read(sfd, &siginfo, sizeof(struct signalfd_siginfo));
if(len != sizeof(struct signalfd_siginfo))
EXIT_WITH_ERROR("read")

if (siginfo.ssi_signo == SIGUSR1) // se ho ricevuto SIGUSR1
c = c | (1 << i); // setto il bit a 1
// altrimenti e' sicuramente SIGUSR2 => il bit resta 0

kill(siginfo.ssi_pid, SIGUSR1); // invio l'acknowledgement al mittente del segnale
}
printf("%c",c);
} while(c != 0); // se tutti i bit a 0 => fine stringa

printf("\n");
return 0;
}
</source>

==Esercizio2==

<source lang="text">
Si costruiscano due programmi txtime e rxnull per stimare l'efficienza di tx e rx.
Rxnull e' uguale all'rx precedente ma non stampa nulla.
Txtime ha come parametri il pid del ricevente e un numero intero n. Txtime deve spedire n caratteri 'K' al txtnull e alla fine deve stampare
il tempo medio impiegato per spedire un carattere.
</source>

<source lang="c">
// Esercizio2: txtime

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/signalfd.h>

#include <sys/timeb.h>

#define EXIT_WITH_ERROR(function) \
{ \
printf("Error %i in ",errno); \
printf(function); \
printf(": %s\n",strerror(errno)); \
exit(EXIT_FAILURE); \
}

int main(int argc, char *argv[])
{
pid_t rx;
int n;
int j;

// variabili per calcolare il tempo medio di trasmissione
struct timeb time_start, time_end;
int millisec;
float media;

sigset_t mask;
int sfd;
struct signalfd_siginfo siginfo;

if(argc != 3)
{
printf("Usage: Tx rx string\n");
exit(1);
}

if(sscanf(argv[1],"%i",&rx) != 1)
EXIT_WITH_ERROR("sscanf");
if(sscanf(argv[2],"%i",&n) != 1)
EXIT_WITH_ERROR("sscanf");

ftime(&time_start);

// setto il sigset_t a contenere SIGUSR1 (sara' l'acknowledgement)
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);

// annullo l'azione standard per SIGUSR1
if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
EXIT_WITH_ERROR("sigprocmask")

sfd = signalfd(-1, &mask, 0);
if (sfd == -1)
EXIT_WITH_ERROR("signalfd");

// invio n caratteri 'K'
for(j=0; j<n; j++)
{
int i;
char c = 'K';

for(i=7; i>=0; i--)
{
if((c>>i)&1) // prendo l'i-esimo bit di c:
{ // SIGUSR1 se e' 1
if(kill(rx,SIGUSR1) == -1)
EXIT_WITH_ERROR("kill")
}
else // SIGUSR2 se invece e' 0
{
if(kill(rx,SIGUSR2) == -1)
EXIT_WITH_ERROR("kill")
}

// sospendo il processo in attesa div SIGUSR1
int len = read(sfd, &siginfo, sizeof(struct signalfd_siginfo));
if(len != sizeof(struct signalfd_siginfo))
EXIT_WITH_ERROR("read")
}
}

ftime(&time_end);

// calcolo il tempo medio di trasmissione
millisec = (time_end.time - time_start.time)*1000 + (time_end.millitm - time_start.millitm);
media = (float)(millisec)/n;
printf("Tempo medio: %f ms per carattere.\n",media);
}
</source>

<source lang="c">
// Esercizio2: rxnull

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/signalfd.h>

#define EXIT_WITH_ERROR(function) \
{ \
printf("Error %i in ",errno); \
printf(function); \
printf(": %s\n",strerror(errno)); \
exit(EXIT_FAILURE); \
}

int main(int argc, char *argv[])
{
pid_t mypid;
sigset_t mask;
int sfd;
struct signalfd_siginfo siginfo;
char c;

mypid = getpid();
printf("%i\n",mypid);

// setto il sigset_t
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);
sigaddset(&mask, SIGUSR2);

// annullo l'azione standard per SIGUSR1 e SIGUSR2
if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1)
EXIT_WITH_ERROR("sigprocmask")

sfd = signalfd(-1, &mask, 0);
if (sfd == -1)
EXIT_WITH_ERROR("signalfd")

do
{
int i;
c = 0;

for(i=7; i>=0; i--)
{
int len = read(sfd, &siginfo, sizeof(struct signalfd_siginfo));
if(len != sizeof(struct signalfd_siginfo))
EXIT_WITH_ERROR("read")

if (siginfo.ssi_signo == SIGUSR1) // se ho ricevuto SIGUSR1
c = c | (1 << i); // setto il bit a 1
// altrimenti e' sicuramente SIGUSR2 => il bit resta 0

kill(siginfo.ssi_pid, SIGUSR1); // invio l'acknowledgement al mittente del segnale
}
} while(c != 0); // se tutti i bit a 0 => fine stringa
// NOTA: questo programma non termina normalmente se usato con txtime

printf("\n");
}
</source>

Prova Pratica 18-06-2015

2015-06-30T10:13:55Z

MV: Created page with "==Esercizio1== <source lang="text"> Usando signalfd (e non signal o sigaction) scrivere due programmi tx e rx. Rx deve essere attivato per primo e per prima cosa stampa il suo..."

Prova Teorica 16-07-2014

2015-05-26T20:33:32Z

MV:

<source lang="text">
scrivere il monitor mMbb che realizzi un meccanismo di un minmax bounded buffer.
Dopo le prime MIN operazioni di scrittura, un minmax bounded buffer deve sempre avere almeno MIN elementi e mai piu' di MAX
elementi (e' quindi limitato sia nell'ampiezza massima, sia nell'ampiezza minima).
Le funzioni (procedure entry) read e write del minmax bounded buffer hanno gli stessi argomenti e valori di ritorno di quelle del producer/consumer o del bounded buffer ordinario.
</source>
===Soluzione di Stefano Zaniboni===
<source lang="c">
/*esercizio 1*/

monitor mMbb{
object[] buffer; //spazio di memorizzazione

final int MAXELEM; // numero massimo di elementi che ci possono essere nel buffer
final int MINELEM; //numero minimo di elementi --> numero di scritture minime

condition okW; // dove mi fermo se non posso scrivere
condition okR; // dove mi fermo se non posso leggere

int count; // elementi presenti nel buffer
int front; // contatore al elemento prodotto
int rear; // contatore al elemento consumato

mMbb(){
buffer = new Object[MAXELEM];
count = rear = front = 0;
}

procedure entry object read(){
if ((count < MINELEM)) //se il buffer e' pieno oppure non ci sono min elem chiamo la wait
okR.wait();
eltype val = buffer[rear]; // assegno al val l'elemento che ho letto e poi aggiorno rear
rear = ((rear + 1) % (MAXELEM -1 )); // aggiorno rear;
count--; // decremento count per dire che ho consumato un elemento
okW.signal(); // qui faccio signal sui produttori che adesso possono scrivere
return retval;
}
procedure entry void write(int val){
if (count == buffer.length) //se il buffer e' pieno mi fermo
okW.wait();
buffer[front] = val; //scrivo elemento
count++; //aggiorno i prodotti disponibili
front = ((front+1)%(MAXELEM - 1)); // aggiorno il contatore front a puntare nella prossima posizione

okR.signal();
}

}
</source>
==Esercizio c.2==
<source lang="text">
Facendo uso di semafori scrivere la funzione rendezvous che consenta ai processi di sincronizzarsi secondo le seguenti specifiche:
– Ogni processo indica come parametro della funzione rendezvous con quanti altri processi vuole sincronizzarsi.
– M processi che chiamano la rendezvous con parametro N rimangono bloccati se M<N.
– Quando l'N-mo processo richiama la rendezvous specificando N come parametro, lui e gli N-1 sospesi devono proseguire nelle propria esecuzione
</source>
<source lang="c">
// ------------------------- SOLUZIONE DI MV -------------------------

void rendezvous(int N)
{
struct S { Semaphore sem; int N; int M };

static List<struct S> L = new List<struct S>();
static Semaphore mutex = new Semaphore(1);

if(N <= 1) // se N==1 significa che non vuole sincronizzarsi
return; // se N<1 non ha senso => esce dalla funzione

bool trovato = false;
mutex.P(); // prende la mutua esclusione per evitare incoerenze
// scorre la lista in cerca di un semaforo per N
for(List<struct S> el = L.head(); !L.last(el) && !trovato; el = L.next(el) )
if(el.content.N == N) // se esiste
{
trovato = true;
if(el.content.M == N-1) // se è l'N-esimo processo
{
while(el.content.M) // sblocca tutti gli altri
{
el.content.sem.V();
el.content.M--;
}
mutex.V();
}
else // altrimenti si mette in attesa
{
el.content.M++;
mutex.V();
el.content.sem.P();
}
break;
}

if(!trovato) // se non esiste lo crea
{
// NB: ho ancora la mutua esclusione
struct S s;
s.N = N;
s.M = 1;
s.sem = new Semaphore(0);
L.insert_tail(S) // inserisce nella lista (in coda)

mutex.V():
// si mette in attesa sul semaforo appena creato (NB: N!=1)
L.tail().content.sem.P();
}
}

/* NOTA: gli elementi della lista non vengono deallocati una volta liberato
il semaforo; questo perchè è ancora possibile una race condition (rara)
nel caso in cui un processo P1 stia per inserirsi su un semaforo già esistente
(ha appena fatto mutex.V() ) e un altro P2 riesca ad entrare nel ciclo e
liberare tutti => P2 effettua una V in più e P1 esce subito dalla P
*/
</source>

Prova Teorica 2013.02.14

2015-05-26T16:58:51Z

MV:

==Esercizio 1==
<source lang="text">
Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato.
</source>

<source lang="c">
// ------------------------- SOLUZIONE DI MV -------------------------

monitor dualwriter
{
type1 buf1[BUFSIZE];
type2 buf2[BUFSIZE];
int next_r1, next_r2, n1, n2;
// si ricorda che: next_w = (next_r+n)%BUFSIZE

condition notempty1, notempty2; // blocca in lettura se n=0
condition canwrite; // blocca in scrittura se n1=BUFSIZE || n2=BUFSIZE

dualwriter() // costruttore
{
n1 = n2 = next_r1 = next_r2 = 0;
}

procedure entry void write(type1 e1, type2 e2)
{
if(n1==BUFSIZE || n2==BUFSIZE)
canwrite.wait();

buf1[(next_r1+n1)%BUFSIZE] = e1;
n1++;
buf2[(next_r2+n2)%BUFSIZE] = e2;
n2++;
notempty1.signal();
notempty2.signal();
}

procedure entry type1 read1()
{
type1 el;

if(n1==0)
notempty1.wait();

el = buf1[next_r1];
next_r1 = (next_r1+1)%BUFSIZE;
n1--;

// libera un processo sse è possibile scrivere in entrambi i buffer
if(n1<BUFSIZE && n2<BUFSIZE)
canwrite.signal();
}

procedure entry type2 read2()
{
type2 el;

if(n2==0)
notempty1.wait();

el = buf2[next_r2];
next_r1 = (next_r1+1)%BUFSIZE;
n2--;

if(n1<BUFSIZE && n2<BUFSIZE)
canwrite.signal();
}
}
</source>

Main Page

2015-05-26T16:18:04Z

MV:

Questo è il Wiki del Corso di Sistemi Operativi

[[Prova Teorica 14-02-2013]]

[[Prova Pratica Es.2 12-02-2009]]

[[Prova Teorica 13-05-2011]]

[[Prova Teorica 16-07-2014]]

[[Prova Pratica 20-02-2014]]

[[Prova Pratica 02-07-2014]]

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Prova Teorica 2013.02.14

2015-05-26T16:16:46Z

MV: Created page with "==Esercizio 1== <source lang="text"> Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza BUFSIZE) che consenta a uno scrittore di sc..."

==Esercizio 1==
<source lang="text">
Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato.
</source>

<source lang="c">
// ------------------------- SOLUZIONE DI MV -------------------------

monitor dualwriter
{
type1 buf1[BUFSIZE];
type2 buf2[BUFSIZE];
int next_r1, next_r2, n1, n2;
// si ricorda che: next_w = (next_r+n)%BUFSIZE

condition notempty1, notempty2; // blocca in lettura se n=0
condition canwrite; // blocca in scrittura se n1=BUFSIZE || n2=BUFSIZE

dualwriter() // costruttore
{
n1 = n2 = next_r1 = next_r2 = 0;
}

procedure entry void write(type1 e1, type2 e2)
{
if(n1==BUFSIZE || n2==BUFSIZE)
canwrite.wait();

buf1[(next_r1+n1)%BUFSIZE] = e1;
n1++;
buf2[(next_r2+n2)%BUFSIZE] = e2;
n2++;
notempty1.signal();
notempty2.signal();
}

procedure entry type1 read1()
{
type1 el;

if(n1==0)
notempty1.wait();

el = buf1[next_r1++];
n1--;

// libera un processo sse è possibile scrivere in entrambi i buffer
if(n1<BUFSIZE && n2<BUFSIZE)
canwrite.signal();
}

procedure entry type2 read2()
{
type2 el;

if(n2==0)
notempty1.wait();

el = buf2[next_r2++];
n2--;

if(n1<BUFSIZE && n2<BUFSIZE)
canwrite.signal();
}
}
</source>

Prova Teorica 2011.05.13

2015-05-25T07:11:16Z

MV:

==Esercizio 1==
<source lang="text">
Scrivere un monitor reqq che gestisca Ncode di richieste.
I richiedenti chiamano la funzione che ha la seguente signature:
answer_t reqq.query(request_t request, int type);
Query deve fermare il processo richiedente fino a completamento della richiesta da parte di un gestore. Il valore di ritorno
e' la risposta del gestore.
Ci sono N gestori, uno per ogni tipo di richiesta, che si comportano come segue:
multiq_handler: process[i, i=0,..,N-1] {
request_t req;
int type;
while (1) {
req=reqq.getquery(i, &type);
reqq.reply(i,handle(req, type));
}
}
Normalmente le richieste vengono assegnate al gestore del tipo corrispondente (i==type), se non vi sono richieste di tale
tipo elabora una richiesta del tipo con la piu' lunga coda di richieste pendenti. Quando un gestore termina l'elaborazione
(funzione handle, da non implementare!) invia il risultato tramite la reply. Il valore passato alla reply deve essere restituito
al richiedente come valore di ritorno della funzione query. Se non vi sono richieste disponibili i gestori si fermano
attendendo nuove richieste.
</source>

<source lang="c">
// ------------------------------- SOLUZIONE DI MV ----------------------------------------

monitor reqq
{
queue Q[N]; // array di N code
answer_t A[N]; // variabili per salvare temporaneamente le risposte dei gestori
condition notempy[N]; // ci si fermano i gestori se la risp. coda è vuota
condition done[N]; // ci si fermano i processi in attesa della risposta
int n_req[N]; // num. di richieste per ogni coda

answer_t query(request_t request, int type)
{
Q[type].enqueue(request);
n_req[type]++;
notempy.signal();
done.wait();
return A[type];
}

request_t getrequest(int i, int* type)
{
*type = i;
if(n_req[N] == 0)
notempy.wait();
return Q[i].dequeue();
}

void reply(int type, answer_t answer)
{
A[type] = answer;
done.signal();
}
}
</source>
Ho provato a risolverlo pur non avendo ben capito una frase ("se non vi sono richieste di tale tipo elabora una richiesta del tipo con la piu' lunga coda di richieste pendenti"). Se notate errori avvisatemi!

<source lang="c">
// ------------------------------- SOLUZIONE DI Maldus ----------------------------------------
monitor reqq{
request_t queue Q[N];
condition[] done = new condition[N];
condition notempty; // una sola condizione per controllare quando la coda delle richieste è vuota;
answer_t A[N];
int longest;

reqq(){
longest = 0 ;
}

procedure entry answer_t query( request_t request, int type){
Q[type].enqueue(request);
if( Q[type].lenght() > Q[longest].lenght() ) longest = type;
notempty.signal();
done[type].wait();
return A[type];
}

procedure entry request_t getquery( int i, int* type){
if( Q[i].empty() ){
if( longest == 0 ) notempty.wait();
i = longest;
}
*type = i ;
return Q[i].dequeue();
}

procedure entry void reply( int type, answer_t answer){
A[type] = answer;
done.signal();
}
</source>
Interpreto la frase "se non vi sono richieste di tale tipo elabora una richiesta del tipo con la piu' lunga coda di richieste pendenti" considerando appunto il tipo per il quale ci sono più richieste ( se quello specificato invece non ne ha) nella funzione getquery: in quest'ottica ho pensato che la condizione notempty dovesse essere singola, perchè se un gestore può gestire anche una richiesta diversa dal tipo specificato, non importa quale richiesta viene aggiunta. Per il resto è praticamente identico alla soluzione di MV.

==Esercizio 2==
<source lang="text">
Facendo uso di semafori ordinari implementare le funzioni lifocs_enter e lifocs_exit che realizzino una critical section LIFO.
I processi per usare la critical section LIFO usano il seguente protocollo:
lifocs_enter()
.... codice critico
lifocs_exit()
quando un processo rilascia la sezione critica e ci sono processi in attesa di entrare, deve venir assegnata la sezione critica al processo che ha fatto l'ultima richiesta (in ordine di tempo).
</source>
<source lang="c">
// ------------------------- SOLUZIONE DI MV -----------------------------

// la cosa più semplice che mi è venuta in mente è di allocare dinamicamente uno stack di semafori
shared Stack<Semaphore> S = new Stack<Semaphore>();
shared Semaphore mutex = new Semaphore(1);
shared int n_proc = 0;

lifocs_enter()
{
mutex.P();
if(n_proc++ == 0)
{
mutex.V();
}
else
{
Semaphore sem = new Semaphore(0);
S.push(sem);
mutex.V();
sem.P();
}
}

lifocs_exit()
{
Semaphore sem;
mutex.P();
if(--n_proc == 0)
{
mutex.V();
}
else
{
sem = S.pop();
mutex.V();
sem.V();
free(sem);
}
}
</source>
==Esercizio 3==
<source lang="text">
Un servizio di message passing a canale prevede che ogni spedizione e ricezione di un messaggio faccia riferimento a “canale” e non ad un processo.
L'interfaccia e' la seguente:
n=channel_join_create(id); /* crea un canale con l'id specificato se non esiste, altrimenti incrementa il numero dei processi che stanno usando il canale, restituisce il numero di processi che condividono il canale. l'operazione e' atomica */
channel_send(id,msg); /* spedisce in modo asincrono un messaggio sul canale id */
msg=channel_receive(id); /* riceve un messaggio sul canale specificato, se piu' processi si fermano in attesa di un messaggio dallo stesso canale, ogni messaggio viene recapitato al processo che per primo ha richiesto la channel_receive */
channel_leave_delete(id); /* decrementa il numero dei processi utilizzatori del canale, il canale viene cancellato
quando non ha piu' utilizzatori. L'operazione e' atomica. */
Implementare un supporto per sezioni critiche che faccia uso del message passing a canale. (le funzioni da implementare sono csenter, csexit).
</source>
<source lang="c">
// --------------------------------- SOLUZIONE DI MV -----------------------------------------

const int ID = 1; // si utilizza un unico canale

void cs_enter()
{
// se c'è almeno un altro processo si mette in attesa di un messaggio di via libera, altrimenti semplicemente crea il canale
if(channel_join_create(ID) > 1)
channel_receive(ID);
}

void cs_exit()
{
// libera il primo processo in attesa di receive sul canale
// (si suppone che un messaggio spedito su un canale vuoto venga semplicemente perduto)
channel_send(ID,"go");
channel_leave_delete(ID);
}
</source>

Prova Teorica 2011.05.13

2015-05-25T06:54:43Z

MV:

Main Page

2015-05-22T12:53:05Z

MV:

Questo è il Wiki del Corso di Sistemi Operativi

[[Prova Teorica 13-05-2011]]

[[Prova Teorica 16-07-2014]]

[[Prova Pratica 20-02-2014]]

[[Prova Pratica 02-07-2014]]

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Prova Teorica 2011.05.13

2015-05-22T12:52:13Z

MV: Created page with "==Esercizio 1== <source lang="text"> Scrivere un monitor reqq che gestisca Ncode di richieste. I richiedenti chiamano la funzione che ha la seguente signature: answer_t reqq.q..."

Esercizio 3, prova pratica, 18-07-2013

2015-05-19T07:24:19Z

MV:

==Testo==
<source lang="text">
Scrivere un programma python o uno script bash che cataloghi per nome tutti i file presenti in un sottoalbero.
nameindex dir1 dir2
crea nel file dir2 un link simbolico ad ogni file contenuto nell'albero che ha come radice dir1. Quando sono presenti piu' file
con lo stesso nome in diverse directory all'interno di dir1, viene posto un suffisso numerico al nome del link simbolico
se dir1 contiene i file pippo, pluto e paperino e la directory paperopoli e quest'ultima contiene i file paperino, qui quo e qua,
all'interno di dir2 divranno essere contenuti i seguenti link simbolici:
pippo → dir1/pippo
pluto → dir1/pluto
paperino → dir1/paperino
paperino1 → dir1/paperopoli/paperino
qui → dir1/paperopoli/qui
quo → dir1/paperopoli/quo
qua → dir1/paperopoli/qua
</source>

===Soluzione di Krusty===
<source lang="python">
import os, sys
from stat import *

exist={}

def Scan(pathname):

for f in os.listdir(pathname):
path = os.path.join(pathname,f)
s = os.stat(path)
if S_ISREG(s.st_mode):
if f not in exist:
exist[f] = 1
os.symlink(path,f)
else:
n = exist[f]
exist[f] = exist[f] + 1
os.symlink(path,(f+str(n)))

elif S_ISDIR(s.st_mode):
Scan(path)

#main

if not os.path.isdir(sys.argv[2]):
os.makedirs(sys.argv[2])

os.chdir(sys.argv[2])
Scan(sys.argv[1])

</source>

==Soluzione di MV==
<source lang="bash">
#! /bin/bash

if (( $# != 2 ))
then
echo "Usage: nameindex dir1 dir2"
exit 1
fi

if [[ $1 = /* ]] # verifico se $1 è un path assoluto o relativo (è necessario assoluto per i link)
then
dir1=$1
else
dir1=`pwd`/$1
fi

for i in `find $dir` # scandisco l'albero
do
if [ -f $i ]
then
filename=`basename $i` # ricavo il nome del file senza percorso

if [ ! -f $2/$filename ] # se è il primo file trovato con quel nome
then # creo il link con lo stesso nome
ln -s $dir1/$i $2/$filename
else # altrimento cerco il primo numero n>0 non ancora usato come suffisso
n=1
while [ -f $2/${filename}${n} ]
do
(( n=$n+1 ))
done
ln -s $dir1/$i $2/$filename$n
fi
fi
done
</source>

Main Page

2015-05-12T20:33:55Z

MV:

Questo è il Wiki del Corso di Sistemi Operativi

[[Buffer Limitato]]

[[Esercizio 1-2 Prova Pratica 30-05-2012]]

[[Esercizio 3 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 30-05-2012]]

[[Esercizio 1 Prova Pratica 23-06-09]]

[[Esercizio 1 Prova Pratica 25-09-2014]]

[[Esercizio 3 Prova Pratica 20-06-2013]]

[[Esercizio 3 Prova Pratica 29-05-14]]

[[Esercizio 2 esame 29/05/2014]]

[[Grep piramidale (non tanto grep) esame 2.7.2003]]

[[Ricerca e stampa MD5checksum (Prova pratica 21-01-2015)]]

[[Linker fisico (Prova pratica 20-02-2014)]]

[[Differenza tra due sottoalberi del file system (Prova pratica 22-07-2011)]]

[[Aggiorna cartelle (Prova pratica 23-01-2014)]]

[[Esercizio 3 prova pratica 29 maggio 2014]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Esercizio 1 Prova Pratica 12-09-11]]

[[Esercizio 1 Prova Pratica 25-01-2013]]

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Buffer Limitato

2015-05-12T20:33:27Z

MV: Created page with "<source lang="text"> Esercizio di programmazione concorrente: Il programma genera 2 thread. Il primo di questi, detto producer, prende i valori da stdin e li scrive su un buff..."

<source lang="text">
Esercizio di programmazione concorrente:
Il programma genera 2 thread.
Il primo di questi, detto producer, prende i valori da stdin e li scrive su un buffer.
Il secondo, detto consumer, legge i valori dal buffer e li scrive su un file.
Requisiti:
- Il buffer è usato come array circolare
- Producer non deve scrivere su valori non ancora letti
- Consumer deve leggere i valori in ordine e senza ripetizioni
</source>

== Soluzione di MV, usando i semafori ==
<source lang="C">
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define DIM_BUF 10
#define THREAD_SHARED 0

char buffer[DIM_BUF];
int next_write = 0, next_read = 0; // indici sul buffer
sem_t empty; // semaforo: consumer si blocca su di esso quando il buffer è vuoto
sem_t full; // semaforo: producer si blocca su di esso quando il buffer è pieno

void* producer_routine(void *arg)
{
char c;
while(scanf("%c",&c) != EOF) // legge ("produce") un carattere da stdin
{
if(sem_wait(&full) != 0) // si blocca se il buffer è pieno
{
printf("Error %i in producer: %s",errno,strerror(errno));
break;
}

buffer[next_write] = c;
next_write = (next_write+1)%DIM_BUF;

if(sem_post(&empty) != 0) // segnala un nuovo carattere non letto sul buffer
{
printf("Error %i in producer: %s",errno,strerror(errno));
break;
}
}
}

void* consumer_routine(void * arg)
{
FILE *file;

if( (file = fopen("./consumed.txt","a")) == NULL)
{
printf("Error %i in consumer: %s",errno,strerror(errno));
return NULL;
}

while(1)
{
char c;

if(sem_wait(&empty) != 0) // se il buffer è vuoto si blocca
{
printf("Error %i in consumer: %s",errno,strerror(errno));
break;
}

fprintf(file,"%c",buffer[next_read]);
next_read = (next_read+1)%DIM_BUF;

if(sem_post(&full) != 0) // segnala che si è liberato un posto sul buffer
{
printf("Error %i in consumer: %s",errno,strerror(errno));
break;
}
}
close(file);
}

int main(int argc, char* argv[])
{
pthread_t producer, consumer;
int *error, i;

for(i=0; i< DIM_BUF; i++)
buffer[i] = 0;

if(sem_init(&empty,THREAD_SHARED,0) != 0) // inizializzato a 0 perchè il buffer è vuoto
return errno;
if(sem_init(&full,THREAD_SHARED,DIM_BUF) != 0) // servono DIM_BUF scritture per riempirlo
return errno;

pthread_create(&producer,NULL,&producer_routine,NULL);
pthread_create(&consumer,NULL,&consumer_routine,NULL);

pthread_join(producer, (void**)&error); // aspetta la terminazione di producer
printf("End.\n");

return 0;
}
</source>

Prova Pratica 2011.06.22

2015-04-20T07:20:03Z

MV:

<source lang="text">
Scrivere uno script bash o un programma python che metta in ordine tutti i file di un sottoalbero dal piu' vecchio al piu' recente.
La stampa finale deve mostrare solamente il path relativo dei file.
</source>
==Soluzione di MV (bash)==
<source lang="bash">
SCRIPT=$0

# il primo script è lanciato con 1 parametro: directory
# le chiamate ricorsive son fatte con 2 parametri: directory file
if (( $# < 1 ))
then
echo "inserire il pathname di una directory come parametro"
exit 1
fi

if [ ! -d $1 ]
then
echo "`pwd`/$1 non esiste o non è una directory"
exit 1
fi

DIR=$1

if (( $# == 2))
then
FILE=$2 # gli script ricorsivi usano lo stesso file del chiamante
else
FILE=tmp$$ # lo script iniziale crea un file temporaneo
fi

# salvo nel file temporaneo le informazioni che mi interessano di tutti i file
for i in `ls $DIR`
do
if [ -f $DIR/$i ]
then
stat -c "%y %n" $DIR/$i >> $FILE
elif [ -d $DIR/$i ]
then
$SCRIPT $DIR/$i $FILE # chiamata ricorsiva
fi
done

# eseguito solo dal primo script (non da quelli ricorsivi)
if (( $# != 2))
then
BEGIN=37 # indica il primo carattere da stampare per ogni riga
# cioè tutti quelli prima indicano la data di modifica del file
sort $FILE | cut --characters="$BEGIN-" # riordino per data e stampo il nome
rm $FILE
fi
</source>

==Soluzione di MV (python)==
<source lang="python">
import sys
import os

if(len(sys.argv) != 1):
DIR = sys.argv[1];
else:
print("inserire il pathname di una directory come parametro")
exit(1)

if os.path.isdir(DIR):
os.chdir(DIR)
else:
print("percorso non valido")
exit(1)

# NOTA: DIR mantiene sempre il percorso relativo dalla directory passata come parametro
def scanTree(DIR,lista):

c = len(DIR)-1
if(DIR[c] == '/' and c != 0):
DIR = DIR[0:c]

for el in os.listdir(DIR):
el = DIR+"/"+el
if os.path.isdir(el):
scanTree(el, lista)
elif os.path.isfile(el):
mtime = os.stat(el).st_mtime
lista.append((mtime,el)); # memorizzo i file in una tupla (mtime, path)

lista = []
scanTree('.', lista)
lista.sort() #NB: le tuple vengono ordinate in base al loro primo elemento (mtime)
for i in lista:
print(i[1])
</source>

Main Page

2015-04-13T09:52:13Z

MV:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 3 Prova Pratica 22-06-2011]]

[[Esercizio 3, prova pratica, 18-07-2013]]

[[Esercizio 3, prova pratica, 17-07-2014]]

[[Esercizio 1, prova pratica, 23-01-2014]]

[[Prova pratica Esercizio 3 esami 17_07_12 - 17_06_14 - 19_07_10]]

[[Prova pratica 23_01_14]]

[[Ampiezza di tutti i file di una directory divisi per suffisso (Prova pratica 29-05-2013)]]

[[Albero binario 2002-07-23]]

[[50 Sfumature di Fibonacci]]

[[Esercizio 1 Prova Pratica 20/06/12]]

[[Esercizio 3 Prova Pratica 17/06/14]]

[[Esercizio 3, prova pratica 13/09/2013]]

[[Prova pratica 17 07 14]]

[[Esercizio 1, prova pratica 20.01.2015]]

[[bash scripting 2002 gennaio]]

[[Process Race (Prova pratica 18-07-2013)]]

[[Arduino web controller]]

[[Esercizio 1, prova pratica 29.05.2013]]

[[Esercizio 1, prova pratica 29.05.2014]]

[[Esercizio 1, prova pratica 20.06.2013]]

[[Prova_pratica_21_01_15]]

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Prova Pratica 2011.06.22

2015-04-13T09:51:11Z

MV: Created page with "<source lang="text"> Scrivere uno script bash o un programma python che metta in ordine tutti i file di un sottoalbero dal piu' vecchio al piu' recente. La stampa finale deve ..."

Main Page

2015-03-11T16:02:19Z

MV:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizio 1, prova pratica 17.06.2014]]

[[Esercizio 1 - 25.09.2014]]

[[Esercizio 1, prova pratica 20/02/2014]]

[[Demone ruba input]]

[[wifi daemon]]

[[Esercizio 1, prova pratica 13/09/2013]]

[[Problema Dei Filosofi]]

[http://www.cs.unibo.it/~renzo/so/portability.tgz portability.tgz]

[[listx.h commentato + esempio su container_of]]

[[Congettura di Goldbach]]

[[list segments]]

[[Execv/fork su file aperto]]

[[Angry_Children]]

[[Esercizio 1, prova pratica 12/02/2009]]

[[(Programma C) Un quadrato nella matrice]]

[["classi"_in_C]]

[[Esempi del 02 dicembre 2014]]

[[Materiale dell'AA 2013-14]]
----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

Esercizio 1, prova pratica 17.06.2014

2015-03-11T16:00:33Z

MV: Created page with "<source lang="text"> Occorre scrivere due programmi: mytar myuntar. Mytar prende come parametro il nome di una directory e il nome di un file: mytar ddd ddd.mytar mytar crea i..."

<source lang="text">
Occorre scrivere due programmi: mytar myuntar.
Mytar prende come parametro il nome di una directory e il nome di un file:
mytar ddd ddd.mytar
mytar crea il file indicato come secondo parametro e registra in esso tutti i file regolari presenti nella directory (ddd
nell'esempio). Ogni file e' registrato nel secondo il seguente formato:
nome del file (stringa ASCII terminata da un byte 0)
lunghezza del file (stringa ASCII terminata da 0, la lunghezza e' registrata come stringa in rappresentazione in base 10
per non avere problemi di endianess e di ampiezza dei campi)
contenuto del file (un numero di byte corrispondente alla lunghezza indicata sopra).
Myuntar fa l'operazione inversa:
myuntar ddd.mytar newddd
crea la directory indicata come secondo parametro e, in essa, tutti i file registrati in ddd.mytar.
Per provare i due programmi, al termine dell'esecuzione di due comandi simili a quelli degli esempi mostrati qui sopra per
mytar e myuntar, tutti i file regolari presenti in ddd devono esistere in newddd e devono avere tutti lo stesso contenuto.
Se create una directory ddd contenente solo file regolare l'output di “diff -R ddd newddd” deve essere vuoto.
</source>

== Soluzione di MV ==
<source lang="text">
Per ora ho fatto solo la prima parte, cioè mytar.
L'unico problema che non riesco a capire è che entra in un loop infinito (scrivendo all'infinito sul file che crea!) se viene usato nella cartella dell'eseguibile stesso...
</source>

<source lang="c">
/*-------------------------------------MYTAR.C--------------------------------------------*/

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

#define BUF_DIM 512

/* scrive nome, dimensione e contenuto del file indicato da src nel file dest (già aperto in scrittura) */
int filecpy(const char *src, const int dest, off_t size);

/* ---------------------------------- MAIN ------------------------------- */
int main(int argc, char* argv[])
{
DIR *ddd;
int f;
struct dirent *entry;
struct stat dest_st;
int e,i,len;
char buf[BUF_DIM];

if(argc != 3)
{
printf("Error: needed 2 parameters\n");
return 1;
}

umask(0001);
/* Creo il file passato come secondo parametro */
if((f = open(argv[2], O_WRONLY|O_CREAT|O_TRUNC, 0666)) == -1)
{
printf("Error in open(): %s (%i)\n",strerror(errno),errno);
return errno;
}

/* Apro la directory passata come primo parametro, se c'è */
if((ddd = opendir(argv[1])) == NULL)
{
printf("Error in opendir(%s): %s (%i)\n",argv[1],strerror(errno),errno);
return errno;
}
/* mi sposto in quella directory */
if(chdir(argv[1]) == -1)
{
printf("Error in chdir(%s): %s (%i)\n",argv[1],strerror(errno),errno);
return errno;
}

e = errno;
i = 0; /* in i mantengo il numero totale di file copiati */
/* leggo lo stat del file che ho creato */
if(fstat(f, &dest_st) == -1)
{
printf("Error in stat(%s): %s (%i)\n",buf,strerror(errno),errno);
return errno;
}

/* leggo le entry della directory finchè ce ne sono */
while((entry = readdir(ddd)) != NULL)
{
struct stat st;

strcpy(buf, entry->d_name);

if(stat(buf, &st) == -1)
{
printf("Error in stat(%s): %s (%i)\n",buf,strerror(errno),errno);
return errno;
}
else if(st.st_mode & S_IFREG) /* è un file */
{
/* verifico che il file in questione sia diverso da quello aperto in scrittura, per evitare che scriva su se stesso all'infinito */
if((st.st_ino == dest_st.st_ino) && (st.st_rdev == dest_st.st_rdev))
continue;

if(filecpy(buf, f, st.st_size) == -1)
{
printf("Error in filecpy(%s, %i)\n",buf,f);
return -1;
}
printf("%s inserito.\n", buf);
i++;
}
}

if(e != errno) /* sono uscito dal ciclo a causa di un errore */
{
printf("Error in readdir(): %s (%i)\n",strerror(errno),errno);
return errno;
}
else /* perchè ho visitato tutte le entrate della directory */
printf("end of directory, %i entry found.\n", i);

return 0;
}

int filecpy(const char *src, const int dest, off_t size)
{
/* NB: dest è già aperto in scrittura */
int s, len, tot;
char buf[BUF_DIM];

if((s = open(src,O_RDONLY,0)) == -1) /* apro src in lettura */
return -1;

tot = write(dest, src, strlen(src)+1); /* per prima cosa copio il titolo del file src */
/* NB: faccio tot+1 per copiare anche lo 0 terminatore */
sprintf(buf, "%i", (int)size); /* poi copio la dimensione */
tot += write(dest, buf, strlen(buf)+1);

/* infine copio tutto il contenuto */
while( (len = read(s,buf,BUF_DIM)) != 0)
{
if(len == -1)
{
printf("Error in read(): %s (%i)\n",strerror(errno),errno);
return -1;
}
/*else printf("%i\n",len);*/
tot += write(dest, buf, len);
}

return tot; /* restituisce il numero totale di byte scritti */
}
</source>