Enforce exclusive order of four processes using semaphores I am on the learning curve of C and its capabilities. Below I have tried to create 4 individual programs where the execution is always in order (program 0,1,2,3).

About the program 
Program #0 is always executed (called) first, it also creates semid's 
Program #1 can ONLY be executed if Program #0 has ran 
Program #2 can ONLY be executed if Program #1 has ran 
Program #3 can ONLY be executed if Program #2 has ran 

What Do I Need? 
Since, I am a beginner I thought an expert's knowledge on creating a better design or code structuring would help me.

Program Call 
./prog0 &amp;&amp; ./prog1 &amp;&amp; ./prog2 &amp;&amp; ./prog3

Program #0

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;unistd.h&gt;
#include &lt;sys/types.h&gt; 
#include &lt;sys/ipc.h&gt; 
#include &lt;sys/sem.h&gt;

int
main ( )
{
    int semid;
    key_t key;
    union semun arg;

    key = ftok("program0.c", 'a');
    semid = semget(key, 3, 0666 | IPC_CREAT);
    if ( semid &lt; 0 )
    {
        perror("Could Not Created The Requested Semaphore");
        exit(1);
    }
    arg.val = 1;
    semctl(semid, 0, SETVAL, arg);
    arg.val = 0;
    semctl(semid, 1, SETVAL, arg);
    semctl(semid, 2, SETVAL, arg);
    printf("Executing process #0.\n");
    return 0;
}


Program #1

int
main ( )
{
    int semid, key;
    union semun arg;
    key = ftok("program0.c", 'a');
    semid = semget(key, 3, 0666 | IPC_CREAT);
    if ( semid &lt; 0 )
    {
        perror("Could Not Created The Requested Semaphore");
        exit(1);
    }
    if ( semctl(semid, 0, GETVAL, 0) != 1 )
    {
        semctl(semid, 0, IPC_RMID);
        exit(1);
    }
    printf("Executing process #1.\n");
    arg.val = 0;
    semctl(semid, 0, SETVAL, arg);
    arg.val++;
    semctl(semid, 1, SETVAL, arg);
    return 0;
}


Program #2

int
main ( )
{
    int semid, key;
    union semun arg;
    key = ftok("program0.c", 'a');
    semid = semget(key, 3, 0666 | IPC_CREAT);
    if ( semid &lt; 0 )
    {
        perror("Could Not Created The Requested Semaphore");
        exit(1);
    }
    if ( semctl(semid, 1, GETVAL, 0) != 1 )
    {
        semctl(semid, 0, IPC_RMID);
        exit(1);
    }
    printf("Executing process #2.\n");
    arg.val = 0;
    semctl(semid, 1, SETVAL, arg);
    arg.val++;
    semctl(semid, 2, SETVAL, arg);
    return 0;
}


Program #3

int
main ( )
{
    int semid, key;
    key = ftok("program0.c", 'a');
    semid = semget(key, 3, 0666 | IPC_CREAT);
    if ( semid &lt; 0 )
    {
        perror("Could Not Created The Requested Semaphore");
        exit(1);
    }
    if ( semctl(semid, 2, GETVAL, 0) != 1 )
    {
        semctl(semid, 0, IPC_RMID);
        exit(1);
    }
    printf("Executing process #3.\n");
    semctl(semid, 0, IPC_RMID);
    return 0;
}
Programs exit instead of wait

Right now, your programs check their semaphore, but if they don't find the value they are expecting, they exit instead of wait.  I think that you should modify your programs to wait until the previous program signals them.  You would need to make the following modifications:


In program #0, initialize each semaphore to the value 1.
In each other program, use semop() to wait for its semaphore to reach value 0.  For example, program #1 waits for semaphore #0's value to become 0, using semop().
Modify each program to actually take a non-zero amount of time to do its work.  I suggest a for loop like this:

for (int i=0;i&lt;10;i++) {
    printf("Executing process #1, iteration #%d.\n", i);
    sleep(1);
}

After each program's work loop, it releases its semaphore using semop().  This causes the semaphore value to transition from 1 to 0, which allows the next program to run.  For example, program #1 releases semaphore #1, causing program #2 to be able to run.
Program #3 cleans up instead of releasing a semaphore.