How to share ck_list across processes? - c

Question

I'm trying to use CK_LIST from http://concurrencykit.org/ across multiple processes but when I do, the values inside the list nodes are garbage. But the list values are correct when I use the list only from one process.
Here is an example of using CK_LIST in a struct with in a single process.
#include <stdio.h>
#include <stdlib.h>
#include <ck_queue.h>
struct shared_map
{
CK_LIST_HEAD(list, list_node) list;
};
struct list_node
{
void *data;
CK_LIST_ENTRY(list_node) list_entry;
};
int main(void)
{
struct list_node *node, *node2;
struct shared_map mapping = { .list = CK_LIST_HEAD_INITIALIZER(mapping->list) };
struct shared_map *map = &mapping;
node = malloc(sizeof(struct list_node));
if(node == NULL)
{
perror("malloc");
return -1;
}
CK_LIST_INIT(&map->list);
int rtrn = asprintf((char **)&node->data, "test");
if(rtrn < 0)
{
perror("asprintf");
return -1;
}
CK_LIST_INSERT_HEAD(&map->list, node, list_entry);
CK_LIST_FOREACH(node2, &map->list, list_entry)
{
printf("out: %s\n", node2->data);
}
return 0;
}
But when I try to use the list between two separate processes the value of node->data is garbage and causes the process using it to crash. Below is an example.
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <ck_queue.h>
struct shared_map
{
CK_LIST_HEAD(list, list_node) list;
};
struct list_node
{
void *data;
CK_LIST_ENTRY(list_node) list_entry;
};
static int create_shared(void **pointer, int size)
{
*pointer = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
if(*pointer == MAP_FAILED)
{
perror("mmap:");
return -1;
}
return 0;
}
int main(void)
{
struct list_node *node, *node2;
struct shared_map mapping = { .list = CK_LIST_HEAD_INITIALIZER(mapping->list) };
struct shared_map *map = &mapping;
int rtrn = create_shared((void **)&map, sizeof(struct shared_map));
if(rtrn < 0)
{
printf("Can't create shared mapping\n");
return -1;
}
CK_LIST_INIT(&map->list);
pid_t pid;
pid = fork();
if(pid == 0)
{
/* Child. */
node = malloc(sizeof(struct list_node));
if(node == NULL)
{
perror("malloc");
return -1;
}
int rtrn = asprintf((char **)&node->data, "test");
if(rtrn < 0)
{
perror("asprintf");
return -1;
}
CK_LIST_INSERT_HEAD(&map->list, node, list_entry);
}
else if(pid > 0)
{
/* Parent. */
sleep(1); // Make sure child runs first.
CK_LIST_FOREACH(node2, &map->list, list_entry)
{
printf("out: %s\n", node2->data);
}
}
else
{
perror("fork");
return -1;
}
return 0;
}
CK_LIST is listed as a multi-reader single-writer linked list so I thought I only had to lock on writes not reads. So why does node->data become garbage when using it between processes as opposed to when used by a single process?

Answer 1

Fortunately, this has nothing to do with CK and just to do with where your memory is coming from.
Your allocation in the child comes from malloc and lives in the child's address space. The child and parent do not share the same address space (being separate processes), so your malloc(3)-obtained storage for the node and data are not at addresses within the parent's address space.
You need to allocate the memory for the node and node->data from some shared space as well. I made a minimal set of changes to the code to get it to work for demonstration purposes. Hopefully obviously, you'd want your API to be less fragile in terms of magic numbers to mmap.
#include <sys/mman.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <ck_queue.h>
struct shared_map {
CK_LIST_HEAD(list, list_node) list;
};
struct list_node {
void *data;
CK_LIST_ENTRY(list_node) list_entry;
};
static int
create_shared(void **pointer, int size)
{
*pointer = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
if (*pointer == MAP_FAILED) {
perror("mmap:");
return -1;
}
return 0;
}
int
main(void)
{
struct list_node *node, *node2;
struct shared_map mapping = { .list = CK_LIST_HEAD_INITIALIZER(mapping->list) };
struct shared_map *map = &mapping;
int rtrn = create_shared((void **)&map, sizeof(struct shared_map) + sizeof(struct list_node) + 5);
if (rtrn < 0) {
printf("Can't create shared mapping\n");
return -1;
}
CK_LIST_INIT(&map->list);
pid_t pid;
pid = fork();
if (pid == 0) {
/* Child. */
node = (struct list_node *)(map + 1);
node->data = node + 1;
memcpy(node->data, "test", 5);
CK_LIST_INSERT_HEAD(&map->list, node, list_entry);
} else if (pid > 0) {
/* Parent. */
sleep(1); // Make sure child runs first.
CK_LIST_FOREACH(node2, &map->list, list_entry) {
printf("out: %s\n", (char *)node2->data);
}
} else {
perror("fork");
return -1;
}
return 0;
}
Fundamentally, I just changed the size of the mmap to include space for the list_node and the C string attached to node->data and made the child set that up.