#include <sys/sem.h>
#include <errno.h>
#include <stdio.h>

/*
 * Try to acquire semaphore without blocking.
 * Returns: 0 if acquired, -1 if not available (EAGAIN), -2 on error.
 */
int sem_trywait(int semid, int semnum) {
    struct sembuf sop;
    sop.sem_num = semnum;
    sop.sem_op  = -1;             /* try to subtract 1 */
    sop.sem_flg = IPC_NOWAIT;     /* don't block — return EAGAIN if can't */

    if (semop(semid, &sop, 1) == -1) {
        if (errno == EAGAIN) {
            /* Resource not available right now */
            return -1;
        }
        perror("semop trywait");
        return -2;
    }
    return 0;  /* acquired! */
}

/* Usage: try to acquire, do something else if not available */
void process_with_trywait(int semid) {
    int result = sem_trywait(semid, 0);

    if (result == 0) {
        printf("Acquired semaphore — entering critical section\n");

        /* ... do protected work ... */

        /* Release: add 1 back */
        struct sembuf rel = {0, 1, 0};
        semop(semid, &rel, 1);
        printf("Released semaphore\n");

    } else if (result == -1) {
        printf("Resource busy — will try again later or do other work\n");
        /* ... do something else ... */
    }
}

/* Spin-lock pattern using IPC_NOWAIT (not recommended for production) */
void spin_acquire(int semid, int semnum) {
    struct sembuf sop = {semnum, -1, IPC_NOWAIT};
    int attempts = 0;

    while (semop(semid, &sop, 1) == -1) {
        if (errno != EAGAIN) { perror("semop spin"); return; }
        attempts++;
        usleep(1000);  /* 1ms backoff */
        if (attempts > 1000) {
            fprintf(stderr, "Spin timeout after %d attempts\n", attempts);
            return;
        }
    }
    printf("Acquired after %d spin attempts\n", attempts);
}

When a process acquires a semaphore with SEM_UNDO and then crashes (or exits abnormally), the kernel automatically reverses the operation. This prevents semaphores from being permanently locked.

#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

/*
 * Acquire semaphore with SEM_UNDO.
 * If this process exits/crashes without releasing, kernel will add 1 back.
 */
int sem_acquire_with_undo(int semid, int semnum) {
    struct sembuf sop;
    sop.sem_num = semnum;
    sop.sem_op  = -1;
    sop.sem_flg = SEM_UNDO;  /* track this operation for automatic undo */
    return semop(semid, &sop, 1);
}

/*
 * Release semaphore with SEM_UNDO.
 * The undo adjustment is cancelled (adjusted back to 0).
 */
int sem_release_with_undo(int semid, int semnum) {
    struct sembuf sop;
    sop.sem_num = semnum;
    sop.sem_op  = +1;
    sop.sem_flg = SEM_UNDO;  /* cancel the earlier undo adjustment */
    return semop(semid, &sop, 1);
}

/* Demonstrate SEM_UNDO: child crashes, parent sees semaphore released */
int main(void) {
    int semid;
    union semun { int val; struct semid_ds *buf; unsigned short *array; } arg;

    semid = semget(IPC_PRIVATE, 1, 0600);
    if (semid == -1) { perror("semget"); exit(1); }
    arg.val = 1;
    semctl(semid, 0, SETVAL, arg);

    pid_t pid = fork();
    if (pid == 0) {
        /* CHILD: acquire with SEM_UNDO, then crash */
        printf("Child: acquiring semaphore with SEM_UNDO\n");
        if (sem_acquire_with_undo(semid, 0) == -1) {
            perror("acquire"); exit(1);
        }
        int val = semctl(semid, 0, GETVAL);
        printf("Child: acquired! semaphore value = %d\n", val);

        printf("Child: simulating crash (exit without releasing)\n");
        _exit(1);  /* crash — no cleanup */

    } else {
        /* PARENT: wait for child, then check semaphore */
        wait(NULL);
        int val = semctl(semid, 0, GETVAL);
        printf("Parent: semaphore value after child crash = %d\n", val);
        /* value = 1 again! Kernel auto-reversed the child's acquire */
        /* WITHOUT SEM_UNDO this would be 0 — permanently locked */

        semctl(semid, 0, IPC_RMID);
    }
    return 0;
}

The most powerful feature of semop() is the ability to operate on multiple semaphores in a single atomic step. This prevents deadlocks that would occur with individual operations.

#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>

/*
 * Classic deadlock scenario WITHOUT atomic operations:
 *
 * Process A: acquire sem[0], then acquire sem[1]
 * Process B: acquire sem[1], then acquire sem[0]
 *
 * Both can block waiting for the other → DEADLOCK
 *
 * Solution: acquire BOTH atomically in one semop() call
 */

/* Atomically acquire two resources at once */
int acquire_two_resources(int semid) {
    struct sembuf ops[2];

    ops[0].sem_num = 0;   /* resource 1 */
    ops[0].sem_op  = -1;
    ops[0].sem_flg = SEM_UNDO;

    ops[1].sem_num = 1;   /* resource 2 */
    ops[1].sem_op  = -1;
    ops[1].sem_flg = SEM_UNDO;

    /*
     * ATOMIC: either BOTH operations succeed, or NEITHER does.
     * If sem[1] is not available, the kernel will NOT decrement sem[0].
     * The process blocks until BOTH can be acquired simultaneously.
     */
    return semop(semid, ops, 2);
}

/* Atomically release both resources */
int release_two_resources(int semid) {
    struct sembuf ops[2];

    ops[0].sem_num = 0;
    ops[0].sem_op  = +1;
    ops[0].sem_flg = SEM_UNDO;

    ops[1].sem_num = 1;
    ops[1].sem_op  = +1;
    ops[1].sem_flg = SEM_UNDO;

    return semop(semid, ops, 2);
}

/* Producer-consumer: atomically check buffer state */
int producer_deposit(int semid) {
    struct sembuf ops[2];

    /* Atomically: decrement empty-slot count AND acquire mutex */
    ops[0].sem_num = 0;   /* empty slots counter */
    ops[0].sem_op  = -1;  /* take one empty slot */
    ops[0].sem_flg = SEM_UNDO;

    ops[1].sem_num = 1;   /* mutex */
    ops[1].sem_op  = -1;  /* lock mutex */
    ops[1].sem_flg = SEM_UNDO;

    if (semop(semid, ops, 2) == -1) { perror("producer deposit"); return -1; }
    printf("Producer: locked mutex and took empty slot\n");
    return 0;
}

#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

/*
 * Wait-for-zero pattern:
 * - Initialize semaphore to N (number of workers)
 * - Each worker decrements by 1 when done
 * - Supervisor waits for value to reach 0 (all done)
 */

union semun { int val; struct semid_ds *buf; unsigned short *array; };

void worker(int semid, int worker_id) {
    printf("Worker %d: starting task\n", worker_id);
    sleep(worker_id);  /* simulate variable work time */
    printf("Worker %d: done, decrementing semaphore\n", worker_id);

    struct sembuf done = {0, -1, 0};  /* decrement by 1 */
    if (semop(semid, &done, 1) == -1) { perror("worker decrement"); }
}

void supervisor(int semid) {
    printf("Supervisor: waiting for all workers to complete...\n");

    /* Wait until semaphore value == 0 */
    struct sembuf wait_zero = {0, 0, 0};  /* sem_op = 0 means wait-for-zero */
    if (semop(semid, &wait_zero, 1) == -1) {
        perror("supervisor wait-for-zero");
        return;
    }

    printf("Supervisor: all workers done!\n");
}

int main(void) {
    int semid;
    union semun arg;
    int num_workers = 3;
    int i;

    /* Create semaphore set */
    semid = semget(IPC_PRIVATE, 1, 0600);
    if (semid == -1) { perror("semget"); exit(1); }

    /* Initialize to num_workers */
    arg.val = num_workers;
    if (semctl(semid, 0, SETVAL, arg) == -1) { perror("SETVAL"); exit(1); }

    printf("Semaphore initialized to %d (number of workers)\n", num_workers);

    /* Fork workers */
    for (i = 1; i <= num_workers; i++) {
        pid_t pid = fork();
        if (pid == 0) {
            worker(semid, i);
            exit(0);
        }
    }

    /* Supervisor: wait for all to finish */
    supervisor(semid);

    /* Wait for all children */
    for (i = 0; i < num_workers; i++) wait(NULL);

    semctl(semid, 0, IPC_RMID);
    return 0;
}

#include <sys/sem.h>
#include <sys/ipc.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

union semun { int val; struct semid_ds *buf; unsigned short *array; };

/* Create a binary semaphore (mutex) initialized to 1 (unlocked) */
int create_mutex(void) {
    int semid;
    union semun arg;

    semid = semget(IPC_PRIVATE, 1, 0600);
    if (semid == -1) { perror("semget"); return -1; }

    arg.val = 1;  /* 1 = unlocked, 0 = locked */
    if (semctl(semid, 0, SETVAL, arg) == -1) { perror("SETVAL"); return -1; }

    return semid;
}

/* Lock the mutex (blocks if already locked) */
int mutex_lock(int semid) {
    struct sembuf sop = {0, -1, SEM_UNDO};  /* subtract 1 */
    return semop(semid, &sop, 1);
}

/* Unlock the mutex */
int mutex_unlock(int semid) {
    struct sembuf sop = {0, +1, SEM_UNDO};  /* add 1 */
    return semop(semid, &sop, 1);
}

/* Try to lock without blocking */
int mutex_trylock(int semid) {
    struct sembuf sop = {0, -1, IPC_NOWAIT | SEM_UNDO};
    if (semop(semid, &sop, 1) == -1) {
        if (errno == EAGAIN) return 1;  /* locked by another */
        return -1;  /* error */
    }
    return 0;  /* successfully locked */
}

/* Shared counter protected by mutex */
static int shared_counter = 0;  /* in real code, this would be in shared mem */

void increment_safely(int semid, int n) {
    int i;
    for (i = 0; i < n; i++) {
        mutex_lock(semid);
        shared_counter++;  /* critical section */
        mutex_unlock(semid);
    }
}

int main(void) {
    int semid = create_mutex();
    if (semid == -1) exit(1);

    /* Fork two processes that increment the counter */
    for (int p = 0; p < 2; p++) {
        if (fork() == 0) {
            increment_safely(semid, 1000);
            printf("Child done\n");
            exit(0);
        }
    }

    wait(NULL); wait(NULL);

    printf("Final counter = %d (expected: in shared mem scenario)\n", shared_counter);
    semctl(semid, 0, IPC_RMID);
    return 0;
}

/* Robust semop with signal-safe retry */
int semop_retry(int semid, struct sembuf *sops, size_t nsops) {
    int ret;
    do {
        ret = semop(semid, sops, nsops);
    } while (ret == -1 && errno == EINTR);  /* retry if interrupted by signal */

    if (ret == -1) {
        if (errno == EIDRM) {
            fprintf(stderr, "semop: semaphore set was deleted\n");
        } else if (errno == EAGAIN) {
            /* Normal: non-blocking operation couldn't complete */
            return -1;
        } else {
            perror("semop");
        }
    }
    return ret;
}