struct sem{
                    int semval;		// current value
                    int sempid		// pid of last operation
                    }
                    

#include <sys/types.h>
                    #include <sys/ipc.h>
                    key_t ftok (char*pathname, char proj)；
                    

#include <sys/types.h>
                    #include <sys/ipc.h>
                    #include <sys/sem.h>
                    

struct sembuf {
                    unsigned short  	sem_num;		/* semaphore index in array */
                    short			sem_op;		/* semaphore operation */
                    short			sem_flg;		/* operation flags */
                    };
                    

#include <linux/sem.h>
                    #include <stdio.h>
                    #include <errno.h>
                    #define SEM_PATH "/unix/my_sem"
                    #define max_tries 3
                    int semid;
                    main()
                    {
                    int flag1,flag2,key,i,init_ok,tmperrno;
                    struct semid_ds sem_info;
                    struct seminfo sem_info2;
                    union semun arg; 			//union semun： 請參考附錄2
                    struct sembuf askfor_res, free_res;
                    flag1=IPC_CREAT|IPC_EXCL|00666;
                    flag2=IPC_CREAT|00666;
                    key=ftok(SEM_PATH,‘a(chǎn)‘);
                    //error handling for ftok here;
                    init_ok=0;
                    semid=semget(key,1,flag1);//create a semaphore set that only includes one semphore.
                    if(semid<0)
                    {
                    tmperrno=errno;
                    perror("semget");
                    if(tmperrno==EEXIST)
                    //errno is undefined after a successful library call( including perror call) so it is saved //in tmperrno.
                    {
                    semid=semget(key,1,flag2);
                    //flag2 只包含了IPC_CREAT標(biāo)志, 參數(shù)nsems(這里為1)必須與原來的信號燈數(shù)目一致
                    arg.buf=&sem_info;
                    for(i=0; i<max_tries; i++)
                    {
                    if(semctl(semid, 0, IPC_STAT, arg)==-1)
                    {	perror("semctl error"); i=max_tries;}
                    else
                    {
                    if(arg.buf->sem_otime!=0){ i=max_tries;  init_ok=1;}
                    else	 sleep(1);
                    }
                    }
                    if(!init_ok)
                    // do some initializing, here we assume that the first process that creates the sem will
                    // finish initialize the sem and run semop in max_tries*1 seconds. else it will not run
                    // semop any more.
                    {
                    arg.val=1;
                    if(semctl(semid,0,SETVAL,arg)==-1) perror("semctl setval error");
                    }
                    }
                    else
                    {perror("semget error, process exit");	exit();	}
                    }
                    else //semid>=0; do some initializing
                    {
                    arg.val=1;
                    if(semctl(semid,0,SETVAL,arg)==-1)
                    perror("semctl setval error");
                    }
                    //get some information about the semaphore and the limit of semaphore in redhat8.0
                    arg.buf=&sem_info;
                    if(semctl(semid, 0, IPC_STAT, arg)==-1)
                    perror("semctl IPC STAT");
                    printf("owner‘s uid is %d\n", 	arg.buf->sem_perm.uid);
                    printf("owner‘s gid is %d\n", 	arg.buf->sem_perm.gid);
                    printf("creater‘s uid is %d\n", 	arg.buf->sem_perm.cuid);
                    printf("creater‘s gid is %d\n", 	arg.buf->sem_perm.cgid);
                    arg.__buf=&sem_info2;
                    if(semctl(semid,0,IPC_INFO,arg)==-1)
                    perror("semctl IPC_INFO");
                    printf("the number of entries in semaphore map is %d \n",	 		arg.__buf->semmap);
                    printf("max number of semaphore identifiers is %d \n", 		 	arg.__buf->semmni);
                    printf("mas number of semaphores in system is %d \n",		 		arg.__buf->semmns);
                    printf("the number of undo structures system wide is %d \n",	 	arg.__buf->semmnu);
                    printf("max number of semaphores per semid is %d \n",		 		arg.__buf->semmsl);
                    printf("max number of ops per semop call is %d \n",		 		arg.__buf->semopm);
                    printf("max number of undo entries per process is %d \n", 	 		arg.__buf->semume);
                    printf("the sizeof of struct sem_undo is %d \n", 	  	 			arg.__buf->semusz);
                    printf("the maximum semaphore value is %d \n", 					arg.__buf->semvmx);
                    //now ask for available resource:
                    askfor_res.sem_num=0;
                    askfor_res.sem_op=-1;
                    askfor_res.sem_flg=SEM_UNDO;
                    if(semop(semid,&askfor_res,1)==-1)//ask for resource
                    perror("semop error");
                    sleep(3); //do some handling on the sharing resource here, just sleep on it 3 seconds
                    printf("now free the resource\n");
                    //now free resource
                    free_res.sem_num=0;
                    free_res.sem_op=1;
                    free_res.sem_flg=SEM_UNDO;
                    if(semop(semid,&free_res,1)==-1)//free the resource.
                    if(errno==EIDRM)
                    printf("the semaphore set was removed\n");
                    //you can comment out the codes below to compile a different version:
                    if(semctl(semid, 0, IPC_RMID)==-1)
                    perror("semctl IPC_RMID");
                    else printf("remove sem ok\n");
                    }
                    

owner‘s uid is 0
                    owner‘s gid is 0
                    creater‘s uid is 0
                    creater‘s gid is 0
                    the number of entries in semaphore map is 32000
                    max number of semaphore identifiers is 128
                    mas number of semaphores in system is 32000
                    the number of undo structures system wide is 32000
                    max number of semaphores per semid is 250
                    max number of ops per semop call is 32
                    max number of undo entries per process is 32
                    the sizeof of struct sem_undo is 20
                    the maximum semaphore value is 32767
                    now free the resource
                    remove sem ok
                    

/*系統(tǒng)中的每個信號燈集對應(yīng)一個sem_array 結(jié)構(gòu) */
                    struct sem_array {
                    struct kern_ipc_perm	sem_perm;		/* permissions .. see ipc.h */
                    time_t			sem_otime;			/* last semop time */
                    time_t			sem_ctime;			/* last change time */
                    struct sem		*sem_base;			/* ptr to first semaphore in array */
                    struct sem_queue	*sem_pending;		/* pending operations to be processed */
                    struct sem_queue	**sem_pending_last; 	/* last pending operation */
                    struct sem_undo		*undo;			/* undo requests on this array */
                    unsigned long		sem_nsems;		/* no. of semaphores in array */
                    };
                    

/* 系統(tǒng)中每個因?yàn)樾盘枱舳叩倪M(jìn)程，都對應(yīng)一個sem_queue結(jié)構(gòu)*/
                    struct sem_queue {
                    struct sem_queue *	next;	 	/* next entry in the queue */
                    struct sem_queue **	prev;	 	/* previous entry in the queue, *(q->prev) == q */
                    struct task_struct*	sleeper; 	/* this process */
                    struct sem_undo *	undo;	 	/* undo structure */
                    int   pid;	 					/* process id of requesting process */
                    int   status;	 				/* completion status of operation */
                    struct sem_array *	sma;	 		/* semaphore array for operations */
                    int	id;	 						/* internal sem id */
                    struct sembuf *	sops;		 	/* array of pending operations */
                    int	nsops;					 	/* number of operations */
                    int	alter;	 					/* operation will alter semaphore */
                    };
                    

union semun {
                    int val;					/* value for SETVAL */
                    struct semid_ds *buf;		/* buffer for IPC_STAT & IPC_SET */
                    unsigned short *array;		/* array for GETALL & SETALL */
                    struct seminfo *__buf;		/* buffer for IPC_INFO */   //test!!
                    void *__pad;
                    };
                    struct  seminfo {
                    int semmap;
                    int semmni;
                    int semmns;
                    int semmnu;
                    int semmsl;
                    int semopm;
                    int semume;
                    int semusz;
                    int semvmx;
                    int semaem;
                    };