使用互斥量构建信号量

Question

I'm reading Modern Operating Systems and there's a exercise that asks you to build a counting-semaphore with a binary-semaphore.

I was wondering if I could do it with semaphores & shared memory (C and POSIX IPC).

I'll leave a simplification of my program here.

typedef struct sem {
    int semid; /* contains two semaphores with value set to 1, one for the critical region and the other for locking */
    int shmid; /* shared counter */
}Sem;

/* the parent process spawns a few child processes and then waits for them */
void child() {
    Sem *s;
    
    s = get_sem();
    down_sem(s);
    printf("working...");
    sleep(5);
    printf("finished!");
    up_sem(s);
}

void down_sem(Sem *s) {
    int n;

    enter_critical(s); // down to critical region sem
    n = get_counter(s);
    
    if (n == 0) {
        exit_critical(s); // up to critical region sem
        acquire_lock(s); // down to lock sem
    } else {
        n--;
        exit_critical(s); // up to critical region sem
    }
}

void up_sem(Sem *s) {
    int n;

    enter_critical(s);
    n = get_counter(s);
    n++;
    
    if (n == 1) {
        exit_critical(s);
        release_lock(s); // up to lock sem
    } else {
        exit_critical(s);
    }
}

But this doesn't work since some processes block in the lock semaphore forever. I'm just now learning these concepts so my design is probably totally off.

I can share the complete code if you wish.

Thanks in advance!

EDIT: requested mre

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/shm.h>

#define NPROC 5
#define SLOTS 2

#define PATH "."
#define SID 'S'
#define SEMN 2

#define SHMID 'M'
#define SHM_SIZE 32

#define CRIT 0
#define LOCK 1

#define UP 1
#define DOWN -1

typedef struct sem {
    int shmid;
    int semid;
}Sem;

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

void err (char *msg) {
    char error[50];
    int n;

    n = snprintf(error, 50, "[%d] %s", getpid(), msg);
    error[n] = 0;
    perror(error);
    exit(1);
}

int* get_n(Sem *s) {
    int *data = NULL;

    data = shmat(s->shmid, (void *)0, 0);
    if (data == (int *)(-1))
        err("get_n shmat");

    return data;
}

void dettach_n(int *data) {
    if (shmdt(data) == -1)  
        err("dettach_n shmdt");
}

void enter_crit(Sem *s) {       
    struct sembuf sb;

    sb.sem_num = CRIT;
    sb.sem_op = DOWN;

    printf("[%d] enter crit\n", getpid());
    if (semop(s->semid, &sb, 1) == -1)
        err("enter crit");
}

void exit_crit(Sem *s) {
    struct sembuf sb;

    sb.sem_num = CRIT;
    sb.sem_op = UP;

    printf("[%d] exit crit\n", getpid());
    if (semop(s->semid, &sb, 1) == -1)
        err("exit crit");
}

void acquire_lock(Sem *s) {
    struct sembuf sb;

    sb.sem_num = LOCK;
    sb.sem_op = DOWN;

    printf("[%d] acquire lock\n", getpid());
    if (semop(s->semid, &sb, 1) == -1)
        err("acquire lock");
}

void release_lock(Sem *s) {
    struct sembuf sb;

    sb.sem_num = LOCK;
    sb.sem_op = UP;

    printf("[%d] release lock\n", getpid());
    if (semop(s->semid, &sb, 1) == -1)
        err("release lock");
}

int sem_init(Sem *s, int n) {
    key_t key;
    Args arg;
    int *data;

    /* sem */
    if ((key = ftok(PATH, SID)) == -1) {
        return -1;
    }
    if ((s->semid = semget(key, SEMN, 0600 | IPC_CREAT)) == -1) {
        return -1;
    }

    arg.val = 1;
    if (semctl(s->semid, 0, SETVAL, arg) == -1) {
        return -1;
    }
    if (semctl(s->semid, 1, SETVAL, arg) == -1) {
        return -1;
    }

    /* mem */
    if ((key = ftok(PATH, SHMID)) == -1) {
        return -1;
    }
    if ((s->shmid = shmget(key, SHM_SIZE, 0664 | IPC_CREAT)) == -1) {
        return -1;
    }

    data = shmat(s->shmid, (void *)0, 0);
    if (data == (int *)(-1)) {
        return -1;
    }
    *data = n;
    if (shmdt(data) == -1) {
        return -1;
    }

    return 0;
}

int sem_get(Sem *s) {
    key_t key;
    
    if ((key = ftok(PATH, SID)) == -1) {
        return -1;
    }
    if ((s->semid = semget(key, SEMN, 0)) == -1) {
        return -1;
    }

    if ((key = ftok(PATH, SHMID)) == -1) {
        return -1;
    }
    if ((s->shmid = shmget(key, SHM_SIZE, 0)) == -1) {
        return -1;
    }

    return 0;
}

int sem_up(Sem *s) {
    int *data;

    enter_crit(s);
    data = get_n(s);
    printf("[%d] read %d\n", getpid(), *data);
    (*data)++;

    if (*data == 1) {
        printf("[%d] now is %d\n", getpid(), *data);
        dettach_n(data);
        exit_crit(s);
        release_lock(s);
    } else {
        exit_crit(s);
    }

    return 0;
}

int sem_down(Sem *s) {
    int *data;

    enter_crit(s);
    data = get_n(s);

    printf("[%d] checked %d\n", getpid(), *data);
    if (*data == 0) {
        dettach_n(data);
        exit_crit(s);
        acquire_lock(s);
    } else {
        (*data)--;
        dettach_n(data);
        exit_crit(s);
    }

    return 0;
}

int sem_rm(Sem *s) {
    if (semctl(s->semid, 0, IPC_RMID) == -1)
        return -1;

    if (shmctl(s->shmid, 0, IPC_RMID) == -1)
        return -1;

    return 0;
}

void child() {
    pid_t pid;
    Sem s;

    pid = getpid();
    printf("\x1b[31m[%d] hello!\033[0m\n", pid);

    if (sem_get(&s) == -1) {
        perror("sem_get");
        exit(1);
    }   
    sem_down(&s);
    printf("\x1b[32m[%d] working...\033[0m\n", pid);
    sleep(5);
    printf("\x1b[32m[%d] finishing...\033[0m\n", pid);
    sem_up(&s);
    printf("\x1b[34m[%d] **child leaving**\033[0m\n", pid);
    exit(0);
}

int main() {
    Sem s;
    int i;

    if (sem_init(&s, SLOTS) == -1) {
        perror("sem_init");
        exit(1);
    }

    printf("[%d] parent\n", getpid());

    for (i = 0; i < NPROC; i++) {
        switch(fork()) {
        case 0:
            child();
        case -1:
            perror("fork");
            exit(1);
        }
    }   

    printf("waiting for children...\n");
    for (i = 0; i < NPROC; i++)
        wait(NULL);

    if (sem_rm(&s) == -1) {
        perror("sem_rm");
        exit(1);
    }

    printf("good bye!\n");

    return 0;
}

Answer 1

The problem was in the up_sem function. It only does an up to the lock sem (release_lock func) if n was previously 0. This is incorrect since it might be several process waiting.

My solution was adding an extra shared memory counting the waiting processes and doing an up to the lock sem when that number is greater than 0.