Sistemi Operativi - User contributions [en]

Prova pratica 21 01 15

2015-04-03T11:32:02Z

Luca:

<source lang="text">
Es 1: scrivere un programma C di nome filepipe che abbia come unico parametro il pathname di un file di testo.
Questo file contiene due comandi con i rispettivi parametri, uno per riga.

Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi i comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>

<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2];
FILE *file=fopen(argv[1], "r");//apro file in lettura
char cmd1[256];
char cmd2[256];

fgets(cmd1, sizeof(cmd1), file);//memorizzo il primo comando in cmd1
fgets(cmd2, sizeof(cmd2), file);//memorizzo il 2 comando in cmd2

pipe(pfd);//creo i 2 descrittori

switch(fork()){
case 0: //figlio fornisce output
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd1);
exit(1);

case -1: exit(1);
}
switch(fork()){//figlio prende input
case 0:
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd2);
exit(1);

case -1: exit(1);
}
int status;
close(pfd[0]);
close(pfd[1]);
wait(&status);
wait(&status);
fclose(file);
}
</source>

<source lang="text">
Es 2: Il secondo esercizio estende il primo. Il file passato come parametro in questo caso ha un numero arbitario di righe e non solo due come nell'esercizio1.
Ogni riga contiene un comando con I rispettivi parametri. Il programma deve attivare tutti I comandi del file in modo concorrente, e terminare quando tutti finiscono.
L'output di tutti I comandi, tranne l'ultimo, deve essere fornito in input all'ultimo comando
(quello nell'ultima riga significativa del file).

Es: se il file contenesse:
ls -l
ls -l
ls -l
cat
l'output dovrebbe essere la lista dei file della corrente directory 3 volte (nell'output puo' capitare che righe di comandi diversi vengano frapposte, l'accesso alla pipe e' conteso).
</source>

<source lang="c">#include <stdio.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2], num_righe=0, tmp=0;
FILE *file=fopen(argv[1], "r");//apro file in lettura
char buff[256];
pipe(pfd);

while(fgets(buff, sizeof(buff), file)!=NULL){//calcolo il numero di righe del file
num_righe++;
}
char comandi[num_righe][256];//array di stringhe
rewind(file);

for(tmp=0; tmp<num_righe; tmp++){
fgets(comandi[tmp], sizeof(comandi[tmp]), file);//copio ogni comando per riga
//printf("comando num %d: %s\n", tmp, comandi[tmp]);
switch(fork()){
case 0:
if(tmp<num_righe-1){
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
if(tmp==num_righe-1){
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
case -1: exit(1);

}
}
int status;
close(pfd[0]);
close(pfd[1]);
for(tmp=0; tmp<num_righe; tmp++)
wait(&status);
fclose(file);
}
</source>

<source lang="text">
Esercizio 3: Script bash o Python:
Scrivere un programma python o uno script bash che scandisca il sottoalbero relativo alle directory passate come parametri (o alla direcotry corrente se non ci sono parametri) e
fornisca in output l'elenco dei file che hanno la stessa somma MD5 (i.e. l'output del comando md5sum).
In output ogni riga deve mostrare un elenco di pathname realtivi a file che hanno la stessa somma MD5 (che quindi sono molto molto probabilmente uguali).
</source>

<source lang="bash">
#! /bin/bash
trova () {
find $1 -type f -exec md5sum {} \; | sort > md5.txt #calcola l'md5 di tutto il sottoalbero, lo ordina e lo salva in un file
cat md5.txt | grep "`cut -d ' ' -f 1 md5.txt | uniq -d`" #stampa le righe del file, nelle quali in primo campo ha valore(md5) duplicato
}

if [[ $# -eq 0 ]] ; then #se num argomenti è 0
trova
else
for parametro in $* #chiamo la funzione per ogni argomento
do
trova $parametro
done
fi
exit
</source>

Esercizio 1 - 25.09.2014

2015-04-02T14:10:24Z

Luca:

<source lang="text">
Scrivere un programma che preso come parametro un file contenente un elenco di comandi (con I relativi parametri) li attivi
tutti in esecuzione concorrente e rimanga in attesa. Quando il primo termina, vengono terminati (con segnale SIGTERM) tutti
gli altri. (consiglio: puo' essere utile usare la mia libreria s2argv-execs)
esempio:
wta commands

il file commands contiene:
./ttest 40
./ttest 10
./ttest 20

lo script ./ttest contiene:
#!/bin/bash
echo waiting for $1 seconds
sleep $1
echo done $1

l'ouptut sara':
waiting for 40 seconds
waiting for 10 seconds
waiting for 20 seconds
done 10

e poi basta perche' gli altri processi verranno terminati.
</source>
== Possibile soluzione ==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <s2argv.h>
#include <sys/types.h>
#include <signal.h>

#define MAX 20

int contaRighe (FILE *A){
char *a;
int i=0;
a= malloc (MAX*sizeof(char));

if (a==NULL) {
perror ("malloc");
return -1;
}

while (fgets(a, MAX, A)){
if (*a==EOF || *a=='\n') break;
i++;
}

return i;
}

int main (int argc, char *argv []){
int status;
int i=0;
int j=0;
int z=0; /*indice per ampiezza "pid_t ID" e "char *comando"*/
char *comando[z];
pid_t ID [z]; /* memorizza i pid di tutti i processi attivati */
pid_t terminato; /* memorizza il pid del primo processo che termina*/

FILE *fd = fopen (argv[1], "r");

if( fd==NULL ) {
perror("Errore in apertura del file");
return -1;
}

j=contaRighe (fd); /*ritorna il numero di righe del file dato in input*/
z=j; /* setto gli array con il numero di righe del file contenente i comandi */

rewind(fd); /*ritorno all'inizio del file*/

/* riempie "comando[z]" con tutti i comandi presenti nel file passato, i comando sono contati da 1 a z. */
while (j!=0){
comando [i] = malloc (MAX*sizeof(char));
fgets(comando [i], MAX, fd);
i++;
j--;
}

i--; /* diminuisco "i" di uno perchè prima di uscire dall'ultimo ciclo è aumentata di uno, "j" è uguale a 0 */

/*ESEGUE TUTTI I COMANDI */
while (i>=0){
switch (ID[j]=fork()) {
case 0:
execsp(comando[j]);
perror("exec");
case -1:
perror ("fork");
return -1;
}
i--;
j++;
}

i=0; /*setto "i" a 0 per il prossimo while */

terminato=wait(&status);

/* TERMINA TUTTI I PROCESSI */
while(i<j){ /* "i" strettamente minore di "j" poichè nell'ultimo ciclo del precedente while viene incrementata di uno */
if (ID[i]!=terminato) {
printf ("Termina processo %d\n",ID[i]);
kill(ID[i], SIGTERM); /* mando segnale di terminazione a tutti i PID che non sono ancora terminati */
}
else printf ("Processo completato %d\n",ID[i]);
i++;
}

fclose (fd);
return 0;
}
</source>

----

<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <s2argv.h>
#include <signal.h>

int main(int argc, char *argv[]){
char buff[256];
int num_cmd=0, tmp=0, i=0, pfd[2];
FILE *file=fopen(argv[1], "r");
while(fgets(buff, sizeof(buff), file)!=NULL){//ottengo numero comandi
num_cmd++;
}
rewind(file);
char cmd[num_cmd][256];
int pid[num_cmd];
pipe(pfd);

for(i=0; i<num_cmd; i++){
fgets(cmd[i], sizeof(cmd[i]), file);
//printf("Comando %d: %s", i, cmd[i]);
switch(pid[i]=fork()){
case 0:
close(pfd[0]);
close(pfd[1]);
execsp(cmd[i]);
exit(1);
case -1: exit(1);
}
}
int status;
close(pfd[0]);
close(pfd[1]);
tmp=wait(&status);
for(i=0; i<num_cmd; i++){
if(tmp==pid[i])
continue;
kill(pid[i], SIGTERM);
printf("terminato il processo: pid[%d]=%d\n", i, pid[i]);
}
fclose(file);
}
</source>
--[[User:Blissett|Blissett]] ([[User talk:Blissett|talk]]) 14:12, 11 March 2015 (CET)

Prova pratica 21 01 15

2015-03-17T08:33:40Z

Luca:

Prova pratica 21 01 15

2015-03-17T08:30:34Z

Luca:

<source lang="text">
Es 1: scrivere un programma C di nome filepipe che abbia come unico parametro il pathname di un file di testo.
Questo file contiene due comandi con i rispettivi parametri, uno per riga.

Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi i comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>

<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2];
FILE *file=fopen(argv[1], "r");//apro file in lettura
char cmd1[256];
char cmd2[256];

fgets(cmd1, sizeof(cmd1), file);//memorizzo il primo comando in cmd1
fgets(cmd2, sizeof(cmd2), file);//memorizzo il 2 comando in cmd2

pipe(pfd);//creo i 2 descrittori

switch(fork()){
case 0: //figlio fornisce output
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd1);
exit(1);

case -1: exit(1);
}
switch(fork()){//figlio prende input
case 0:
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd2);
exit(1);

case -1: exit(1);
}
int status;
close(pfd[0]);
close(pfd[1]);
wait(&status);
wait(&status);
fclose(file);
}
</source>

<source lang="text">
Es 2: Il secondo esercizio estende il primo. Il file passato come parametro in questo caso ha un numero arbitario di righe e non solo due come nell'esercizio1.
Ogni riga contiene un comando con I rispettivi parametri. Il programma deve attivare tutti I comandi del file in modo concorrente, e terminare quando tutti finiscono.
L'output di tutti I comandi, tranne l'ultimo, deve essere fornito in input all'ultimo comando
(quello nell'ultima riga significativa del file).

Es: se il file contenesse:
ls -l
ls -l
ls -l
cat
l'output dovrebbe essere la lista dei file della corrente directory 3 volte (nell'output puo' capitare che righe di comandi diversi vengano frapposte, l'accesso alla pipe e' conteso).
</source>

<source lang="c">#include <stdio.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2], num_righe=0, tmp=0;
FILE *file=fopen(argv[1], "r");//apro file in lettura
char buff[256];
pipe(pfd);

while(fgets(buff, sizeof(buff), file)!=NULL){//calcolo il numero di righe del file
num_righe++;
}
char comandi[num_righe][256];//array di stringhe
rewind(file);

for(tmp=0; tmp<num_righe; tmp++){
fgets(comandi[tmp], sizeof(comandi[tmp]), file);//copio ogni comando per riga
//printf("comando num %d: %s\n", tmp, comandi[tmp]);
switch(fork()){
case 0: //figlio fornisce output
if(tmp<num_righe-1){
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
if(tmp==num_righe-1){
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
case -1: exit(1);

}
}
int status;
close(pfd[0]);
close(pfd[1]);
for(tmp=0; tmp<num_righe; tmp++)
wait(&status);
fclose(file);
}
</source>

Prova pratica 21 01 15

2015-03-17T08:12:51Z

Luca:

<source lang="text">
Es 1: scrivere un programma C di nome filepipe che abbia come unico parametro il pathname di un file di testo.
Questo file contiene due comandi con i rispettivi parametri, uno per riga.

Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi i comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>

<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2];
FILE *file=fopen(argv[1], "r");//apro file in lettura
char cmd1[256];
char cmd2[256];

fgets(cmd1, sizeof(cmd1), file);//memorizzo il primo comando in cmd1
fgets(cmd2, sizeof(cmd2), file);//memorizzo il 2 comando in cmd2

pipe(pfd);//creo i 2 descrittori

switch(fork()){
case 0: //figlio fornisce output
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd1);
exit(1);

case -1: exit(1);
}
switch(fork()){//figlio prende input
case 0:
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd2);
exit(1);

case -1: exit(1);
}
int status;
close(pfd[0]);
close(pfd[1]);
wait(&status);
wait(&status);
fclose(file);
}
</source>

<source lang="text">
Es 2: Il secondo esercizio estende il primo. Il file passato come parametro in questo caso ha un numero arbitario di righe e non solo due come nell'esercizio1.
Ogni riga contiene un comando con I rispettivi parametri. Il programma deve attivare tutti I comandi del file in modo concorrente, e terminare quando tutti finiscono.
L'output di tutti I comandi, tranne l'ultimo, deve essere fornito in input all'ultimo comando
(quello nell'ultima riga significativa del file).

Es: se il file contenesse:
ls -l
ls -l
ls -l
cat
l'output dovrebbe essere la lista dei file della corrente directory 3 volte (nell'output puo' capitare che righe di comandi diversi vengano frapposte, l'accesso alla pipe e' conteso).
</source>

<source lang="c">#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2], c=0, tmp=0, f=0;
FILE *file=fopen(argv[1], "r");//apro file in lettura
char buff[256];

while(fgets(buff, sizeof(buff), file)!=NULL){//calcolo il numero di righe del file
c++;
}
char comandi[c][256];//array di stringhe
rewind(file);

for(tmp=0; tmp<c; tmp++){
fgets(comandi[tmp], sizeof(comandi[tmp]), file);//copio ogni comando per riga
comandi[tmp][strlen(comandi[tmp])-2]='\0';//elimino l' EOL
switch(fork()){
case 0: //figlio fornisce output
if(tmp==0){
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
if(tmp==1){
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
if(tmp%2==0){
execsp(comandi[tmp]);
exit(1);
}
if(tmp%2==1){
execsp(comandi[tmp]);
exit(1);
}

case -1: exit(1);
}
}
int status;
wait(&status);
fclose(file);
}
</source>

N.B ci sono problemi relativi all ultimo comando

Prova pratica 21 01 15

2015-03-12T09:54:03Z

Luca:

<source lang="text">
Es 1: scrivere un programma C di nome filepipe che abbia come unico parametro il pathname di un file di testo.
Questo file contiene due comandi con i rispettivi parametri, uno per riga.

Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi i comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>

<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2];
FILE *file=fopen(argv[1], "r");//apro file in lettura
char cmd1[256];
char cmd2[256];

fgets(cmd1, sizeof(cmd1), file);//memorizzo il primo comando in cmd1
fgets(cmd2, sizeof(cmd2), file);//memorizzo il 2 comando in cmd2

cmd1[strlen(cmd1)-2]='\0';//tronco la stringa eliminando l'EOL
cmd2[strlen(cmd2)-2]='\0';

pipe(pfd);//creo i 2 descrittori

switch(fork()){
case 0: //figlio fornisce output
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd1);
exit(1);

case -1: exit(1);
}
switch(fork()){//figlio prende input
case 0:
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd2);
exit(1);

case -1: exit(1);
}
int status;
wait(&status);
fclose(file);
}
</source>

<source lang="text">
Es 2: Il secondo esercizio estende il primo. Il file passato come parametro in questo caso ha un numero arbitario di righe e non solo due come nell'esercizio1.
Ogni riga contiene un comando con I rispettivi parametri. Il programma deve attivare tutti I comandi del file in modo concorrente, e terminare quando tutti finiscono.
L'output di tutti I comandi, tranne l'ultimo, deve essere fornito in input all'ultimo comando
(quello nell'ultima riga significativa del file).

Es: se il file contenesse:
ls -l
ls -l
ls -l
cat
l'output dovrebbe essere la lista dei file della corrente directory 3 volte (nell'output puo' capitare che righe di comandi diversi vengano frapposte, l'accesso alla pipe e' conteso).
</source>

<source lang="c">#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2], c=0, tmp=0, f=0;
FILE *file=fopen(argv[1], "r");//apro file in lettura
char buff[256];

while(fgets(buff, sizeof(buff), file)!=NULL){//calcolo il numero di righe del file
c++;
}
char comandi[c][256];//array di stringhe
rewind(file);

for(tmp=0; tmp<c; tmp++){
fgets(comandi[tmp], sizeof(comandi[tmp]), file);//copio ogni comando per riga
comandi[tmp][strlen(comandi[tmp])-2]='\0';//elimino l' EOL
switch(fork()){
case 0: //figlio fornisce output
if(tmp==0){
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
if(tmp==1){
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(comandi[tmp]);
exit(1);
}
if(tmp%2==0){
execsp(comandi[tmp]);
exit(1);
}
if(tmp%2==1){
execsp(comandi[tmp]);
exit(1);
}

case -1: exit(1);
}
}
int status;
wait(&status);
fclose(file);
}
</source>

N.B ci sono problemi relativi all ultimo comando

Prova pratica 21 01 15

2015-03-11T16:06:47Z

Luca:

Main Page

2015-03-11T16:03:56Z

Luca:

Questo è il Wiki del Corso di Sistemi Operativi

[[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 21 01 15

2015-03-11T16:02:47Z

Luca: Created page with "<source lang="text"> Scrivere un programma C di nome filepipe che abbia come unico parametro il pathname di un file di testo. Questo file contiene due comandi con i rispettivi..."

<source lang="text">
Scrivere un programma C di nome filepipe che abbia come unico parametro il pathname di un file di testo.
Questo file contiene due comandi con i rispettivi parametri, uno per riga.

Il programma deve mettere in esecuzione concorrente I due comandi in modo che l'output del primo venga fornito come input del secondo usando una pipe.
Il programma deve terminare quando entrambi i comandi sono terminati.
Esempio: se il file ffff contiene:
ls -l
tac
il comando:
filepipe ffff
deve restituire lo stesso output del comando:
ls -l | tac
</source>

<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <s2argv.h>
#include <string.h>

int main(int argc, char *argv[]){
int pfd[2];
FILE *file=fopen(argv[1], "r");//apro file in lettura
char cmd1[256];
char cmd2[256];

fgets(cmd1, sizeof(cmd1), file);//memorizzo il primo comando in cmd1
fgets(cmd2, sizeof(cmd2), file);//memorizzo il 2 comando in cmd2

cmd1[strlen(cmd1)-2]='\0';//tronco la stringa eliminando l'EOL
cmd2[strlen(cmd2)-2]='\0';

pipe(pfd);//creo i 2 descrittori

switch(fork()){
case 0: //figlio fornisce output
dup2(pfd[1], STDOUT_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd1);
exit(1);

case -1: exit(1);
}
switch(fork()){//figlio prende input
case 0:
dup2(pfd[0], STDIN_FILENO);
close(pfd[0]);
close(pfd[1]);
execsp(cmd2);
exit(1);

case -1: exit(1);
}
int status;
wait(&status);
fclose(file);
}
</source>