Hello,


I am trying to create a program that access a shared memory area but doesnt know its size. At the beginning of the area, there is a variable(int) that contains the full area size. So I am trying to map enough space to read the total size, and remap the whole area. I am using POSIX (realtime) shared memort functions: shm_open(), ftruncate(), mmap(), munmap(), shm_unlink().
The problem is that if I truncate a small area (enough to read the full size), and than truncate the file descriptor again with its new size, the previous content of the shared memory area gets overwritten with 0.
I could truncate a bigger area than the shared memory possibly could be (limiting the maximum size of it), read the size, and than truncate (with a smaller size this time). It works, but I dont think this is an elegant solution since I am maping a big memmory area, just to read few bytes and than unmaped it.

Follow a simplified version of the code to express what I intent to do. I am using the solution I mentioned above (using a bigger area):

int shm_id;
char *memory;
int full_size;

shm_id=shm_open(name, O_RDWR , 0777);
if(shm_id==-1)
{
….
}
ftruncate(shm_id,MAX_SIZE);
memory=(char *)mmap(NULL,MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, shm_id, 0);

full_size=*(int*)&memory[0];
munmap(shm_id, MAX_SIZE);

ftruncate(shm_id, full_size);
memory=(char *)mmap(NULL,full_size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_id, 0);


Has anyone tried to do something similar? Any suggestions? I also tried closing the shared memory descriptor and opening again. But also didnt work. I am running under OpenSuse 13.2.
Thank you guys,
Dante

ftruncate should be called only once, after the very first creation of share memory

So,do I only need to truncate on the process where I create the shared memory? And not on processes where I access an already existing one?

Thank you for the quick response NevemTeve!

That means you have to know if it was a first creation or not.

It is solved, I did some studying and I believe I understood the concept.
Thankou again NevemTeve.

Your logic should be as follows:

(1) Attempt to open the shared-memory segment by name.
(2) If (RC == -1) the segment does not exist, then you are the first: create it, then "ftruncate()" it to its maximum size.
(3) In any case, map the memory, or some appropriately-sized "window" thereunto, into each process.

1 members found this post helpful.

That, and some synchronization to avoid race conditions: