[C] Problema puntatori e memoria condivisa! [Archivio]

SuperNoa

31-08-2006, 13:14

Ciao a tutti, anche io come dados881 sto cercando di imparare l'utilizzo della memoria condivisa regolata da semafori!
Ora vi posto il mio programma, c'è un codice per il server ed uno per il client, la compilazione va a buon fine, ma c'è qualche errore logico poichè nell'esecuzione ho un "Segmentation fault"!

In particolare ho qualche dubbio e difficoltà riguardo l'utilizzo dei puntatori nella memoria, infatti ho bisogno di azzerare la prima cella di memoria per utilizzarla come contatore, e farla incrementare dai client che scriveranno in memoria, ma per creare un contatore, ho bisogno di un puntatore di tipo int, mentre per scrivere nelle altre locazioni di memoria ho bisogno di un puntatore di tipo struct, posso scrivere nella memoria dati di tipo diverso? E se si come faccio poi per l'attach della memoria, perchè se uso per l'attach un puntatore di tipo struct, poi non posso accedere alla prima locazione che dovrebbe essere di interi, d'altronde non posso azzerare una locazione di tipo struct! Quindi come faccio?

Altra domandina, ho provato a cercare su internet un pò di materiale e ho visto che nell'operazione di attach
"shmPtr=(struct prenotazione*)shmat(shmid,0,0);" ,da qualche parte facevano il cast per assegnare al puntarore l'indirizzo della memoria altre fonti invece non lo facevano, tipo: "shmPtr=shmat(shmid,0,0);" , perchè?
Illuminatemi, please! :'(

P.S. Di sicuro manca qualcosa, il programma è incompleto, in modo particolare il client, ma mi sono fermato cercando di capire l'errore "Segmentation fault" in fase di esecuzione e quindi cercando di scigliere quei dubbi sull'utilizzo del contatore nella memoria!

/*La compagnia aerea Sky Airline ha pensato di oﬀrire ai clienti dell’agenzia di viaggi Volare
di Napoli per il mese di agosto una oﬀerta eccezionale sull’unico volo giornaliero da Napoli a
Barcellona. Le condizioni dell’oﬀerta sono le seguenti:
• possono partecipare solo nuclei familiari composti da almeno 2 persone;
• l’oﬀerta sarà valida solo se per il giorno scelto ci sono almeno 50 e al più 250 prenotazioni;
• le prenotazioni devono avvenire solo il giorno 10 luglio dalle 11:00 alle 12:00, presso l’agenzia Volare;
• i clienti avranno conferma o meno immediatamente dopo le 12:00 del 10 luglio.
La compagnia aerea ha allora fornito alla agenzia Volare un software Server, di nome Offerta,
ed un software Client, di nome Prenotazione, tale che se la famiglia Rossi, composta da 4
persone, è interessata all’oﬀerta per il giorno 25 agosto, potrà digitare sul computer messo a disposizione dall’agenzia Prenotazione Rossi 25 4
Scrivere in linguaggio C il codice per il processo Server Offerta e per il generico processo client
Prenotazione: il processo Server deve controllare per ciascuno dei giorni del mese di agosto
che il numero di prenotazioni rientri nei limiti stabiliti. I client hanno 1 ora di tempo per
inserire. Il processo Server deve comunicare l’esito dell’oﬀerta per ciascuno dei giorni del mese
di agosto.

- Implementare il precedente scenario ipotizzando che la comunicazione da client
a server avvenga attraverso la memoria condivisa il cui accesso sia regolato da un semaforo.
Il server comunica l’esito dell’oﬀerta alla scadenza dell’ora scrivendolo sullo standard output: per
ciascuno dei giorni di agosto comunica solo se tutte le prenotazioni fatte sono accettate o no.*/

SERVER

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h> // utilizzate per i semafori e shm
#include <sys/ipc.h> // utilizzate per i semafori e shm
#include <sys/sem.h> // utilizzate per i semafori
#include <sys/shm.h> // utilizzata per la shm
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
# include <string.h>
#define SIZE 32 // l'array deve immagazinare dati per tutti i 31 giorni di agosto
// non usiamo la locazione 0
#define SHMSIZE 1000

void alrm(int s);

int i, done, count, data, semid, shmid;

struct prenotazione{
char cognome[20];
int data;
int n_persone;
int pid;
}pren; // variabile di tipo struct prenotazione

int *countPtr;
struct prenotazione *shmPtr; // puntatore di tipo struct prenotazione

int giorno[SIZE]; // nell'array giorno[] immagaziniamo il numero di persone prenotate giorno per giorno

int main() {

int count = 0;
int done = 1;

key_t mykey1 = 1234; // chiave del semaforo
key_t mykey2 = 4321; // chiave della memoria

for(i=0;i<=SIZE;i++){ // azzeriamo il vettore
giorno[i]=0;
}

union semun{ // struttura utilizzata da semctl con SETVAL per settare il valore del semaforino

int val; // a 1, infatti alla variabile val sarà assegnato il valore 1

} arg;

arg.val=1;

// il valore sem_lock viene sottratto al valore del semaforino (valore del semaforino nella struttura sem)
struct sembuf sem_lock={0,-1,0}; // lock del semaforo di 1 risorsa sul primo semaforino
// il valore sem_unlock viene sommato al valore del semaforino (valore del semaforino nella struttura sem)
struct sembuf sem_unlock={0,1,0}; // unlock del semaforo

// creiamo il semaforo
semid=semget(mykey1,1,IPC_CREAT|IPC_EXCL|0666);

semctl(semid,0,SETVAL,1); // settiamo il primo semaforino ad 1, la risorsa è presa da arg.val

// inizializiamo a 0 la prima cella di memoria, la utilizzeremo come contatore dei client
shmid= shmget(mykey2, SHMSIZE, IPC_CREAT|0600); // creiamo la memoria condivisa
semop(semid, &sem_lock, 1); // lockiamo 1 unità di risorsa
shmPtr=(struct prenotazione*)shmat(shmid,0,0); // lo 0 al 2° parametro, indica che attacca il segmento dove possibile
*countPtr=0; // nello spazio dati del processo
shmdt(shmPtr);
semop(semid,&sem_unlock,1);

signal(SIGALRM,alrm); // signal cattura SIGALARM e la lancia la funzione alrm
alarm(30); // il server resterà attivo per un ora 3600, ( vabbè facciamo 30s ) solo per verificare il funzionamento

while(done==0){ // contiamo i client che hanno scritto nella memoria
printf("Il tempo per l'inserimento è scaduto\n");
printf("Hanno scritto nella memoria %d client", count);

semop(semid, &sem_lock,1);
shmPtr=shmat(shmid,0,SHM_RDONLY);
count = *countPtr;

for(i= 1; i <= count; i++ ){ // un for dalla loazione 1 fino al n° di client che hanno scritto
data = pren.data;
printf("in data %d agosto il signor %s ha prenotato per %d persone\n",pren.data,pren.cognome,pren.n_persone);
giorno[pren.data] = giorno[pren.data] + pren.n_persone;
// la data della prenotazione sarà l'indice dell'array giorno, ad ogni locazione avremo la somma
// delle persone prenotate per quel giorno
}
shmdt(shmPtr);
semop(semid,&sem_unlock,1);
}

for(i=1;i<SIZE;i++){ // rispetta i vincoli, ogni giorno possono prenotarsi
if(giorno[i]>50 && giorno[i]<250) // min 50 persone e max 250
printf("Per il giorno %d la prenotazione è stata accettata! :) \n", i);
else
printf("Per il giorno %d la prenotazione non è stata accettata!\n", i);

sleep(1);

semctl(semid,0,IPC_RMID,0);
shmctl(shmid,IPC_RMID,NULL);

if(( kill(pren.pid,SIGKILL) )==-1)
printf("Impossibile uccidere il processo client %d\n", pren.pid);
}
}
void alrm(int s) {
done=0;
}

CLIENT

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h> // utilizzate per i semafori e shm
#include <sys/ipc.h> // utilizzate per i semafori e shm
#include <sys/sem.h> // utilizzate per i semafori
#include <sys/shm.h> // utilizzata per la shm
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
# include <string.h>
#define SIZE 32 // l'array deve immagazinare dati per tutti i 31 giorni di agosto
// non usiamo la locazione 0
#define SHMSIZE 1000

int i, done, data, semid, shmid;

struct sembuf sem_lock={0,-1,0}; // lock del semaforo
struct sembuf sem_unlock={0,1,0}; // unlock del semaforo

struct prenotazione{
char cognome[20];
int data;
int n_persone;
int pid;
} pren; // variabile di tipo struct prenotazione

int *countPtr;
struct prenotazione *shmPtr; // puntatore di tipo struct prenotazione

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

key_t mykey1 = 1234; // chiave del semaforo
key_t mykey2 = 4321; // chiave della memoria

struct prenotazione pren;
struct prenotazione *shmPtr; // puntatore di tipo struct prenotazione
shmPtr = &pren; // facciamo puntare la variabile struttura a shmPtr

// ---- Inizio Riempimento struttura -----------------------------------------------------------------------------------

if(argc!=4){ // verifichiamo se gli argomenti passati da linea di comando sono 3
printf("Numero di argomenti errato!\n");
printf("Digitare: prenotazione cognome data n_persone\n");
}
for(i=1;i<argc;i++){ // il primo argomento argv[0] è prenotazione, il nome del software Client
strcpy(pren.cognome,argv[1]);
pren.data = atoi(argv[2]); // il terzo argomento è la data in cui si vuole prenotare la vacanza
pren.n_persone = atoi(argv[3]);//il quarto argomento è il numero di persone per il quale si vuole prenot
}

pren.pid=getpid(); // mettiamo nella struct il pid del client

// ---- Fine Riempimento struttura --------------------------------------------------------------------------------------

if(pren.n_persone>1){
semop(semid, &sem_lock, 1); // lockiamo 1 unità di risorsa
shmPtr=shmat(shmid,0,0); // lo 0 al 2° parametro, indica che attacca il segmento dove possibile
*countPtr++ ; // verra sommata alla locazione 0 della memoria +1, ciò per incrementare il contatore
*shmPtr = pren; // scriviamo la struttura al primo indirizzo disponibile
shmdt(shmPtr);
semop(semid,&sem_unlock,1);
}
else
printf("Possono partecipare solo nuclei familiari composti da almeno 2 persone\n");

while(1);
}

SuperNoa

01-09-2006, 10:47

Comunque dopo un pò di sbattimenti sono riuscito a trovare una soluzione funzionante, anche se ho dovuto semplificare il programma, togliendo le struct e considerando la memoria condivisa come un grande vettore ad int !
Comunque se qualcuno mi dà qualche suggerimento ad implementarla anche con le struct si potrebbe provare a farla, il dubbio che mi resta è sempre lo stesso, volendo utilizzare la prima cella di memoria come un contatore e quindi una locazione ad int si possono utilizzare le altre locazioni con altri tipi di dati, come ad esempio delle struct?
Perchè se utilizziamo un puntatore alla memoria questo potrà essere solo di un determinato tipo, quindi se lo dichiariamo ad interi
"int *shmPtr " per utilizzare la prima locazione come contatore, non possiamo utilizzarlo per passare delle struct, allora mi chiedevo si possono dichiarare più puntatori alla memoria? Quindi magari potremmo farne uno ad interi per usarlo come contatore e crearne un altro di tipo struct! Che mi dite?
Vi posto il programma funzionante senza struct, al quale mi riferivo sopra, magari a qualcuno può sempre far comodo!

SERVER

/*La compagnia aerea Sky Airline ha pensato di oﬀrire ai clienti dell’agenzia di viaggi Volare
di Napoli per il mese di agosto una oﬀerta eccezionale sull’unico volo giornaliero da Napoli a
Barcellona. Le condizioni dell’oﬀerta sono le seguenti:
• possono partecipare solo nuclei familiari composti da almeno 2 persone;
• l’oﬀerta sarà valida solo se per il giorno scelto ci sono almeno 50 e al più 250 prenotazioni;
• le prenotazioni devono avvenire solo il giorno 10 luglio dalle 11:00 alle 12:00, presso l’agenzia Volare;
• i clienti avranno conferma o meno immediatamente dopo le 12:00 del 10 luglio.
La compagnia aerea ha allora fornito alla agenzia Volare un software Server, di nome Offerta,
ed un software Client, di nome Prenotazione, tale che se la famiglia Rossi, composta da 4
persone, è interessata all’oﬀerta per il giorno 25 agosto, potrà digitare sul computer messo a disposizione dall’agenzia Prenotazione Rossi 25 4
Scrivere in linguaggio C il codice per il processo Server Offerta e per il generico processo client
Prenotazione: il processo Server deve controllare per ciascuno dei giorni del mese di agosto
che il numero di prenotazioni rientri nei limiti stabiliti. I client hanno 1 ora di tempo per
inserire. Il processo Server deve comunicare l’esito dell’oﬀerta per ciascuno dei giorni del mese
di agosto.
* Implementare il precedente scenario ipotizzando che la comunicazione da client
a server avvenga attraverso la memoria condivisa il cui accesso sia regolato da un semaforo.
Il server comunica l’esito dell’oﬀerta alla scadenza dell’ora scrivendolo sullo standard output: per
ciascuno dei giorni di agosto comunica solo se tutte le prenotazioni fatte sono accettate o no.*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h> // utilizzate per i semafori e shm
#include <sys/ipc.h> // utilizzate per i semafori e shm
#include <sys/sem.h> // utilizzate per i semafori
#include <sys/shm.h> // utilizzata per la shm
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
# include <string.h>
#define SHMSIZE 1000
#define SIZE 32 // l'array deve immagazinare dati per tutti i 31 giorni di agosto
// non usiamo la locazione 0

void alrm(int s);

int i, done, count, data, semid, shmid;

int *shmPtr; // puntatore alla memoria

//--------- MAIN --------------------------------------------------------------------------------------------------------

int main() {

count = 0;
done = 1;

key_t mykey1 = 1234; // chiave del semaforo
key_t mykey2 = 4321; // chiave della memoria

union semun{ // struttura utilizzata da semctl con SETVAL per settare il valore del semaforino

int val; // a 1, infatti alla variabile val sarà assegnato il valore 1

} arg;

arg.val=1;

// il valore sem_lock viene sottratto al valore del semaforino (valore del semaforino nella struttura sem)
struct sembuf sem_lock={0,-1,0}; // lock del semaforo di 1 risorsa sul primo semaforino
// il valore sem_unlock viene sommato al valore del semaforino (valore del semaforino nella struttura sem)
struct sembuf sem_unlock={0,1,0}; // unlock del semaforo

semid=semget(mykey1,1,IPC_CREAT|IPC_EXCL|0666); // creiamo il semaforo
semctl(semid,0,SETVAL,1); // settiamo il primo semaforino ad 1, la risorsa è presa da arg.val

shmid= shmget(mykey2, SHMSIZE, IPC_CREAT|0600); // creiamo la memoria condivisa
semop(semid, &sem_lock, 1); // lockiamo 1 unità di risorsa
shmPtr=shmat(shmid,0,0); // lo 0 al 2° parametro, indica che attacca il segmento dove possibile
shmPtr[0] = 0; // inizializiamo a 0 la prima cella di memoria, la useremo come contatore dei client
shmdt(shmPtr);
semop(semid,&sem_unlock,1);

signal(SIGALRM,alrm); // signal cattura SIGALARM e la lancia la funzione alrm
alarm(20); // il server resterà attivo per un ora 3600

while(done==1){

sleep(1);
} // contiamo i client che hanno scritto nella memoria
printf("Il tempo per l'inserimento è scaduto\n");

semop(semid, &sem_lock,1);
shmPtr=shmat(shmid,0,SHM_RDONLY);
count = shmPtr[0]; // in count il n° di client che hanno scritto in memoria (n° nella prima locazione della mem)
printf("Ci sono state %d richieste\n", count);
for(i=1;i<SIZE;i++){ // rispetta i vincoli, ogni giorno possono prenotarsi
if(shmPtr[i]>50 && shmPtr[i]<250) // min 50 persone e max 250
printf("Per il giorno %d la prenotazione è stata accettata! Si sono prenotate %d persone\n", i, shmPtr[i]);
else
printf("Per il giorno %d la prenotazione non è stata accettata! Si sono prenotate %d persone\n", i, shmPtr[i]);
}

shmdt(shmPtr);
semop(semid,&sem_unlock,1);

semctl(semid,0,IPC_RMID,0);
shmctl(shmid,IPC_RMID,NULL);

exit(0);
}
void alrm(int s) {
done=0;
}

CLIENT

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h> // utilizzate per i semafori e shm
#include <sys/ipc.h> // utilizzate per i semafori e shm
#include <sys/sem.h> // utilizzate per i semafori
#include <sys/shm.h> // utilizzata per la shm
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
# include <string.h>
#define SHMSIZE 1000
#define SIZE 32 // l'array deve immagazinare dati per tutti i 31 giorni di agosto
// non usiamo la locazione 0

int i, j, count, pid, semid, shmid;

struct sembuf sem_lock={0,-1,0}; // lock del semaforo
struct sembuf sem_unlock={0,1,0}; // unlock del semaforo

int *shmPtr; // puntatore alla memoria

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

key_t mykey1 = 1234; // chiave del semaforo
key_t mykey2 = 4321; // chiave della memoria

char cognome[20];
int data, n_persone;
// ---- Inizio Riempimento struttura -----------------------------------------------------------------------------------

if(argc!=4){ // verifichiamo se gli argomenti passati da linea di comando sono 3
printf("Numero di argomenti errato!\n");
printf("Digitare: prenotazione cognome data n_persone\n");
}
for(j=1;j<argc;j++){ // il primo argomento argv[0] è prenotazione, il nome del software Client
strcpy(cognome,argv[1]);
data = atoi(argv[2]); // il terzo argomento è la data in cui si vuole prenotare la vacanza
n_persone = atoi(argv[3]);//il quarto argomento è il numero di persone per il quale si vuole prenot
}

printf("In data %d agosto il signor %s ",data,cognome);
printf("ha prenotato per %d persone\n",n_persone);

// ---- Fine Riempimento struttura --------------------------------------------------------------------------------------

semid=semget(mykey1, 0, 0666); // ci agganciamo al semaforo
shmid=shmget(mykey2, 0, 0); // ci attacchiamo alla memoria condivisa

if(n_persone>1){

semop(semid, &sem_lock,1); // lockiamo 1 unità di risorsa
shmPtr=shmat(shmid,0,0); // lo 0 al 2° parametro,indica che attacca il segmento dove possibile
shmPtr[0] = shmPtr[0]+1; // incrementiamo il contatore della prima locazione //*shmPtr= *shmPtr+1;
count = shmPtr[0];
shmPtr[data] = shmPtr[data] + n_persone; // aggiorniamo per ogni data il numero di persone che vogliono prenotarsi
//printf("Hanno scritto in memoria %d client\n", count);
shmdt(shmPtr);
semop(semid,&sem_unlock,1);
}
else
printf("Possono partecipare solo nuclei familiari composti da almeno 2 persone\n");

exit(0);
}