Why does my lock not fix my race condition?

Question

I have coded little program that uses shared memory that sends bytes around basicly. The problem I have is, I think, that I'm getting stuck in the child process (it prints Process 2: 5000 and then nothing).

Can anyone help me? I'd really appreciate it!

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
 
int main() {
    int sem_id;
    int shm_id;

    key_t key = ftok("shared_memory", 1); // Create key shared memory
    key_t keytwo = ftok("semaphore", 1); // Create key semaphore
    shm_id = shmget(key, sizeof(int), IPC_CREAT | 0666); // Create shared memory
    sem_id = semget(keytwo, 1, IPC_CREAT | 0666); // Create Semaphore
 
    if((shm_id = shmget(key, sizeof(int), IPC_CREAT | 0666)) == -1){ // -1 indicates error
     perror("semctl");
     exit(1);
    } else {
    printf("Shared memory created with id: %d \n", shm_id);
    }
 
    if((sem_id = semget(keytwo, 1, IPC_CREAT | 0666)) == -1){ // -1 indicates error
    perror("semctl");
    exit(1);
    } else {
    printf("Sephamore created with id: %d \n", shm_id);
    }
 
    struct sembuf sem_lock = {0, -1, 0}; // Struct for semop to lock
    struct sembuf sem_unlock = {0, 1, 0}; // Struct for semop to unlock
 
    char *data = (char *)shmat(shm_id, NULL, 0); // Connect Shared-Memorys to Process
 
    pid_t pid;
 
    semctl(sem_id, 0, SETVAL, 1); //initialize the semaphore with value 1
    if((semctl(sem_id, 0, SETVAL, 1)) == -1){ // -1 indicates error
     perror("semctl");
     exit(1);
    } else {
    printf("Sephamore initialized \n");
    }
 
    pid = fork();
 
    if(pid < 0){
        printf("Error");
        return 1;
    }
 
    int p = 1;
    int c = 1;

    //16777216 = 1024 * 16384 
    char *message = (char *) malloc(16777216);
    char *read = (char *) malloc(16777216);
 
    for (int KiB = 1; KiB <= 16384; KiB *= 2) {
        int bytes = KiB * 1024;

         for(int i = 0; i < 1000; i++){
 
            if (pid == 0) {
                // Process 2:
                semop(sem_id, &sem_lock, 1);
                memcpy(read, data, bytes); //"read" data
                //printf("%s \n", read) //print to check whether read worked
                semop(sem_id, &sem_unlock, 1);
                //print to check race condition
                printf("Process 2 print: %d \n", p);
                p++;
            } else {
                // Process 1:
                for (int i = 0; i < bytes; ++i) {
                    message[i] = 'a';
                }
                semop(sem_id, &sem_lock, 1);
                printf("%d", sem_id);
                memcpy(data, message, bytes);
                semop(sem_id, &sem_unlock, 1);
                //print to check race condition
                printf("Process 1 print: %d \n", c);
                c++;
                wait(NULL);
                }
        }
        
    }
  
    shmdt(data); // Remove shared-memory from process
    shmctl(shm_id, IPC_RMID, NULL); // Delete shared memory
    semctl(sem_id, 0, IPC_RMID); // Delete semaphore
 
    return 0;
}

I was expecting the processes to alternate.

I have tried: Place locks differently, Add locks, Remove locks, Remove unlocks, sleep(1).

Answer 1

I am not saying this is the reason for the failure, but you are not testing any return codes from these functions. Always test returns, especially if you are seeing problems and / or are new to calls

taking semctl as an example. looking here https://man7.org/linux/man-pages/man2/semctl.2.html you see that it returns a value indicating the result

so here

semctl(sem_id, 0, SETVAL, 1); //initialize the semaphore with value 1

you should do

if(semctl(sem_id, 0, SETVAL, 1) == -1){ // -1 indicates error
     perror("semctl");
     exit(1);
 }