The name argument identifies the shared memory object. POSIX.1 defines portable naming rules that you should always follow:

The oflag argument is a bitmask that controls two things: (a) whether you are creating a new object or opening an existing one, and (b) the access mode. You must specify exactly one access mode flag.

The mode argument specifies the file permission bits when creating a new object. It is exactly the same as the mode bits used for regular files (see stat(2)).

If you are not creating a new object (i.e., O_CREAT is absent from oflag), you should pass 0 for mode — it is ignored in that case.

/* Common permission values for shm_open() */

fd = shm_open("/myshm", O_CREAT | O_RDWR, 0600);
/*                                          ^^^^
 *  0600 = owner read + write
 *  0660 = owner + group read + write
 *  0644 = owner read+write, others read-only
 *
 * The actual permissions are further masked by the
 * process's umask, just like open().
 */

/* Opening an existing object (no creation) */
fd = shm_open("/myshm", O_RDONLY, 0);
/*                                ^ pass 0 when not creating */

The file descriptor returned by shm_open() always has the FD_CLOEXEC flag set automatically. This means:

This example shows two processes: a creator (uses O_CREAT | O_EXCL) and a consumer (opens existing object with O_RDONLY).

/*
 * shm_creator.c — Creates a shared memory object exclusively
 * Compile: gcc shm_creator.c -o shm_creator -lrt
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>

#define SHM_NAME  "/ep_channel"
#define SHM_SIZE  1024

int main(void)
{
    int fd;
    char *addr;

    /*
     * O_CREAT | O_EXCL | O_RDWR:
     *   - Create the object (O_CREAT)
     *   - Fail if already exists (O_EXCL) — we want to be the only creator
     *   - Open for read-write (O_RDWR)
     * 0660: owner and group can read/write
     */
    fd = shm_open(SHM_NAME, O_CREAT | O_EXCL | O_RDWR, 0660);
    if (fd == -1) {
        if (errno == EEXIST) {
            fprintf(stderr,
                "Shared memory '%s' already exists. "
                "Run: shm_unlink %s or rm /dev/shm%s\n",
                SHM_NAME, SHM_NAME, SHM_NAME);
        } else {
            perror("shm_open");
        }
        exit(EXIT_FAILURE);
    }

    printf("[Creator] shm_open() OK. fd=%d\n", fd);

    /* Set the size before any mmap() */
    if (ftruncate(fd, SHM_SIZE) == -1) {
        perror("ftruncate");
        shm_unlink(SHM_NAME);
        exit(EXIT_FAILURE);
    }

    /* Map it */
    addr = mmap(NULL, SHM_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        shm_unlink(SHM_NAME);
        exit(EXIT_FAILURE);
    }
    close(fd);  /* fd not needed after mmap */

    /* Write a message */
    snprintf(addr, SHM_SIZE, "Message from creator: pid=%d", (int)getpid());
    printf("[Creator] Wrote: %s\n", addr);
    printf("[Creator] Run shm_reader now. Press Enter to cleanup...\n");
    getchar();

    munmap(addr, SHM_SIZE);
    shm_unlink(SHM_NAME);
    printf("[Creator] Cleaned up.\n");
    return 0;
}

/*
 * shm_reader.c — Opens an existing shared memory object read-only
 * Compile: gcc shm_reader.c -o shm_reader -lrt
 * Run AFTER shm_creator is running.
 */

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

#define SHM_NAME  "/ep_channel"
#define SHM_SIZE  1024

int main(void)
{
    int fd;
    char *addr;

    /*
     * O_RDONLY: open existing object for reading only
     * mode = 0: not creating, so mode is ignored
     */
    fd = shm_open(SHM_NAME, O_RDONLY, 0);
    if (fd == -1) {
        perror("shm_open");
        exit(EXIT_FAILURE);
    }
    printf("[Reader] shm_open() OK. fd=%d\n", fd);

    /* Map read-only: PROT_READ only (matching O_RDONLY) */
    addr = mmap(NULL, SHM_SIZE, PROT_READ, MAP_SHARED, fd, 0);
    if (addr == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }
    close(fd);

    printf("[Reader] Read: %s\n", addr);

    munmap(addr, SHM_SIZE);
    return 0;
}

# Terminal 1
gcc shm_creator.c -o shm_creator -lrt
./shm_creator

# Terminal 2 (while creator is waiting)
gcc shm_reader.c -o shm_reader -lrt
./shm_reader
# Press Enter in Terminal 1 to cleanup

Specifying O_TRUNC when opening an existing shared memory object truncates it to zero length immediately. This destroys any existing data.

/* O_TRUNC: opens the existing object and resets its size to 0 */
fd = shm_open("/myshm", O_RDWR | O_TRUNC, 0);
/*
 * After this call:
 *   - The object exists but has size 0
 *   - Any processes that had it mapped still have their mapping
 *     but the backing region was shrunk — accessing beyond the
 *     new end results in SIGBUS
 *   - You must call ftruncate() again to restore a usable size
 *
 * Linux note: O_TRUNC works even with O_RDONLY (read-only open),
 * but this is undefined behavior per POSIX — avoid it.
 */