ring_logger_shm.c

#define _POSIX_C_SOURCE 200809L
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <stdatomic.h>
#include <stdint.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <string.h>

#define SLOT_MSG 64
#define SLOTS 64

typedef struct {
    atomic_uint_fast64_t seq;
    char msg[SLOT_MSG];
} slot_t;

typedef struct {
    slot_t slots[SLOTS];
} ring_t;

static ring_t *ring_create(const char *name)
{
    int fd = shm_open(name, O_CREAT | O_RDWR, 0600);
    if (fd < 0) return NULL;
    if (ftruncate(fd, sizeof(ring_t)) < 0) {
        close(fd);
        return NULL;
    }
    void *p = mmap(NULL, sizeof(ring_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);
    if (p == MAP_FAILED) return NULL;
    ring_t *r = p;
    for (int i = 0; i < SLOTS; i++) {
        atomic_store_explicit(&r->slots[i].seq, 0, memory_order_relaxed);
        r->slots[i].msg[0] = 0;
    }
    return r;
}

static ring_t *ring_open(const char *name)
{
    int fd = shm_open(name, O_RDWR, 0);
    if (fd < 0) return NULL;
    void *p = mmap(NULL, sizeof(ring_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);
    if (p == MAP_FAILED) return NULL;
    return p;
}

static void ring_log(ring_t *r, uint64_t seq, const char *msg)
{
    size_t idx = seq % SLOTS;
    slot_t *s = &r->slots[idx];
    atomic_store_explicit(&s->seq, seq, memory_order_release);
    snprintf(s->msg, SLOT_MSG, "%s", msg);
}

static void writer_proc(const char *name)
{
    ring_t *r = ring_open(name);
    if (!r) _exit(1);
    for (uint64_t i = 1; i <= 100; i++) {
        char buf[64];
        snprintf(buf, sizeof buf, "log-%llu", (unsigned long long)i);
        ring_log(r, i, buf);
        usleep(10000);
    }
    _exit(0);
}

static void reader_proc(const char *name)
{
    ring_t *r = ring_open(name);
    if (!r) _exit(1);
    uint64_t last = 0;
    for (;;) {
        int seen = 0;
        for (int i = 0; i < SLOTS; i++) {
            uint64_t seq = atomic_load_explicit(&r->slots[i].seq, memory_order_acquire);
            if (seq > last) {
                printf("seq=%llu msg=%s\n", (unsigned long long)seq, r->slots[i].msg);
                if (seq > last) last = seq;
                seen = 1;
            }
        }
        if (!seen && last >= 100) break;
        usleep(20000);
    }
    _exit(0);
}

int main(void)
{
    const char *name = "/ring_logger_example";
    shm_unlink(name);
    ring_t *r = ring_create(name);
    if (!r) return 1;
    pid_t w = fork();
    if (w == 0) writer_proc(name);
    pid_t rpid = fork();
    if (rpid == 0) reader_proc(name);
    waitpid(w, NULL, 0);
    waitpid(rpid, NULL, 0);
    shm_unlink(name);
    return 0;
}