Lifecycle of a Named Semaphore

sem_open() — Create or Open a Named Semaphore

#include <fcntl.h>      /* Defines O_* constants */
#include <sys/stat.h>   /* Defines mode constants */
#include <semaphore.h>

sem_t *sem_open(const char *name, int oflag, ...
                /* mode_t mode, unsigned int value */ );

/* Returns: pointer to semaphore on success, SEM_FAILED on error */

Arguments Explained

oflag Combinations

Example 1: Open an Existing Semaphore

#include <semaphore.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    sem_t *sem;

    /* Open existing semaphore - no mode/value needed */
    sem = sem_open("/shared_counter", 0);
    if (sem == SEM_FAILED) {
        perror("sem_open");   /* ENOENT if it doesn't exist */
        exit(EXIT_FAILURE);
    }

    printf("Opened existing semaphore\n");

    sem_close(sem);
    return 0;
}

Example 2: Create a New Semaphore (Exclusive)

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

int main(void)
{
    sem_t *sem;

    /*
     * O_CREAT | O_EXCL: create only if it doesn't exist.
     * Permissions: 0660 (owner+group: read+write)
     * Initial value: 1 (binary semaphore - like a mutex)
     */
    sem = sem_open("/my_mutex", O_CREAT | O_EXCL, 0660, 1);
    if (sem == SEM_FAILED) {
        perror("sem_open");   /* EEXIST if already exists */
        exit(EXIT_FAILURE);
    }

    printf("Created semaphore. Check: ls /dev/shm/sem.*\n");

    sem_close(sem);
    sem_unlink("/my_mutex");   /* Remove from system */
    return 0;
}

Example 3: Create or Open (Common Pattern)

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

int main(void)
{
    sem_t *sem;

    /*
     * O_CREAT only (no O_EXCL):
     * - Creates with value=3 if it doesn't exist
     * - Opens the existing one if it does (value/mode ignored)
     */
    sem = sem_open("/resource_pool", O_CREAT, 0660, 3);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        exit(EXIT_FAILURE);
    }

    printf("Semaphore ready with up to 3 resources\n");
    /* Use sem_wait/sem_post to acquire/release */

    sem_close(sem);
    return 0;
}

Where are Named Semaphores Stored on Linux?

Linux stores named semaphores in a dedicated tmpfs filesystem mounted at /dev/shm. When you create a semaphore named /demo, it appears as /dev/shm/sem.demo.

This filesystem has kernel persistence: semaphore objects persist even when no process has them open, but they are lost on system reboot (since tmpfs is RAM-based).

/* Create a semaphore */
$ ./psem_create -cx /demo 666 1

/* Verify it exists on the filesystem */
$ ls -l /dev/shm/sem.*
-rw-rw---- 1 ravi users 16 Jun 12 10:00 /dev/shm/sem.demo

/* Each semaphore object is typically 16-32 bytes */
$ stat /dev/shm/sem.demo

Named Semaphores and fork()

When a process calls fork(), the child inherits all open named semaphore references from the parent. Both parent and child can then use the same semaphore to synchronize their actions.

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

int main(void)
{
    sem_t *sem;
    pid_t pid;

    /* Create semaphore, initial value 0 */
    sem = sem_open("/fork_sync", O_CREAT | O_EXCL, 0660, 0);
    if (sem == SEM_FAILED) { perror("sem_open"); exit(1); }

    pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        /* CHILD: do some work then signal parent */
        printf("Child: doing work...\n");
        sleep(1);
        printf("Child: work done, signaling parent\n");
        sem_post(sem);   /* increment: signal parent */
        sem_close(sem);
        exit(0);
    } else {
        /* PARENT: wait for child to complete */
        printf("Parent: waiting for child...\n");
        sem_wait(sem);   /* decrement: wait for child signal */
        printf("Parent: child signaled, continuing\n");
        wait(NULL);
        sem_close(sem);
        sem_unlink("/fork_sync");
    }

    return 0;
}

sem_close() — Close a Named Semaphore

#include <semaphore.h>

int sem_close(sem_t *sem);
/* Returns: 0 on success, -1 on error */

sem_close() removes the calling process’s association with the semaphore. It does not delete the semaphore from the system. Other processes that have the semaphore open can continue using it.

sem_unlink() — Delete a Named Semaphore

#include <semaphore.h>

int sem_unlink(const char *name);
/* Returns: 0 on success, -1 on error */

sem_unlink() removes the semaphore name from the system and marks the semaphore for deletion. The actual deletion happens only when all processes that have the semaphore open call sem_close() (or exit). This is similar to how unlink() works with files.

Complete Example: Two Processes Sharing a Named Semaphore

This example shows a server process creating a semaphore and a client process opening the same semaphore to coordinate access.

server.c (creates and manages semaphore)

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

#define SEM_NAME  "/ep_server_sem"

int main(void)
{
    sem_t *sem;

    /* Remove old semaphore if it exists from a previous crash */
    sem_unlink(SEM_NAME);

    /* Create fresh: binary semaphore, initial value 1 (unlocked) */
    sem = sem_open(SEM_NAME, O_CREAT | O_EXCL, 0660, 1);
    if (sem == SEM_FAILED) {
        perror("sem_open (server)");
        exit(EXIT_FAILURE);
    }

    printf("Server: semaphore '%s' created.\n", SEM_NAME);
    printf("Server: sleeping 10 seconds (start client now)...\n");
    sleep(10);

    printf("Server: shutting down, unlinking semaphore\n");
    sem_close(sem);
    sem_unlink(SEM_NAME);
    return 0;
}

client.c (opens and uses the existing semaphore)

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>

#define SEM_NAME  "/ep_server_sem"

int main(void)
{
    sem_t *sem;

    /* Open existing semaphore (no O_CREAT) */
    sem = sem_open(SEM_NAME, 0);
    if (sem == SEM_FAILED) {
        perror("sem_open (client)");
        exit(EXIT_FAILURE);
    }

    printf("Client: acquired semaphore reference\n");

    /* Acquire (lock) */
    printf("Client: waiting to acquire lock...\n");
    if (sem_wait(sem) == -1) {
        perror("sem_wait");
        exit(EXIT_FAILURE);
    }
    printf("Client: lock acquired! In critical section\n");
    sleep(2);   /* simulate work */
    printf("Client: releasing lock\n");

    /* Release (unlock) */
    if (sem_post(sem) == -1) {
        perror("sem_post");
        exit(EXIT_FAILURE);
    }

    sem_close(sem);
    printf("Client: done\n");
    return 0;
}

/* Compile and run */
gcc server.c -o server -pthread
gcc client.c -o client -pthread

/* Terminal 1 */
./server

/* Terminal 2 (while server is running) */
./client

Common Errors and Their Meanings