#include <sys/types.h>   /* For portability */
#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

/* Returns: shared memory segment identifier on success, or -1 on error */

The key identifies the segment — it’s how unrelated processes agree to use the same segment. There are two ways to set it:

/* Method 1: IPC_PRIVATE — for parent-child sharing */
shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0600);

/* Method 2: ftok() — for unrelated processes */
key_t key = ftok("/tmp/myapp.lock", 'A');
if (key == -1) { perror("ftok"); exit(1); }

/* Creator: */
shmid = shmget(key, 4096, IPC_CREAT | IPC_EXCL | 0600);

/* Other process (already knows the path): */
shmid = shmget(key, 4096, 0);   /* no IPC_CREAT — just open */

The kernel allocates shared memory in multiples of the system page size (typically 4096 bytes on x86). Your requested size is silently rounded up to the next page boundary. This matters for sizing your structs.

#include <unistd.h>   /* sysconf() */

/* How to query the system page size at runtime */
long page_size = sysconf(_SC_PAGESIZE);
printf("Page size: %ld bytes\n", page_size);   /* typically 4096 */

/* Round your desired size up to a page boundary */
size_t desired   = 3000;
size_t allocated = ((desired + page_size - 1) / page_size) * page_size;
printf("Will allocate: %zu bytes\n", allocated);  /* 4096 */

A realistic pattern showing how two unrelated processes share a segment using ftok(). Both programs must be run from the same directory so ftok() produces identical keys.

/* shm_server.c — creates the segment and writes data */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE   1024
#define KEY_PATH   "/tmp"
#define KEY_ID     'S'

int main(void)
{
    key_t  key;
    int    shmid;
    char  *shm;

    /* Generate a key from a path + project byte */
    key = ftok(KEY_PATH, KEY_ID);
    if (key == -1) { perror("ftok"); exit(1); }

    /* Create the segment (exclusive — fail if already exists) */
    shmid = shmget(key, SHM_SIZE, IPC_CREAT | IPC_EXCL | 0600);
    if (shmid == -1) { perror("shmget"); exit(1); }
    printf("[server] shmid=%d, key=0x%x\n", shmid, key);

    /* Attach */
    shm = shmat(shmid, NULL, 0);
    if (shm == (void *)-1) { perror("shmat"); exit(1); }

    /* Write data */
    snprintf(shm, SHM_SIZE, "Hello from server! PID=%d", getpid());
    printf("[server] wrote: %s\n", shm);
    printf("[server] press Enter to delete segment...\n");
    getchar();

    /* Detach and delete */
    shmdt(shm);
    shmctl(shmid, IPC_RMID, NULL);
    printf("[server] segment deleted\n");
    return 0;
}

/* shm_client.c — opens existing segment and reads data */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define SHM_SIZE   1024
#define KEY_PATH   "/tmp"
#define KEY_ID     'S'

int main(void)
{
    key_t  key;
    int    shmid;
    char  *shm;

    /* Same ftok() args as server = same key */
    key = ftok(KEY_PATH, KEY_ID);
    if (key == -1) { perror("ftok"); exit(1); }

    /* Open existing segment (no IPC_CREAT) */
    shmid = shmget(key, 0, 0);
    if (shmid == -1) { perror("shmget"); exit(1); }

    /* Attach read-only (SHM_RDONLY) */
    shm = shmat(shmid, NULL, SHM_RDONLY);
    if (shm == (void *)-1) { perror("shmat"); exit(1); }

    printf("[client] read: %s\n", shm);

    shmdt(shm);
    return 0;
}

Compile and test:

gcc -o shm_server shm_server.c
gcc -o shm_client shm_client.c

# Terminal 1:
./shm_server

# Terminal 2 (while server is waiting):
./shm_client

Modern x86 CPUs have a Translation Lookaside Buffer (TLB) — a small hardware cache that maps virtual page numbers to physical frame numbers. If your application allocates gigabytes of memory, the TLB fills up and causes frequent TLB misses, which are expensive.

Huge pages (2 MB or 1 GB instead of the usual 4 KB) let one TLB entry cover far more memory. The SHM_HUGETLB flag requests that the segment be backed by huge pages. Requires CAP_IPC_LOCK privilege and huge page pool pre-allocation.

/* SHM_HUGETLB example (requires root or CAP_IPC_LOCK) */
#include <sys/shm.h>

#define HUGE_SIZE  (2 * 1024 * 1024)  /* 2 MB — one huge page */

int shmid = shmget(IPC_PRIVATE, HUGE_SIZE,
                   IPC_CREAT | SHM_HUGETLB | 0600);
if (shmid == -1) {
    perror("shmget with SHM_HUGETLB");
    /* May fail if no huge pages configured: check /proc/sys/vm/nr_hugepages */
}

# Check/set huge page pool (as root):
cat /proc/sys/vm/nr_hugepages
echo 64 > /proc/sys/vm/nr_hugepages   # allocate 64 huge pages = 128 MB

System V IPC objects persist until explicitly deleted. Use the ipcs command to list them and ipcrm to delete stale segments.

# List all shared memory segments:
ipcs -m

# Sample output:
# ------ Shared Memory Segments --------
# key        shmid      owner      perms      bytes      nattch     status
# 0x00000000 131072     ravi       600        4096       0

# Delete a segment by ID:
ipcrm -m 131072

# Delete by key:
ipcrm -M 0x53455250

# Delete all shared memory (dangerous!):
ipcs -m | awk 'NR>3 { print $2 }' | xargs ipcrm -m 2>/dev/null

Important: If your program crashes before calling shmctl(IPC_RMID), the segment remains in the system. Always check with ipcs -m during development to avoid resource leaks.

/* Always clean up — even on error paths */
#include <signal.h>
#include <sys/shm.h>

static int g_shmid = -1;

void cleanup_handler(int sig)
{
    if (g_shmid != -1)
        shmctl(g_shmid, IPC_RMID, NULL);
    _exit(0);
}

int main(void)
{
    signal(SIGINT,  cleanup_handler);
    signal(SIGTERM, cleanup_handler);

    g_shmid = shmget(IPC_PRIVATE, 4096, IPC_CREAT | 0600);
    /* ... rest of program ... */
    return 0;
}

The kernel enforces several limits. You can read and adjust them via /proc.

# Key limits (read current values):
cat /proc/sys/kernel/shmmax    # max size of single segment (bytes)
cat /proc/sys/kernel/shmall    # total pages of shared memory system-wide
cat /proc/sys/kernel/shmmni    # max number of segments system-wide
cat /proc/sys/kernel/shmmin    # min size (usually 1)

# Typical values on a modern Linux:
# shmmax: 18446744073692774399  (~unlimited on 64-bit)
# shmmni: 4096
# shmall: 18446744073692774399

/* Query limits programmatically with shmctl(IPC_INFO) */
#include <sys/shm.h>

struct shminfo info;
if (shmctl(0, IPC_INFO, (struct shmid_ds *) &info) == -1) {
    perror("shmctl IPC_INFO");
} else {
    printf("shmmax = %lu\n", info.shmmax);
    printf("shmmin = %lu\n", info.shmmin);
    printf("shmmni = %lu\n", info.shmmni);
    printf("shmall = %lu\n", info.shmall);
}