Private Semaphore in c - c

Question

in some exemples i did see that they use threading for that
but i want to do it using just fork and 1 private semaphore
i want to do something simple like this :
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<semaphore.h>
int main() {
pid_t pid;
sem_t sema;
sem_init(&sema,1,0);
pid=fork();
if(pid==0) {
printf("first"); // want this first
sem_post(&sema);
}else{
sem_wait(&sema);
printf("second -_-");// and that second
}
return 0;
}
///////////////////////////////////
gcc pgm.c -pthread
./a.out
///////////////////////////////////
output :
first
//////////////////////////////////
so whats the problem here ? i want it =>
first second -_-

Answer 1

The semaphore you created is not shared across processes unless you create it in shared memory (even though you passed 1 for pshared). To do what you want to do, you need to create shared memory first. Read about shmget and shmat.
Note that if you used threads instead of fork, your threads would share the same memory and then the code would work. But because you used fork, you created a new process that no longer shares the same memory with the parent process.

Answer 2

If you are using semaphore.h, then you must put your semaphores in the shared memory to use them in different processes. If you don't want to use shared memory you can always use the semaphores in sys/sem.h. I've implemented your example using sys/sem.h below:
#include <stdio.h>
#include <stdlib.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
/* Required for semctl() */
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
int main()
{
pid_t pid;
/* VARIABLES FOR SEMAPHORE */
int sem_id;
union semun sem_arg;
unsigned short sem_value[1] = {0}; /* initial value of semaphore will be 0 */
struct sembuf sem_buf;
/* END OF VARIABLES FOR SEMAPHORE */
/* CREATE SHARED SEMAPHORE */
sem_arg.array = sem_value;
sem_id = semget(IPC_PRIVATE, 1, SHM_R | SHM_W);
semctl(sem_id, 0, SETALL, sem_arg);
/* END OF CREATE */
pid=fork();
if(pid==0) {
printf("first"); // want this first
/* UNLOCK SEMAPHORE */
sem_buf.sem_num = 0;
sem_buf.sem_op = 1;
sem_buf.sem_flg = 0;
semop(sem_id, &sem_buf, 1);
/* END OF UNLOCK */
}else {
/* LOCK SEMAPHORE */
sem_buf.sem_num = 0;
sem_buf.sem_op = -1;
sem_buf.sem_flg = 0;
semop(sem_id, &sem_buf, 1);
/* END OF LOCK */
printf("second -_-"); // and that second
}
/* Remove semaphore */
semctl(sem_id, 0, IPC_RMID, NULL);
return 0;
}
It looks more complicated but you can define functions for LOCK and UNLOCK sections and call them instead of writing the same 4 lines of code each time you want to lock/unlock your processes.
Note: you don't need -lpthread flag to compile this code.