Repository navigation
Expand file tree
/
Copy pathsemaph.c
More file actions
291 lines (242 loc) · 8.18 KB
/
Copy pathsemaph.c
File metadata and controls
291 lines (242 loc) · 8.18 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
/*
* Provide an simpler and easier to understand interface to the System V
* semaphore system calls. There are 7 routines available to the user:
*
* id = sem_create(key, initval); # create with initial value or open
* id = sem_open(key); # open (must already exist)
* sem_wait(id); # wait = P = down by 1
* sem_signal(id); # signal = V = up by 1
* sem_op(id, amount); # wait if (amount < 0)
* # signal if (amount > 0)
* sem_close(id); # close
* sem_rm(id); # remove (delete)
*
* We create and use a 3-member set for the requested semaphore.
* The first member, [0], is the actual semaphore value, and the second
* member, [1], is a counter used to know when all processes have finished
* with the semaphore. The counter is initialized to a large number,
* decremented on every create or open and incremented on every close.
* This way we can use the "adjust" feature provided by System V so that
* any process that exit's without calling sem_close() is accounted
* for. It doesn't help us if the last process does this (as we have
* no way of getting control to remove the semaphore) but it will
* work if any process other than the last does an exit (intentional
* or unintentional).
* The third member, [2], of the semaphore set is used as a lock variable
* to avoid any race conditions in the sem_create() and sem_close()
* functions.
*/
#include "apue.h"
#include <sys/ipc.h>
#include <sys/sem.h>
#include <errno.h>
void sem_op(int, int);
int sem_create(key_t, int);
int sem_open(key_t);
void sem_rm(int);
void sem_close(int);
void sem_wait(int);
void sem_signal(int);
#define BIGCOUNT 10000 /* initial value of process counter */
/*
* Define the semaphore operation arrays for the semop() calls.
*/
static struct sembuf op_lock[2] = {
{2, 0, 0}, /* wait for [2] (lock) to equal 0 */
{2, 1, SEM_UNDO} /* then increment [2] to 1 - this locks it */
/* UNDO to release the lock if processes exits
before explicitly unlocking */
};
static struct sembuf op_endcreate[2] = {
{1, -1, SEM_UNDO},/* decrement [1] (proc counter) with undo on exit */
/* UNDO to adjust proc counter if process exits
before explicitly calling sem_close() */
{2, -1, SEM_UNDO} /* then decrement [2] (lock) back to 0 */
};
static struct sembuf op_open[1] = {
{1, -1, SEM_UNDO} /* decrement [1] (proc counter) with undo on exit */
};
static struct sembuf op_close[3] = {
{2, 0, 0}, /* wait for [2] (lock) to equal 0 */
{2, 1, SEM_UNDO}, /* then increment [2] to 1 - this locks it */
{1, 1, SEM_UNDO} /* then increment [1] (proc counter) */
};
static struct sembuf op_unlock[1] = {
{2, -1, SEM_UNDO} /* decrement [2] (lock) back to 0 */
};
static struct sembuf op_op[1] = {
{0, 99, SEM_UNDO} /* decrement or increment [0] with undo on exit */
/* the 99 is set to the actual amount to add
or subtract (positive or negative) */
};
/****************************************************************************
* Create a semaphore with a specified initial value.
* If the semaphore already exists, we don't initialize it (of course).
* We return the semaphore ID if all OK, else -1.
*/
int
sem_create(key_t key, int initval)
{
register int id, semval;
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
} semctl_arg;
if (key == IPC_PRIVATE)
return(-1); /* not intended for private semaphores */
else if (key == (key_t) -1)
return(-1); /* probably an ftok() error by caller */
again:
if ((id = semget(key, 3, 0666 | IPC_CREAT)) < 0)
return(-1); /* permission problem or tables full */
/*
* When the semaphore is created, we know that the value of all
* 3 members is 0.
* Get a lock on the semaphore by waiting for [2] to equal 0,
* then increment it.
*
* There is a race condition here. There is a possibility that
* between the semget() above and the semop() below, another
* process can call our sem_close() function which can remove
* the semaphore if that process is the last one using it.
* Therefore, we handle the error condition of an invalid
* semaphore ID specially below, and if it does happen, we just
* go back and create it again.
*/
if (semop(id, &op_lock[0], 2) < 0) {
if (errno == EINVAL)
goto again;
err_sys("can't lock");
}
/*
* Get the value of the process counter. If it equals 0,
* then no one has initialized the semaphore yet.
*/
if ((semval = semctl(id, 1, GETVAL, 0)) < 0)
err_sys("can't GETVAL");
if (semval == 0) {
/*
* We could initialize by doing a SETALL, but that
* would clear the adjust value that we set when we
* locked the semaphore above. Instead, we'll do 2
* system calls to initialize [0] and [1].
*/
semctl_arg.val = initval;
if (semctl(id, 0, SETVAL, semctl_arg) < 0)
err_sys("can SETVAL[0]");
semctl_arg.val = BIGCOUNT;
if (semctl(id, 1, SETVAL, semctl_arg) < 0)
err_sys("can SETVAL[1]");
}
/*
* Decrement the process counter and then release the lock.
*/
if (semop(id, &op_endcreate[0], 2) < 0)
err_sys("can't end create");
return(id);
}
/****************************************************************************
* Open a semaphore that must already exist.
* This function should be used, instead of sem_create(), if the caller
* knows that the semaphore must already exist. For example a client
* from a client-server pair would use this, if its the server's
* responsibility to create the semaphore.
* We return the semaphore ID if all OK, else -1.
*/
int
sem_open(key_t key)
{
register int id;
if (key == IPC_PRIVATE)
return(-1); /* not intended for private semaphores */
else if (key == (key_t) -1)
return(-1); /* probably an ftok() error by caller */
if ((id = semget(key, 3, 0)) < 0)
return(-1); /* doesn't exist, or tables full */
/*
* Decrement the process counter. We don't need a lock
* to do this.
*/
if (semop(id, &op_open[0], 1) < 0)
err_sys("can't open");
return(id);
}
/****************************************************************************
* Remove a semaphore.
* This call is intended to be called by a server, for example,
* when it is being shut down, as we do an IPC_RMID on the semaphore,
* regardless whether other processes may be using it or not.
* Most other processes should use sem_close() below.
*/
void
sem_rm(int id)
{
if (semctl(id, 0, IPC_RMID, 0) < 0)
err_sys("can't IPC_RMID");
}
/****************************************************************************
* Close a semaphore.
* Unlike the remove function above, this function is for a process
* to call before it exits, when it is done with the semaphore.
* We "decrement" the counter of processes using the semaphore, and
* if this was the last one, we can remove the semaphore.
*/
void
sem_close(int id)
{
register int semval;
/*
* The following semop() first gets a lock on the semaphore,
* then increments [1] - the process counter.
*/
if (semop(id, &op_close[0], 3) < 0)
err_sys("can't semop");
/*
* Now that we have a lock, read the value of the process
* counter to see if this is the last reference to the
* semaphore.
* There is a race condition here - see the comments in
* sem_create().
*/
if ((semval = semctl(id, 1, GETVAL, 0)) < 0)
err_sys("can't GETVAL");
if (semval > BIGCOUNT)
err_dump("sem[1] > BIGCOUNT");
else if (semval == BIGCOUNT)
sem_rm(id);
else
if (semop(id, &op_unlock[0], 1) < 0)
err_sys("can't unlock"); /* unlock */
}
/****************************************************************************
* Wait until a semaphore's value is greater than 0, then decrement
* it by 1 and return.
* Dijkstra's P operation. Tanenbaum's DOWN operation.
*/
void
sem_wait(int id)
{
sem_op(id, -1);
}
/****************************************************************************
* Increment a semaphore by 1.
* Dijkstra's V operation. Tanenbaum's UP operation.
*/
void
sem_signal(int id)
{
sem_op(id, 1);
}
/****************************************************************************
* General semaphore operation. Increment or decrement by a user-specified
* amount (positive or negative; amount can't be zero).
*/
void
sem_op(int id, int value)
{
if ((op_op[0].sem_op = value) == 0)
err_sys("can't have value == 0");
if (semop(id, &op_op[0], 1) < 0)
err_sys("sem_op error");
}