#include <stdio.h>          /* printf()                 */
#include <stdlib.h>         /* exit(), malloc(), free() */
#include <unistd.h>
#include <sys/types.h>      /* key_t, sem_t, pid_t      */
#include <sys/wait.h>
#include <sys/shm.h>        /* shmat(), IPC_RMID        */
#include <errno.h>          /* errno, ECHILD            */
#include <semaphore.h>      /* sem_open(), sem_destroy(), sem_wait().. */
#include <fcntl.h>          /* O_CREAT, O_EXEC          */


int main (int argc, char **argv){
    int i;                        /*      loop variables          */
    key_t shmkey;                 /*      shared memory key       */
    int shmid;                    /*      shared memory id        */
    sem_t *sem;                   /*      synch semaphore         *//*shared */
    pid_t pid;                    /*      fork pid                */
    int *p;                       /*      shared variable         *//*shared */
    unsigned int n;               /*      fork count              */
    unsigned int value;           /*      semaphore value         */

    /* initialize a shared variable in shared memory */
    shmkey = ftok ("/dev/null", 5);       /* valid directory name and a number */
    printf ("shmkey for p = %d\n", shmkey);
    shmid = shmget (shmkey, sizeof (int), 0644 | IPC_CREAT);
    if (shmid < 0){                           /* shared memory error check */
        perror ("shmget\n");
        exit (1);
    }

    p = (int *) shmat (shmid, NULL, 0);   /* attach p to shared memory */
    *p = 0;
    printf ("p=%d is allocated in shared memory.\n\n", *p);

    /********************************************************/

    printf ("How many children do you want to fork?\n");
    printf ("Fork count: ");
    scanf ("%u", &n);

    printf ("What do you want the semaphore value to be?\n");
    printf ("Semaphore value: ");
    scanf ("%u", &value);

    /* initialize semaphores for shared processes */
    sem = sem_open ("pSem", O_CREAT | O_EXCL, 0644, value); 
    /* name of semaphore is "pSem", semaphore is reached using this name */
    sem_unlink ("pSem");      
    /* unlink prevents the semaphore existing forever */
    /* if a crash occurs during the execution         */
    printf ("semaphores initialized.\n\n");


    /* fork child processes */
    for (i = 0; i < n; i++){
        pid = fork ();
        if (pid < 0)              /* check for error      */
            printf ("Fork error.\n");
        else if (pid == 0)
            break;                  /* child processes */
    }


    /******************************************************/
    /******************   PARENT PROCESS   ****************/
    /******************************************************/
    if (pid != 0){
        /* wait for all children to exit */
        while ((pid = waitpid (-1, NULL, 0)) > 0){
           if (errno == ECHILD)
                break;
        }

        printf ("\nParent: All children have exited.\n");

        /* shared memory detach */
        shmdt (p);
        shmctl (shmid, IPC_RMID, 0);

        /* cleanup semaphores */
        sem_unlink("pSem");
        sem_close(sem);

        exit (0);
    }

    /******************************************************/
    /******************   CHILD PROCESS   *****************/
    /******************************************************/
    else{
        sem_wait (sem);           /* P operation */
        printf ("  Child(%d) is in critical section.\n", i);
        sleep (1);
        *p += i % 3;              /* increment *p by 0, 1 or 2 based on i */
        printf ("  Child(%d) new value of *p=%d.\n", i, *p);
        sem_post (sem);           /* V operation */
        exit (0);
    }
}

sem_t* sem_open(const char *name, int oflag, /*optional*/ mode_t mode , /*optional*/ unsigned int value);

sem_wait(sem_t *sem);
sem_trywait(sem_t *sem);
sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

#ifndef __SYS_V_SEM__
#define __SYS_V_SEM__
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#define SEM_RESOURCE_MAX 1 // 이진 세마포어를 의미합니다.

/**
 * 아래를 이해하기 위해서는 다음을 이해해야 합니다.
 * struct sembuf { short sem_num; short sem_op; short sem_flg; };
 * - sem_num은 세마포어의 수로 여러 개의 세마포어를 사용하는 경우 사용합니다. 하나의 경우 0이 됩니다.
 * - sem_op에 값을 넣어주면 그 값을 세마포어 값에 더하거나 빼주도록 합니다.
 * - sem_flg는 세마포어 옵션으로 크게 2가지가 있습니다.
 *   - IPC_NOWAIT: POSIX에서 sem_trywait와 유사한 역할을 합니다.
 *   - SEM_UNDO: 프로세스가 세마포어를 돌려주지 않고 종료할 경우 커널이 알아서 증가시켜줍니다.
 */
#define SEM_LOCK {0, -1, SEM_UNDO} // P 연산에 해당합니다.
#define SEM_UNLOCK {0, 1, SEM_UNDO} // V 연상에 해당합니다.

union semun { /***** <<<<< UNION임을 유의하도록 합니다. >>>>> *****/
    int val;                   // SETVAL의 값을 지칭합니다.
    struct semid_ds *buf;      // IPC_SET, IPC_STAT을 위한 버퍼입니다.
    unsigned short int *array; // GETALL, SETALL을 위한 배열에 해당합니다.
};

static inline int
sem_init(int *semid, key_t key) {
    union semun semopts;
    // 1은 세마포어의 크기를 의미합니다. 
    if((*semid = semget(key, 1, IPC_CREAT|IPC_EXCL|0666)) == -1) {
        return -1;
    }
    semopts.val = SEM_RESOURCE_MAX;
    /**
     * - 1st arg: 세마포어 아이디
     * - 2nd arg: 여러 개의 세마포어를 사용하는 경우 사용합니다. 하나의 경우 0이 됩니다.
     * - 3rd arg: 명령이 들어가는 곳으로 semun을 설정하도록 합니다.
     * - 4th arg: 설정이 될 semun에 해당합니다.
     */
    semctl(*semid, 0, SETVAL, semopts);
    return 0;
}

static inline int
sem_open(int *semid, key_t key) {
   // 세마포어의 접근만 하는 경우에는 0을 사용하도록 합니다.
   if((*semid = semget(key, 0, 0666)) == -1)  {
       perror("Semaphore doesn't exist");
       return -1;
   }
   return 0;
}

static inline void
sem_wait(int *semid) {
    struct sembuf sem_lock = SEM_LOCK;
    /**
     * int semop(int semid,. struct sembuf *sops, unsigned nsops);
     * 세마포어 식별자와 어떤 연산을 이루어 질 것인지와 관련된 명령입니다.
     * 여기서 nsops는 sops가 가리키는 배열의 수행 연산을 선택합니다.
     * SEM_LOCKS = {0, -1, SEM_UNDO} 이므로, 아래의 명령은 해당 배열에서 '-1'을 지칭하라는 것입니다.
     */
    semop(*semid, &sem_lock, 1);
}

static inline void
sem_post(int *semid) {
    struct sembuf sem_unlock = SEM_UNLOCK;
    semop(*semid, &sem_unlock, 1);
}

static inline void
sem_destroy(int *semid) {
    // 세마포어를 삭제하도록 합니다. 삭제이므로 semun은 0으로 아무것도 넘기지 않습니다. 
    semctl(*semid, 0, IPC_RMID, 0);
}
#endif