Sistemi Operativi - User contributions [en]

Prova Teorica 2011.05.13

2015-05-27T07:04:23Z

Maldus:

==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>
Nota di Maldus: se nella funzione lifocs_exit rilascio la mutua esclusione prima di chiamare la V() sul semaforo che era in cima secondo me c'è il pericolo che tra le due istruzioni si inserisca un'altra lifocs_exit che invece arrivi fino in fondo, svegliando così il penultimo processo piuttosto che l'ultimo sulla pila. La soluzione è fare passaggio del testimone: la lifocs_exit non rilascia la mutua esclusione, lasciando l'onere di farlo alla lifocs_enter, immediatamente dopo la chiamata a sem.P()
==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>

2015-04-13T20:20:08Z

Maldus:

==Testo==
<source lang="text">
Scrivere un programma chiamato spy che tenga sotto controllo una directory (il cui pathname viene passato come unico
paramentro), e segnali, stampandone il nome, ogni file che viene creato in tale directory.
Si faccia uso della interfaccia inotify (leggere la pagina di manuale).
Attenzione: il buffer per gli eventi deve avere dimensione superiore a quella della struttura inotify_event altrimento non c'e'
spazio per il campo name.

</source>

===Soluzione di Davide Boldrin===
<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <linux/inotify.h>

#define EVENT_SIZE ( sizeof (struct inotify_event) )
#define EVENT_BUF_LEN ( 1024 * ( EVENT_SIZE + 16 ) )

int main(int argc, char *argv[]){
while(1){
int length, i = 0;
int fd;
int wd;
char buffer[EVENT_BUF_LEN];

fd = inotify_init();

if ( fd < 0 ) {
perror( "inotify_init" );
}

wd = inotify_add_watch( fd, argv[1], IN_CREATE | IN_DELETE );

length = read( fd, buffer, EVENT_BUF_LEN );

if ( length < 0 ) {
perror( "read" );
}

while ( i < length) {
struct inotify_event *event = ( struct inotify_event * ) &buffer[ i ];
if ( event->len ) {
if ( event->mask & IN_CREATE ) {
if ( event->mask & IN_ISDIR ) {
printf( "Nuova cartella %s creata.\n", event->name );
}
else {
printf( "Nuovo file %s creato.\n", event->name );
}
}
else if ( event->mask & IN_DELETE ) {
if ( event->mask & IN_ISDIR ) {
printf( "Cartella %s eliminata.\n", event->name );
}
else {
printf( "File %s eliminato.\n", event->name );
}
}
}
i += EVENT_SIZE + event->len;
}

}
}

</source>

Qualcuno ha idea di come implementare l'esercizio 2 dello stesso appello!?

Nota del Prof: l'esercizio non prevedeva il controllo delle directory create/eliminate. Se e' stato compreso il funzionamento e non e' solo una traduzione della [http://www.thegeekstuff.com/2010/04/inotify-c-program-example/ fonte], allora basta mettere al riconoscimento del file una access o simili pervedere se e' eseguibile, fork/exec per eseguire il file e infine unlink per eliminarlo. [[User:Renzo|Renzo]] ([[User talk:Renzo|talk]]) 16:27, 7 April 2015 (CEST)

===Soluzione di Maldus===
'''Esercizio 2'''
<source lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <errno.h>
#include <limits.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#define SIZE sizeof(struct inotify_event) + NAME_MAX + 1

char buf[SIZE]; /*creo un buffer in grado di contenere una sola struttura inotify_event; dovrebbe essere più grande?*/

int main( int argc , char* argv[]){
int fd , w , status;
pid_t id;
struct inotify_event* event;
if( argc < 2 ){
printf("not enough arguments\n") ;
exit(1) ;
}
fd = inotify_init();
if( fd == -1) perror("inotify_init:");
w = inotify_add_watch( fd , argv[1] , IN_CREATE | IN_DELETE_SELF );
if( w == -1 ) perror("inotify_add_watch:");
printf("%s sotto controllo:\n", argv[1]) ;
chdir(argv[1]);
while(1){
read( fd , buf , SIZE );
event = (struct inotify_event*) &buf[0] ;
if( event->mask & IN_DELETE_SELF) break;
else if(event->mask & IN_CREATE){
if(!(event->mask & IN_ISDIR)){
printf("Creato %s\n" , event->name);
if( access(event->name, X_OK)== 0){
if( fork() ){
wait(&status);
if( unlink(event->name) == -1 ) perror("unlink:");
}
else{
execl( event->name , event->name , NULL);
perror("execl:");
exit(1);

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

'''Esercizio 3'''
<source lang="python">
import fnmatch, os , sys

sum=0

if len(sys.argv)<2:
print("not enough arguments")
sys.exit(2)

for file in os.listdir('.'):
if fnmatch.fnmatch(file, sys.argv[1]):
sum=sum + os.stat(file).st_size

print("totale: %i" %sum)
</source>

2015-04-02T20:21:17Z

Maldus: Created page with "Consegna([http://www.cs.unibo.it/~renzo/so/pratiche/2013.09.13.pdf]): <source lang="text"> Sia data una directory che contiene file di testo. Scopo dell'esercizio e' di contar..."

Esercizio 1, prova pratica 29.05.2013

2015-03-25T08:28:01Z

Maldus:

<source lang="text">
Scrivere un programma testeventfd che faccia uso della system call eventfd.
In particolare il programma deve eseguire una fork, quando l'utente digita un numero letto dal processo padre, il processo
figlio deve stampare un numero uguale di x.
</source>
==Soluzione di Pierg==
<source lang="c">
#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

int main (int argc, char *argv[]) {

int efd, i;
long long unsigned int val;
ssize_t s;

/* Check for eventfd error */
efd = eventfd(0, 0);
if (efd == -1) {
perror("Eventfd Error");
}

/* Use fork to move eventfd form parent to child */
switch (fork()) {

case 0:
/* Read parent event */
s = read(efd, &val, sizeof(long long unsigned int));

if (s != sizeof(long long unsigned int)) {
perror("Read Error");
exit(EXIT_FAILURE);
}

/* For is used to print the 'x' of the argument passed by terminal */
for (i = (int)val; i > 0; i--) {
printf ("x\n");
}

exit(EXIT_SUCCESS);

/* Check for error */
case -1:
perror("Fork Error");
exit(EXIT_FAILURE);

default:
/* Wait for number */
printf ("Inserisci un intero diverso da 0: \n");
scanf ("%llu", &val);

/* Write parent event */
s = write(efd, &val, sizeof(long long unsigned int));

if (s != sizeof(long long unsigned int)) {
perror("Write Error");
exit(EXIT_FAILURE);
}

exit(EXIT_SUCCESS);
}
}
</source>

==Soluzione di Maldus==
Semaforo implementato usando un altro eventfd.
<source lang="c">
#include <stdio.h>
#include <sys/eventfd.h>
#include <inttypes.h>
#include <sys/types.h>
#include <signal.h>

int main(){
pid_t son ;
int ed1 , ed2 , i;
uint64_t x = 1;
int y = 1 ;
ed1 = eventfd(0,0) ; /*eventfd usato per la comunicazione effettiva del numero*/
ed2 = eventfd( 1 , EFD_SEMAPHORE ) ; /*eventfd usato come semaforo*/
switch( son = fork() ){
case 0:
while( 1 ){
read( ed1 , &x , 8) ; /*se ci sono dei dati li legge*/
for(i = x ; i > 0 ; i--) printf( "x" ) ;
printf("\n");
write(ed2 , &y , 8 ) ; /*dopo la lettura dei dati, dà il via libera sul semaforo per scrivere di nuovo*/
}
return 1;
default:
while( x ){
read( ed2 , &y , 8 ) ; /*si blocca sul semaforo se i dati non sono ancora stati letti*/
scanf("%" PRIu64 , &x) ;
write(ed1 , &x , 8 ) ; /*scrittura dei dati*/
}
kill(son ,SIGTERM);
return 0 ;
}
}
</source>

Esercizio 1, prova pratica 29.05.2013

2015-03-23T22:31:32Z

Maldus:

<source lang="text">
Scrivere un programma testeventfd che faccia uso della system call eventfd.
In particolare il programma deve eseguire una fork, quando l'utente digita un numero letto dal processo padre, il processo
figlio deve stampare un numero uguale di x.
</source>
==Soluzione di Pierg==
<source lang="c">
#include <sys/eventfd.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

int main (int argc, char *argv[]) {

int efd, i;
long long unsigned int val;
ssize_t s;

/* Check for eventfd error */
efd = eventfd(0, 0);
if (efd == -1) {
perror("Eventfd Error");
}

/* Use fork to move eventfd form parent to child */
switch (fork()) {

case 0:
/* Read parent event */
s = read(efd, &val, sizeof(long long unsigned int));

if (s != sizeof(long long unsigned int)) {
perror("Read Error");
exit(EXIT_FAILURE);
}

/* For is used to print the 'x' of the argument passed by terminal */
for (i = (int)val; i > 0; i--) {
printf ("x\n");
}

exit(EXIT_SUCCESS);

/* Check for error */
case -1:
perror("Fork Error");
exit(EXIT_FAILURE);

default:
/* Wait for number */
printf ("Inserisci un intero diverso da 0: \n");
scanf ("%llu", &val);

/* Write parent event */
s = write(efd, &val, sizeof(long long unsigned int));

if (s != sizeof(long long unsigned int)) {
perror("Write Error");
exit(EXIT_FAILURE);
}

exit(EXIT_SUCCESS);
}
}
</source>

==Soluzione di Maldus==
<source lang="c">
#include <stdio.h>
#include <sys/eventfd.h>
#include <inttypes.h>
#include <sys/types.h>
#include <signal.h>
#include <semaphore.h>

int main(){
sem_t empty , full ;
pid_t son ;
int ed , status, i;
uint64_t x = 1;
ed = eventfd(0,0) ;
sem_init( &full , 1 , 0) ;
sem_init( &empty , 1 , 1 ) ;
switch( son = fork() ){
case 0:
while( x){
scanf("%" PRIu64 , &x) ;
sem_wait(&empty) ;
write(ed , &x , 8 ) ;
sem_post(&full) ;
}
kill(son ,SIGTERM);
return 0 ;
default:
while( 1 ){
sem_wait(&full);
read( ed , &x , 8) ;
for( i = x ; i > 0 ; i--) printf( "x\n" ) ;
sem_post(&empty) ;
}
return 1;
}
}
</source>
Siccome la write su di un event descriptor somma il valore dal buffer, se questa viene effettuata prima della lettura (che lo riporta a 0) il risultato ottenuto non è quello richiesto. Benchè sia altamente improbabile che una situazione del genere si verifichi in questo programma, ho cercato di evitarla usando i semafori (si tratta di un problema produttore/consumatore), senza successo: non riesco a capire perchè, ma sembra che le sem_post non incrementino il valore del semaforo.
Togliendo sem_wait e sem_post il programma funziona correttamente.

Esercizio 1, prova pratica 13/09/2013

2015-03-04T20:55:32Z

Maldus:

Consegna([http://www.cs.unibo.it/~renzo/so/pratiche/2013.09.13.pdf]):
<source lang="text">
Lo scopo del programma che dovrete scrivere e' di confrontare fra loro i file di una directory, se ne trovate due (o piu') che
hanno lo stesso contenuto dovete unificarli. Alla fine del processo l'elenco dei file della directory deve rimanere invariato ma
i nomi dei file che avevano lo stesso contenuto devono essere link fisici che indicano lo stesso file.
In questo esercizio si richiede che l'intero contenuto dei file venga confrontato.
</source>

==Soluzione di Maldus (ora con tabella hash!)==
<source lang="c">
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <fcntl.h>
#include <stdlib.h>

#define SIZE 1024

char BUFF1[SIZE] ; /*buffer usati per leggere i file*/
char BUFF2[SIZE] ;

struct list{ /*struttura che uso per implementare la lista di file che hanno uguale somma crittografica*/
struct dirent* ent ;
struct list *next ;
struct list *prev ;
};

inline void del(struct list* p){ /*rimuove p dalla lista in cui si trova*/
(p->next)->prev = p->prev ;
(p->prev)->next = p->next ;
free(p) ;
}

int critsum( int f ){ /*somma crittografica per la tabella hash*/
int i , n ;
int x = 0 ;
while(( n = read( f , BUFF1 , SIZE ) )> 0 ){
for( i = 0 ; i < n ; i++ ){
x += ((int) BUFF1[i])*((i%8)+1) ; /*aggiungo ogni volta il valore numerico corrispondente al byte letto moltiplicato per un numero da 1 a 8*/
}
}
if( x < 0) return -x ;/*restituisco sempre un valore positivo, perchè possa essere usato come indice di un vettore*/
else return x ;
}

int buffcmp( char* buf1 , char* buf2 , int s1 , int s2 ){/*funzione che compara due buffer*/
int i ;
if( s1 != s2 ) return 1 ; /*se hanno lunghezza diversa sono diversi*/
for( i = 0 ; i < s1 ; i++ ){
if( buf1[i] != buf2[i] ) return 1 ;
}
return 0 ;
}

int filecmp( int f1 , int f2 ){ /*funzione ausiliaria che confronta due file. Si comporta come strcmp*/
int n1 , n2 ;
while(( n1 = read( f1 , BUFF1 , SIZE ) )> 0 ){ /*ho provato a inserire entrambe le read nel controllo del while con un &&; mi creava dei problemi, come se la seconda read venisse eseguita nel giro seguente del ciclo*/
n2 = read( f2 , BUFF2 , SIZE ) ;
if( buffcmp( BUFF1 , BUFF2 , n1 , n2 ) != 0 ) return 1 ; /*ritorna 1 se i due file sono diversi*/
}
return 0 ; /*ritorna 0 se sono uguali*/
}

void del_clones( struct list* p ){ /*cerca nella lista il cui primo elemento è p tutti i file con lo stesso contenuto*/
struct list *aux1 , *aux2 , *tmp;
int fd1, fd2 ;
struct stat s1 , s2 ;
aux1 = p ;
aux2 = aux1->next ;
while( aux1->next != p ){
printf( "%s:\n" , (aux1->ent)->d_name ) ;
if( stat( (aux1->ent)->d_name , &s1 ) != 0 ){
perror("stat") ;
exit(1) ;
}
if ( (fd1 = open((aux1->ent)->d_name, O_RDONLY ) ) == -1){ /*apro la entry*/
perror("open") ;
exit(1) ;
}

while( (aux2->next) != p && (aux2 != p) ){
tmp = aux2->next ;
if( stat( (aux2->ent)->d_name , &s2 ) != 0 ){
perror("stat") ;
exit(1) ;
}
if ( (fd2 = open((aux2->ent)->d_name, O_RDONLY ) ) == -1){ /*apro la entry*/
perror("open") ;
exit(1) ;
}
printf("\t%s" , (aux2->ent)->d_name) ;
if( s1.st_ino != s2.st_ino){
if( filecmp( fd1 , fd2 ) == 0 ){ /*controllo se i due file hanno lo stesso contenuto*/
printf("<-uguale\t") ;
unlink((aux2->ent)->d_name) ; /*rimuovo il file uguale*/
if( link( (aux1->ent)->d_name , (aux2->ent)->d_name) == -1 ){ /*creo un link fisico*/
perror("link") ;
exit(1) ;
}
del(aux2) ;
}
}
else del(aux2) ; /*se hanno lo stesso i-node toglili dalla lista*/
aux2 = tmp; /*tmp = aux2->next. Lo salvo in precedenza nel caso in cui aux2 sia stato cancellato*/
close(fd2) ;
}
printf("\n") ;
close(fd1) ;
aux1 = aux1->next ;

}
}

int main( int argc, char* argv[]){
struct stat s1 , s2; /*struttura di informazioni su un file*/
DIR *dir ; /*puntatore a directory*/
struct dirent *entry ; /*struttura di informazioni sulle entry di una directory*/
int fd1; /*descrittore di file*/
char *name ;
int n = 0 ; /*contatore di file all'interno della directory*/
int cs , i ; /*cs è somma crittografica del file*/
struct list *hash ;
struct list *tmp ;
if( stat( argv[1] , &s1 ) != 0 ){
perror("stat") ;
return 1 ;
}
if( !S_ISDIR(s1.st_mode) ){
printf( "argument is not a valid directory\n" ) ;
return 0 ;
}
if( (dir = opendir( argv[1] )) == NULL ){
perror("opendir") ;
return 1 ;
}
if( chdir( argv[1] ) == -1 ){ /*sposto la directory corrente in quella di esecuzione per poter aprire i file*/
perror("chdir") ;
return 1 ;
}
while( (entry = readdir(dir) ) != NULL){ /*conto i file contenuti nella directory*/
stat( entry->d_name , &s1 ) ;
if( S_ISREG(s1.st_mode) ) n++ ; /*se si tratta di un file normale contalo*/
}
printf("La directory contiene %i file\n" , n ) ;
n = 2*n ; /*da questo momento n è il numero di indici nella mia hashtable*/
hash = (struct list*) malloc( sizeof(struct list)*n) ; /*alloco una hash table con n = 2n indici*/
rewinddir(dir) ;
for( i = 0 ; i < n ; i++ ){ /*inizializzo le liste*/
hash[i].next = &hash[i] ;
hash[i].prev = &hash[i] ;
hash[i].ent = NULL ;
}
while( (entry = readdir(dir) ) != NULL){ /*con questo ciclo riempo la hashtable*/
stat( entry->d_name , &s1 ) ;
if( S_ISREG(s1.st_mode) ){ /*se si tratta di un file normale consideralo*/
if ( (fd1 = open(entry->d_name, O_RDONLY ) ) == -1){ /*apro la entry*/
perror("open") ;
exit(1) ;
}
cs = critsum( fd1 ) ;
tmp = (struct list*) malloc( sizeof(struct list) ) ;
tmp->ent = entry ;
(hash[cs%n].next)->prev = tmp ; /*inserisco il file in testa alla lista di indice cs%n*/
tmp->prev = &hash[cs%n] ;
tmp->next = hash[cs%n].next ;
hash[cs%n].next = tmp ;
close(fd1) ;
}
}
for( i = 0 ; i < n ; i++ ){ /*con questo ciclo cancello effettivamente i file uguali*/
printf("%i: " , i ) ;
if( hash[i].next != &hash[i] ){
del_clones( hash[i].next ) ;
}
else printf("\n") ;
}
return 0 ;
}
</source>

Esercizio 1, prova pratica 13/09/2013

2015-03-03T09:52:10Z

Maldus:

Esercizio 1, prova pratica 13/09/2013

2015-03-02T20:30:38Z

Maldus:

2014-12-02T16:16:17Z

Maldus:

scrivere un programma C che faccia lseek a 1miliardo (SEEK_SET) e scriva "ciao".

<source lang="c">
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

int main( int argc, char* argv[]){
int f;
f = open( argv[1] , O_WRONLY | O_CREAT );
lseek( f , 1000000000 , SEEK_SET ) ;
write( f , "ciao" , 4 ) ;
return 0 ;
}
</source>
Non sono effettivamente riuscito ad aprire il file creato, ma ha la dimensione di 1 Gigabyte.

Esempi del 02 dicembre 2014

2014-12-02T16:15:34Z

Maldus:

Esercizio 1, prova pratica 12/02/2009

2014-11-22T08:39:22Z

Maldus: Created page with "Ho provato a svolgere l'esercizio 1 dell'esame di laboratorio del 2 febbraio 2009 ([http://www.cs.unibo.it/~renzo/so/pratiche/2009.02.12.pdf]). Consegna: <source lang="text">..."

Ho provato a svolgere l'esercizio 1 dell'esame di laboratorio del 2 febbraio 2009 ([http://www.cs.unibo.it/~renzo/so/pratiche/2009.02.12.pdf]).

Consegna:
<source lang="text">
Esercizio1 (obbligatorio): (10 punti)
Scrivere un programma C denominato “invarg” che esegua il programma passato come parametro invertendo gli argomenti.
Esempio:
invarg cat a b c
deve avere l'effetto di
cat c b a
</source>

==Soluzione di Maldus==
<source lang="c">
#include <stdio.h>
#include <stdlib.h>

int main(int argc , char* argv[]){
char *nargv[argc-1] ; /*nargv è il vettore degli argomenti da passare al programma da eseguire*/
int i , j ; /*puntatori che scorrono, rispettivamente, argv ed nargv per riempire correttamente nargv*/
nargv[0] = argv[1] ; /*il primo valore di nargv deve essere il programma chiamato, l'ultimo deve essere NULL*/
nargv[argc-1] = NULL ;
for( i = argc - 1 , j = 1 ; i > 1 , j < (argc - 1) ; i-- , j++ ) nargv[j] = argv[i] ; /*metto in nargv (dal secondo elemento in poi) gli argomenti presenti
in argv in ordine invertito*/
execvp( nargv[0] , nargv ) ; /*eseguo il programma (il cui nome è contenuto in nargv[0]) passandogli nargv come vettore di parametri*/
fprintf( stderr , "programma errato\n" ) ; /*se ci troviamo in questo punto significa che la chiamata a execvp è fallita, probabilmente
perchè il programma indicato non è stato trovato*/
exit(1) ;
}
</source>

Main Page

2014-11-22T08:34:37Z

Maldus:

Questo è il Wiki del Corso di Sistemi Operativi

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

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

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

[["classi"_in_C]]

[[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]]