Process communication - semaphore

Interprocess communication —— Semaphore

Related structures
1.sem

C Code

1. struct sem {   
2.                  short   sempid;        /* pid of last operation */  
3.                  ushort  semval;        /* current value */  
4.                  ushort  semncnt;       /* num procs awaiting increase in semval */  
5.                  ushort  semzcnt;       /* num procs awaiting semval = 0 */  
6. };  

struct sem {
                 short   sempid;        /* pid of last operation */
                 ushort  semval;        /* current value */
                 ushort  semncnt;       /* num procs awaiting increase in semval */
                 ushort  semzcnt;       /* num procs awaiting semval = 0 */
};

among ,
sem_pid The member saves the process of the last semaphore operation pid.
sem_semval  Members store the count value of semaphores .
sem_semncnt The member holds the number of processes waiting to use resources .
sem_semzcnt  Members save the number of processes waiting for resources to be completely idle .

2.semun
semun The consortium is in senctl() Use in a function , Provide senctl() Information required for operation .

C Code

1. union semun {   
2.                  int val;                /* value for SETVAL */  
3.                  struct semid_ds *buf;   /* buffer for IPC_STAT & IPC_SET */  
4.                  ushort *array;          /* array for GETALL & SETALL */  
5.                  struct seminfo *__buf;  /* buffer for IPC_INFO */  
6.                  void *__pad;   
7. };  

union semun {
                 int val;                /* value for SETVAL */
                 struct semid_ds *buf;   /* buffer for IPC_STAT & IPC_SET */
                 ushort *array;          /* array for GETALL & SETALL */
                 struct seminfo *__buf;  /* buffer for IPC_INFO */
                 void *__pad;
};

3．sembuf
sembuf The structure is semop() Function is used to define basic operations on semaphore objects

C Code

1. struct sembuf {   
2.          unsigned short  sem_num;        /* semaphore index in array */  
3.          short           sem_op;         /* semaphore operation */  
4.          short           sem_flg;        /* operation flags */  
5. };  

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

among ,
sem_num The member is the sequence number of the semaphore receiving the operation in the semaphore array （ The array subscript ）.
sem_op  Member defines the operation to be performed ( It can be positive 、 Negative and zero ).
sem_flg It is a sign of controlling operation behavior .

4.semid_qs
and msgqid_ds similar ,semid_qs Structure is used by the system to store information about each semaphore object .

C Code

1. struct semid_ds {   
2.       struct ipc_perm sem_perm;            /* permissions ..  see ipc.h */  
3.       __kernel_time_t sem_otime;           /* last semop time */  
4.       __kernel_time_t sem_ctime;           /* last change time */  
5.       struct sem      *sem_base;           /* ptr to first semaphore in array */  
6.       struct sem_queue *sem_pending;       /* pending operations to be processed */  
7.       struct sem_queue **sem_pending_last; /* last pending operation */  
8.       struct sem_undo *undo;               /* undo requests on this array */  
9.       unsigned short  sem_nsems;           /* no.  of semaphores in array */  
10. };  

struct semid_ds {
      struct ipc_perm sem_perm;            /* permissions ..  see ipc.h */
      __kernel_time_t sem_otime;           /* last semop time */
      __kernel_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 short  sem_nsems;           /* no.  of semaphores in array */
};

among ,
sem_perm  Members store the access rights of semaphore objects and other information .
sem_otime Members saved the last semop() Time of operation .
sem_ctime The member saves the time when the semaphore object was last changed .
sem_base  The pointer stores the starting address of the semaphore array .
sem_pending The pointer saves the operation that has not been carried out .
sem_pending_last The pointer holds the last operation that has not been performed .
sem_undo  Members saved undo The number of requests .
sem_nsems Member holds the number of members of the semaphore array .

Related functions
1.semget()
Use semget() Function to create a new semaphore object or get the identifier of an existing object .
system call ： semget()
Function declaration ： int semget(key_t key,int nsems,int semflg);
Return value ：  semaphore set IPC identifier on success

C Code

1. int open_semaphore_set(key_t keyval, int numsems)   
2. {   
3.     int sid;   
4.     if(!numsems) return(-1);   
5.     if((sid=semget(keyval,numsems,IPC_CREAT|0660))==-1)   
6.     {      
7.         return(-1);   
8.     }   
9.     return(sid);   
10. }  

int open_semaphore_set(key_t keyval, int numsems)
{
	int sid;
	if(!numsems) return(-1);
	if((sid=semget(keyval,numsems,IPC_CREAT|0660))==-1)
	{	
		return(-1);
	}
	return(sid);
}

The second parameter of the function nsems Is unique to semaphore objects , It specifies the number of semaphores in the newly generated semaphore object , That is, the number of semaphore array members .
2.semop()
Use this function to change the state of each semaphore in the semaphore object .
system call ： semop()
Function declaration ： int semop(int semid, struct sembuf *sops, unsigned int nsops);
Return value ：  0 on success (all operations performed)
The first parameter semid Is the identifier of the semaphore object to be operated .
The second parameter sops yes sembuf Array of , It defines the semop() The sequence of operations to be performed by the function .
The third parameter nsops preserved sops Length of array , That is to say semop() The number of operations that the function will perform .

3.semctl()
And message queues msgctl() Function similar to ,semctl() Function is used to directly control the semaphore object
system call ：  semctl()
Function declaration ：  int semctl(int semid, int semnum, int cmd, union semun arg);
Return value ：   positive integer on success
Comparing the parameters of these two functions, we find some subtle differences . First , Because the semaphore object is actually a collection of multiple semaphores rather than a single individual , So when operating , It is not only necessary to specify the identifier of the object , You also need to use the sequence number of semaphores in the set to specify specific semaphore individuals .

Both functions have cmd Parameters , Specifies the specific operation of the function . however , and msgctl() Compared to the function , semctl() Functions can do much more ：
IPC_STAT  Get semaphore object semid_ds structural information , And store it in arg Parameters in buf The pointer returns .
IPC_SET   use arg Parameters in buf To set the... Of the semaphore object semid_ds structural information . Just like the message queue object , Only a few parameters can be set by this function .
IPC_RMID  Delete semaphore object from memory .
GETALL    Get the values of all semaphores in the semaphore object , And store it arg In the parameter array Array returns .
GETNCNT   Returns the number of processes waiting to use a semaphore controlled resource .
GETPID    Returns the last call to a semaphore semop() The process of the function pid.
GETVAL    Return the value of a semaphore of the object .
GETZCNT   Returns the number of processes waiting for the resources controlled by a semaphore to be fully used .
SETALL    use arg Parameters in array Array value to set the value of each semaphore in the object .
SETVAL    use arg Parameters in val Member to set the value of a semaphore in the object .

C Code

1. int  get_sem_val(int sid, int semnum)   
2. {   
3.     return(semctl(sid,semnum,GETVAL,0));   
4. }  

int  get_sem_val(int sid, int semnum)
{
	return(semctl(sid,semnum,GETVAL,0));
}

The above code returns the value of a semaphore in the semaphore object . Note that there semctl() The last parameter of the function takes zero , This is because of the execution GETVAL This parameter is automatically ignored during the command .

C Code

1. void init_semaphore(int sid, int semnum, int initval)   
2. {   
3.     union semun semopts;   
4.         semopts.val=initval;   
5.     semctl(sid, semnum, SETVAL, semopts);   
6.   
7. }  

void init_semaphore(int sid, int semnum, int initval)
{
	union semun semopts;
        semopts.val=initval;
	semctl(sid, semnum, SETVAL, semopts);

}

The code above uses initval Parameter to set the value of a semaphore in the semaphore object .
In message queues and semaphore objects , There are IPC_STAT and IPC_SET The operation of . However, due to the different types of passed parameters , Caused the difference in their use . stay msgctl() Function ,IPC_STAT The operation is simply to put the kernel msgqid_ds junction

The address of the structure is given buf Parameters ( It's a pointer ). And in the semctl() Function , IPC_STAT The operation is to semid_ds Copy the contents of to arg Parametric buf In the memory indicated by the member pointer . therefore , The following code will generate errors , and msgctl() Functional

Similar code does not ：

C Code

1. void getmode(int sid)   
2. {   
3.     int rc;   
4.     union semun semopts;   
5.     /* The following statement will produce errors */  
6.     if((rc=semctl(sid, 0, IPC_STAT, semopts))==-1)   
7.     {   
8.         perror("semctl");   
9.     }   
10.     printf("Pemission Mode were %o/n", semopts.buf->sem_perm.mode);   
11.     return;   
12. }  

void getmode(int sid)
{
	int rc;
	union semun semopts;
	/* The following statement will produce errors */
	if((rc=semctl(sid, 0, IPC_STAT, semopts))==-1)
	{
		perror("semctl");
	}
	printf("Pemission Mode were %o/n", semopts.buf->sem_perm.mode);
	return;
}

Why? ？ Because the implementation does not give buf Pointer allocates memory , Its direction is uncertain . such “ Not oriented ” The pointer of is C One of the most dangerous traps in the program . Correct this mistake , Just give it in advance buf The pointer prepares a piece of memory . Here is the modified code ：

C Code

1. void getmode(int sid)   
2. {   
3.     int rc;   
4.     union semun semopts;   
5.     struct semid_ds mysemds;   
6.     /* to buf The pointer prepares a piece of memory */  
7.     semopts.buf=&mysemds;   
8.   
9.     /* Now? OK 了 */  
10.     if((rc=semctl(sid, 0, IPC_STAT, semopts))==-1)   
11.     {   
12.         perror("semctl");   
13.     }   
14.     printf("Pemission Mode were %o/n", semopts.buf->sem_perm.mode);   
15.     return;   
16.   
17. }  

void getmode(int sid)
{
	int rc;
	union semun semopts;
	struct semid_ds mysemds;
	/* to buf The pointer prepares a piece of memory */
	semopts.buf=&mysemds;

	/* Now? OK 了 */
	if((rc=semctl(sid, 0, IPC_STAT, semopts))==-1)
	{
		perror("semctl");
	}
	printf("Pemission Mode were %o/n", semopts.buf->sem_perm.mode);
	return;

}

example ：

C Code

1. semtool.c   
2.   
3. #include <stdio.h>   
4. #include <ctype.h>   
5. #include <stdlib.h>   
6. #include <sys/types.h>   
7. #include <sys/ipc.h>   
8. #include <sys/sem.h>   
9.   
10. #define SEM_RESOURCE_MAX 1      /*Initial value of all semaphores*/   
11.   
12. void opensem(int *sid, key_t key);   
13. void createsem(int *sid, key_t key, int members);   
14. void locksem(int sid, int member);   
15. void unlocksem(int sid, int member);   
16. void removesem(int sid);   
17. unsigned short get_member_count(int sid);   
18. int  getval(int sid, int member);   
19. void dispval(int sid,int member);   
20. void changemode(int sid, char *mode);   
21. void usage(void);   
22.   
23. int main(int argc, char *argv[])   
24. {   
25.     key_t key;   
26.     int semset_id;   
27.     if(argc == 1) usage();   
28.   
29.     /*Create unique key via call to ftok()*/  
30.     key=ftok(".",'s');     
31.     switch(tolower(argv[1][0]))   
32.         {   
33.   
34.         case 'c':    
35.         if(argc!=3)usage();   
36.         createsem(&semset_id, key, atoi(argv[2]));   
37.         break;   
38.   
39.         case 'l':   
40.         if(argc!=3) usage();   
41.         opensem(&semset_id, key);   
42.         locksem(semset_id, atoi(argv[2]));   
43.         break;   
44.            
45.         case 'u':   
46.         if(argc!=3) usage();   
47.         opensem(&semset_id, key);   
48.         unlocksem(semset_id, atoi(argv[2]));   
49.         break;   
50.   
51.         case 'd':    
52.         opensem(&semset_id,key);   
53.         removesem(semset_id);   
54.         break;   
55.   
56.         case 'm':   
57.         opensem(&semset_id, key);   
58.         changemode(semset_id, argv[2]);   
59.         break;   
60.   
61.         default:   
62.         usage();   
63.   
64.   
65.     }   
66.     return(0);   
67.   
68. }   
69.   
70. void opensem(int *sid,  key_t key)   
71. {   
72.     /*Open the semaphore set ---do not creat!*/  
73.     if((*sid=semget(key, 0 , 0666)==-1)   
74.     {   
75.   
76.         printf("Semaphore set does not exist!/n");   
77.         exit(1);   
78.     }   
79.   
80. }   
81.   
82. void createsem(int *sid, key_t key, int members)   
83. {   
84.     int cntr;   
85.     union semun semopts;   
86.     if(members > SEMMSL){   
87.         printf("Sorry,max number of semaphores in a set is %d/n",SEMMSL);   
88.         exit(1);   
89.   
90.     }   
91.     printf("Attempting to create new semaphore set with %d members/n",members);   
92.     if((*sid=semget(key, members, IPC_CREAT|IPC_EXCL|0666))==-1)   
93.     {   
94.         fprintf(stderr,"Semaphore set already exist!/n");   
95.         exit(1);   
96.   
97.     }   
98.        
99.     semopts.val= SEM_RESOURCE_MAX;   
100.     /*Initialize all members(could be done with SETALL)*/  
101.     for(cntr=0;cntr<members;cntr++)   
102.     {   
103.         semctl(*sid, cntr, SETVAL, semopts);   
104.     }   
105.   
106. }   
107.   
108.   
109. void locksem(int sid, int member)   
110. {   
111.     struct sembuf sem_lock={0, -1, IPC_NOWAIT};   
112.     if(member <0 ||member>(get_member_count(sid) -1))   
113.     {   
114.         fprintf(stderr,"semaphore member %d out of range/n", member);   
115.         return;   
116.            
117.   
118.     }   
119.        
120.     /*Attempt to lock the semphore set*/  
121.         if(!getval(sid, member))   
122.     {   
123.         fprintf(stderr,"Semaphore resources exhausted (no lock)/n")   
124.         exit(1);       
125.     }   
126.   
127.     sem_lock.sem_num =member;   
128.        
129.     if((semop(sid, &sem_lock, 1)==-1)   
130.     {   
131.         fprintf, "Lock faild/n");   
132.             exit(1);   
133.   
134.   
135.     }   
136.     else  
137.   
138.         printf("Semaphore resources decremented by one (locked)/n");   
139.     dispval(sid ,member);   
140.   
141.   
142. }   
143.   
144.   
145. void unlocksem(int sid, int member)   
146. {   
147.   
148.     struct sembuf sem_unlock={member, 1, IPC_NOWAIT};   
149.     int semval;   
150.         if(member<0 || member>(get_member_count(sid)-1))   
151.     {   
152.         fprintf(stderr,"Semaphore member %d out of range/n",member);   
153.         return;   
154.   
155.     }   
156.   
157.     /*Is the semaphore set locked? */  
158.   
159.     semval =getval(sid, member);   
160.     if(semval==SEM_REOURSE_MAX){   
161.   
162.         fprintf(stderr, "Semaphore not locked!/n");   
163.         exit(1);    
164.   
165.     }   
166.   
167.     sem_unlock.sem_num = member;   
168.   
169.     /*Attempt to lock the semaphore set*/  
170.         if((semop(sid, &sem_unlock, 1))==-1)   
171.     {   
172.         fprintf(stderr, "Unlock failed/n");   
173.         exit   
174.   
175.     }   
176.     else  
177.         printf("Semaphore resources incremented by one(unlocked)/n");   
178.         dispval(sid, member);   
179.   
180.   
181. }   
182.   
183.   
184. void removesem(int sid)   
185. {   
186.     semctl(sid, 0, IPC_RMID,0);   
187.     print("Semaphore removed/n");   
188.   
189. }   
190.   
191. unsigned short get_member_count(int sid)   
192. {   
193.   
194.     union  semum semopts;   
195.     struct semid_ds mysemds;   
196.        
197.     semopts.buf= &mysemds;   
198.     /*Return number of member in the semaphore set*/  
199.     int rc;   
200.     if((rc=semctl(sid, 0, IPC_STAT, semopts))==-1)   
201.     {   
202.         perror("semctl");   
203.         return(-1)   
204.     }   
205.        
206.     return(semopts.buf->sem_nsems);   
207.   
208. }   
209.   
210. int getval(int sid, int member)   
211. {   
212.     int semval;   
213.     semval= semctl(sid, member,GETVAL, 0)   
214.     reval semval;   
215.   
216. }   
217.   
218. void changemode(int sid, char *mode)   
219. {   
220.     int rc;   
221.     union semun semopts;   
222.     struct semid_ds mysemds;   
223.        
224.     /*Get current values for internal data structure */  
225.   
226.     semopts.buf=&mysemds;   
227.     rc = semctl(sid, 0, IPC_STAT, semopts);   
228.     if(rc ==-1)   
229.     {   
230.         perror("semctl");   
231.         exit(1);   
232.   
233.     }   
234.   
235.     printf("Old permission were %o/n", semopts.buf->perm.mode);   
236.   
237.     /* Change the permission on the semaphore */  
238.     sscanf(mode,"%ho",&semopts.buf->sem_perm.mode);   
239.   
240.     /*Update the internal data structure */  
241.     semctl(sid,0, IPC_SET, semopts);   
242.        
243.     printf("Updated....../n");   
244.   
245.   
246. }   
247.   
248. void dispval(int sid, int member)   
249. {   
250.     int semval;   
251.     semval= semctl(sid, member, GETVAL,0);   
252.     printf("semval for member %d is %d/n", member ,semval);   
253.   
254.   
255.   
256. }   
257.   
258.   
259.   
260. void usage(void)   
261. {   
262.     fprintf(stderr, "semtool -Autility for thinking with semaphores/n");   
263.     fprintf(stderr, "/nUSAGE:  semtool (c)reate <semcount>/n");   
264.     fprintf(stderr, "                  (l)ock <sem #>/n");   
265.         fprintf(stderr, "                  (u)nlock <sem #>/n");   
266.     fprintf(stderr, "                  (d)elete/n");   
267.     fprintf(stderr, "                  (m)ode <mode>/n");   
268.     exit(1);   
269.   
270. }