How to share existing memory?

Question

I wanted to write some function void* share(void*, int) that should set up shared memory to share the data at the pointer.

My first attempt looked like (without checks etc.):

void* share(void *toBeShared, int size) {
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR);
    ftruncate(fd, size);
    return mmap(toBeShared, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
}

but this does not seem to work as I would like it. The second attempt was something like:

void* share(void *toBeShared, int size) {
    void *mem = NULL;
    int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR);
    ftruncate(fd, size);
    mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
    memcpy(mem, toBeShared, size);
    return mem;
}

and this does work, but I need to copy the entire data, which I would like to avoid.

Therefore my question: is there a way to share memory that has already been allocated (if possible without having to copy too much around) and if yes, how could it be done?

Thanks in advance.

PS: I've seen more of these questions (e.g. here and here), but there are no answers given in there.

---

edit:

how I would like to use it:

typedef struct {
    char *name;
    int status;
} MyTask;

int main(int argc, char** argv) {
    MyTask* taskList = NULL, sharedTaskList = NULL;
    int length = 0;
    ...
    readFile(&taskList, &length, ...);
    sharedTaskList = share(taskList, length * sizeof(MyTask));
    // or maybe even better: without needing to assign it to new variable
    for(i = 0; i < NR_WORKERS; i++) {
        switch(pid = fork()) {
            //etc...
        }
    }
    ...
    return 0;
}

Answer 1

How to share existing memory?

Don't share existing memory. Get some (small amount of) "fresh" shared memory and use (i.e. fill or read) it later.

Assuming you are on Linux, read shm_overview(7).

I guess that some of your functions might fail. You should test against failure each call, e.g.

int fd = shm_open(SHM_NAME, O_CREAT | O_RDWR | O_EXCL, S_IRUSR | S_IWUSR);
if (fd<0) {perror("shm_open"); exit(EXIT_FAILURE);};

and so on. Perhaps use also strace(1)

is there a way to share memory that has already been allocated

Short answer, no! (or not easily, and not in a portable way). You conventionally do the opposite: obtain some shared segment of known size, and use some pointers into it. (the same shared segment might have different virtual addresses in different processes, e.g. because of ASLR).

You could use mmap(2) with MAP_FIXED on some already used virtual address space subsegment (that would overwrite & replace the mapping with a new one, not share an existing mapping!), but I would suggest to avoid that. Notice that the virtual address space is managed in multiples of pages, so there is no way to share some data which is not page aligned. So your share function is impossible unless both toBeShared and size are page-aligned. You could consider the Linux specific mremap(2)

In other words, your applications should first allocate some shared memory and then put/use some data inside the obtained shared segment, not try to share some existing unshared virtual memory range. So you probably want to code some void* get_my_shared_memory(); (assuming the size is a compile time constant, and you call that function once per process, and its resulting virtual address would often vary from one process to another)

In practice, memory is a finite resource, and shared memory is a scarce and very limited resource. On most systems, you'll be able to share a few dozens of megabytes only... So sharing an arbitrary large amount of memory is unreasonable.

^{Perhaps your entire application might just use some server, e.g. some database server à la PostGreSQL, to share information, by making requests to that server (and using ACID properties of DBMS). Or you could organize it as a monitoring process exchanging messages (e.g. URL to be processed) -on pipes or sockets or fifos- with slave processes. But we don't know what kind of application are you coding.}

BTW, sharing memory is not enough. You need to synchronize your processes.