[C] copiare aree di memoria

[Pompolus]

Salve a tutti,

per un programma che simuli la gestione dell'allocazione della memoria, devo copiare un'area di memoria in un'altra area di memoria.

In pratica ho un'applicazione SERVER in ascolto...
Un'applicazione CLIENT alloca una determinata area di memoria, ci scrive dentro qualcosa, poi chiama una funzione del server passandogli il (void *) all'area di memoria allocata.

A questo punto il SERVER dovrà andare a leggere nell'area di memoria suddetta e copiare byte per byte i dati in un'altra area di memoria.


per fare ciò uso la funzione memcpy, il problema è che sembra che il SERVER non riesca ad accedere all'area di memoria allocata dal CLIENT, riesco ad ottenere il giusto indirizzo tramite FIFO, ma quando si tratta di accedervi sembra impossibile, infatti la memcpy non fa un bel niente...

E' possibile accedere da un processo ad un'area di memoria allocato da un altro processo? Un modo deve esserci ma non so quale.
Se può essere utile sto lavorando sotto linux.

Qualcuno sa aiutarmi? :(

[cionci]

Sono processi distinti, il loro indirizzamento è diverso, è normale che non ti funzioni.
http://www.cact.unile.it/facilities/XC6000/html-man/gapil/gapilsu190.html

[fero86]

E' possibile accedere da un processo ad un'area di memoria allocato da un altro processo? pensa un po' alle conseguenze se questo si potesse fare: la memoria allocata da un certo processo potrebbe contenere dati sensibili, come password o numeri di carte di credito oppure informazioni la cui corruzione potrebbe causare il malfunzionamento del sistema, e non sarebbe positivo se qualunque processo (virus compresi) potesse accedervi. una volta (20 anni fa, ai tempi del DOS) in effetti si poteva fare, poi visto che non andava affatto bene l'uomo ha introdotto svariati meccanismi di protezione. oggi... si puó ancora fare :D ma non in tutti i sistemi operativi e non in maniera diretta, e comunque sotto la supervisione di un opportuno sistema di sicurezza che consenta solo determinati accessi. di certo non lo fai con memcpy, ne' dereferenziando puntatori; in particolare quest'ultima cosa non ha neanche piu senso perché oggi a ciascun processo viene assegnato uno spazio di indirizzamento virtuale (ciascun processo ha i suoi 4 GB virtuali) e tutti i puntatori che esso puó generare si riferiscono per definizione al suo spazio di indirizzamento, non c'é modo di riferirsi con un puntatore allo spazio di indirizzamento di un altro processo.


Un modo deve esserci ma non so quale. devi copiare i dati manualmente sulla FIFO.

[Pompolus]

pensa un po' alle conseguenze se questo si potesse fare: la memoria allocata da un certo processo potrebbe contenere dati sensibili, come password o numeri di carte di credito oppure informazioni la cui corruzione potrebbe causare il malfunzionamento del sistema, e non sarebbe positivo se qualunque processo (virus compresi) potesse accedervi. una volta (20 anni fa, ai tempi del DOS) in effetti si poteva fare, poi visto che non andava affatto bene l'uomo ha introdotto svariati meccanismi di protezione. oggi... si puó ancora fare :D ma non in tutti i sistemi operativi e non in maniera diretta, e comunque sotto la supervisione di un opportuno sistema di sicurezza che consenta solo determinati accessi. di certo non lo fai con memcpy, ne' dereferenziando puntatori; in particolare quest'ultima cosa non ha neanche piu senso perché oggi a ciascun processo viene assegnato uno spazio di indirizzamento virtuale (ciascun processo ha i suoi 4 GB virtuali) e tutti i puntatori che esso puó generare si riferiscono per definizione al suo spazio di indirizzamento, non c'é modo di riferirsi con un puntatore allo spazio di indirizzamento di un altro processo.


devi copiare i dati manualmente sulla FIFO.

Ciao, grazie della risposta.

Allora ho rifatto il tutto e ora mando i dati tramite FIFO, però ho un problema.

Dopo che il SERVER legge la FIFO, le memcpy non funziona più, sembra rimanere in stallo. Tutti i dati dentro le fifo vengono letti correttamente, ma la funzione memcpy dopo non funziona proprio più, anche usando dati che non sono stati passati tramite FIFO, non capisco perchè!

faccio un esempio, questa è la parte del server:



//////////////////////faccio una memcpy prima della READ/////////////////////////////////////////////
char s1[30] = "ciao a tutti";
char s2[30];
char s3[30];

void * buffer;
int n_byte;
int buffer_dim = 30;

memcpy(s2, s1, 30);

if ((n_byte = read(FIFO_to_read, buffer, buffer_dim) )== -1)
perror(" Errore nella lettura della fifo");
else
printf(" nella fifo sono stati letti %d byte e in buffer c'è %s\n", n_byte, buffer);


////////////////faccio una memcpy dopo la READ///////////////////////////////////////////
memcpy(s3, s1, 30);




questa è la parte del CLIENT:




char stringa[30] ="sono la stringa da inviare";
int size = 30;
void *buffer = stringa;

n_byte = write(FIFO_to_write, buffer, size);

if (n_byte == -1)
perror(" Error while writing FIFO");
else
printf("nella fifo sono stati scritti %d byte \n",n_byte);



tutte le memcpy prima della read vengono effettuate normalmente, ma dopo la read la memcpy non va più il programma si blocca sulla sua istruzione.

La cosa strana è che prima faccio altre READ tramite FIFO, ma c'è una READ in particolare dopo la quale la memcpy non funziona più, eppure i dati dalla fifo vengono letti normalmente, se provo a stamparli ci sono e sono giusti.


Quel che sembra che gli dia fastidio è che dalla parte del client invio la stringa, il server la riceve correttamente ma dopodichè si blocca la memcpy, se invece invio l'indirizzo della stringa, il server riesce poi afare le varie memcpy, ma ovviamente poi non può accedere alla stringa perchè è stata dichiarata dall'altra applicazione.

COME DIAVOLO NE ESCO!?!?! :(

Se non sono stato chiaro fate pure domande che qui sto nella m... ehm pupù fino al collo!


Vi ringrazio per l'aiuto

[cionci]

Guarda il link che ti ho dato sopra ;)

[Pompolus]

Guarda il link che ti ho dato sopra ;)

purtroppo non posso usare la memoria condivisa ma devo utilizzare le FIFO per forza di cose. : \

[DanieleC88]

:eekk:

Laboratorio di sistemi operativi 1? Non è difficile dai, in bocca al lupo! :asd:

[Pompolus]

:eekk:

Laboratorio di sistemi operativi 1? Non è difficile dai, in bocca al lupo! :asd:

crepi, ma se non è difficile, dove sta il problema? : \

[DanieleC88]

Conta che solo un processo può scrivere nella sua memoria, quindi avendo server e client separati non devi far scrivere al primo nella memoria del secondo, devi farli "comunicare" e trasferire così i dati che ti servono. Poi sarà l'applicazione interessata (server o client a seconda del tipo di trasferimento che fai) a scrivere i dati nella zona che ti serve. Consiglio: pensa alla libreria e a dove va a finire, poi c'è bisogno solo di "incollare i pezzi". ;)

P.S.: sicuro che sia la memcpy() a bloccarsi? I casi sono due: o si blocca sulla FIFO o ti si termina il server per segmentation fault (il che è probabilissimo visto che fai memcpy() dove magari non potresti, se ho capito bene).

[DanieleC88]

Altro consiglio: usa un debugger. Lancia il server, recuperane il PID, poi lancia gdb e dagli come comando "attach <PIDserver>" e "continue", almeno sarai sicuro nel caso si verifichi un segmentation fault. :)

Buon lavoro! ;)

[Pompolus]

no, era proprio la memcpy a bloccarsi per cause ancora sconosciute, comunque ho risolto evitando proprio di usarlo e facendo scrivere direttamente alla FIFO nell'indirizzo di memoria desiderato...

Resta ancora un mistero perchè sta memcpy non funzionava, mah : \

[Tommo]

Sei sicuro che le due applicazioni girassero nello stesso thread?

Perchè, se l'esecuzione delle 2 è asincrona, è possibile che il server si accorga che la memoria è stata scritta dalla FIFO, ma tenta di copiarla quando la scrittura non è ancora terminata, appunto crashando.

Prova a fargli "perdere tempo" tra la read e il memcpy...:stordita:

[DanieleC88]

Non credo sia quello il problema, la read() e la write() sono bloccanti, il server legge solo quando il client ha scritto, il client legge solo quando il server ha scritto... Non ho capito come viene effettuata questa memcpy() e in che modo "blocchi" il tutto, non mi sembra possibile, onestamente. :D

[Tommo]

Bho mi sembrava una cosa possibile :asd:
Cmq è strano, in effetti il memcpy che viene chiamato dopo read(), e crasha, non coinvolge nessuno dei parametri del read stesso... per cui la memoria viene scombinata in qualche modo.

[DanieleC88]

La cosa che mi sembra più probabile è che un segmentation fault mandi in crash una delle due applicazioni (client o server) e che l'altra cerchi di leggere una FIFO che resta sempre vuota perché non ha più chi vi fornisca dei dati. :)