sysv_sem.c revision 1.49 1 1.49 jdolecek /* $NetBSD: sysv_sem.c,v 1.49 2003/11/29 11:43:25 jdolecek Exp $ */
2 1.33 thorpej
3 1.33 thorpej /*-
4 1.33 thorpej * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 1.33 thorpej * All rights reserved.
6 1.33 thorpej *
7 1.33 thorpej * This code is derived from software contributed to The NetBSD Foundation
8 1.33 thorpej * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 1.33 thorpej * NASA Ames Research Center.
10 1.33 thorpej *
11 1.33 thorpej * Redistribution and use in source and binary forms, with or without
12 1.33 thorpej * modification, are permitted provided that the following conditions
13 1.33 thorpej * are met:
14 1.33 thorpej * 1. Redistributions of source code must retain the above copyright
15 1.33 thorpej * notice, this list of conditions and the following disclaimer.
16 1.33 thorpej * 2. Redistributions in binary form must reproduce the above copyright
17 1.33 thorpej * notice, this list of conditions and the following disclaimer in the
18 1.33 thorpej * documentation and/or other materials provided with the distribution.
19 1.33 thorpej * 3. All advertising materials mentioning features or use of this software
20 1.33 thorpej * must display the following acknowledgement:
21 1.33 thorpej * This product includes software developed by the NetBSD
22 1.33 thorpej * Foundation, Inc. and its contributors.
23 1.33 thorpej * 4. Neither the name of The NetBSD Foundation nor the names of its
24 1.33 thorpej * contributors may be used to endorse or promote products derived
25 1.33 thorpej * from this software without specific prior written permission.
26 1.33 thorpej *
27 1.33 thorpej * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 1.33 thorpej * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 1.33 thorpej * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 1.33 thorpej * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 1.33 thorpej * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 1.33 thorpej * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 1.33 thorpej * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 1.33 thorpej * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 1.33 thorpej * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 1.33 thorpej * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 1.33 thorpej * POSSIBILITY OF SUCH DAMAGE.
38 1.33 thorpej */
39 1.9 cgd
40 1.1 cgd /*
41 1.1 cgd * Implementation of SVID semaphores
42 1.1 cgd *
43 1.33 thorpej * Author: Daniel Boulet
44 1.1 cgd *
45 1.1 cgd * This software is provided ``AS IS'' without any warranties of any kind.
46 1.1 cgd */
47 1.42 lukem
48 1.42 lukem #include <sys/cdefs.h>
49 1.49 jdolecek __KERNEL_RCSID(0, "$NetBSD: sysv_sem.c,v 1.49 2003/11/29 11:43:25 jdolecek Exp $");
50 1.31 tron
51 1.32 tron #define SYSVSEM
52 1.1 cgd
53 1.3 mycroft #include <sys/param.h>
54 1.3 mycroft #include <sys/kernel.h>
55 1.3 mycroft #include <sys/sem.h>
56 1.38 simonb #include <sys/sysctl.h>
57 1.38 simonb #include <sys/mount.h> /* XXX for <sys/syscallargs.h> */
58 1.45 thorpej #include <sys/sa.h>
59 1.10 cgd #include <sys/syscallargs.h>
60 1.25 christos
61 1.48 jdolecek static int semtot = 0;
62 1.48 jdolecek struct semid_ds *sema; /* semaphore id pool */
63 1.48 jdolecek static struct __sem *sem; /* semaphore pool */
64 1.48 jdolecek static struct sem_undo *semu_list; /* list of active undo structures */
65 1.48 jdolecek static int *semu; /* undo structure pool */
66 1.1 cgd
67 1.27 christos #ifdef SEM_DEBUG
68 1.28 christos #define SEM_PRINTF(a) printf a
69 1.27 christos #else
70 1.27 christos #define SEM_PRINTF(a)
71 1.27 christos #endif
72 1.27 christos
73 1.25 christos struct sem_undo *semu_alloc __P((struct proc *));
74 1.25 christos int semundo_adjust __P((struct proc *, struct sem_undo **, int, int, int));
75 1.25 christos void semundo_clear __P((int, int));
76 1.25 christos
77 1.37 sommerfe /*
78 1.37 sommerfe * XXXSMP Once we go MP, there needs to be a lock for the semaphore system.
79 1.37 sommerfe * Until then, we're saved by being a non-preemptive kernel.
80 1.37 sommerfe */
81 1.37 sommerfe
82 1.25 christos void
83 1.1 cgd seminit()
84 1.1 cgd {
85 1.48 jdolecek int i, sz;
86 1.48 jdolecek vaddr_t v;
87 1.1 cgd
88 1.48 jdolecek /* Allocate pageable memory for our structures */
89 1.48 jdolecek sz = seminfo.semmni * sizeof(struct semid_ds)
90 1.48 jdolecek + seminfo.semmns * sizeof(struct __sem)
91 1.48 jdolecek + seminfo.semmnu * seminfo.semusz;
92 1.48 jdolecek if ((v = uvm_km_zalloc(kernel_map, round_page(sz))) == 0)
93 1.48 jdolecek panic("sysv_sem: cannot allocate memory");
94 1.48 jdolecek sema = (void *)v;
95 1.48 jdolecek sem = (void *)(sema + seminfo.semmni);
96 1.48 jdolecek semu = (void *)(sem + seminfo.semmns);
97 1.5 mycroft
98 1.5 mycroft for (i = 0; i < seminfo.semmni; i++) {
99 1.33 thorpej sema[i]._sem_base = 0;
100 1.5 mycroft sema[i].sem_perm.mode = 0;
101 1.5 mycroft }
102 1.5 mycroft for (i = 0; i < seminfo.semmnu; i++) {
103 1.35 augustss struct sem_undo *suptr = SEMU(i);
104 1.5 mycroft suptr->un_proc = NULL;
105 1.5 mycroft }
106 1.5 mycroft semu_list = NULL;
107 1.44 christos exithook_establish(semexit, NULL);
108 1.1 cgd }
109 1.1 cgd
110 1.1 cgd /*
111 1.37 sommerfe * Placebo.
112 1.1 cgd */
113 1.1 cgd
114 1.1 cgd int
115 1.45 thorpej sys_semconfig(l, v, retval)
116 1.45 thorpej struct lwp *l;
117 1.23 thorpej void *v;
118 1.23 thorpej register_t *retval;
119 1.23 thorpej {
120 1.5 mycroft *retval = 0;
121 1.37 sommerfe return 0;
122 1.1 cgd }
123 1.1 cgd
124 1.1 cgd /*
125 1.1 cgd * Allocate a new sem_undo structure for a process
126 1.1 cgd * (returns ptr to structure or NULL if no more room)
127 1.1 cgd */
128 1.1 cgd
129 1.1 cgd struct sem_undo *
130 1.5 mycroft semu_alloc(p)
131 1.5 mycroft struct proc *p;
132 1.1 cgd {
133 1.35 augustss int i;
134 1.35 augustss struct sem_undo *suptr;
135 1.35 augustss struct sem_undo **supptr;
136 1.5 mycroft int attempt;
137 1.1 cgd
138 1.1 cgd /*
139 1.5 mycroft * Try twice to allocate something.
140 1.5 mycroft * (we'll purge any empty structures after the first pass so
141 1.5 mycroft * two passes are always enough)
142 1.1 cgd */
143 1.1 cgd
144 1.5 mycroft for (attempt = 0; attempt < 2; attempt++) {
145 1.5 mycroft /*
146 1.5 mycroft * Look for a free structure.
147 1.5 mycroft * Fill it in and return it if we find one.
148 1.5 mycroft */
149 1.5 mycroft
150 1.5 mycroft for (i = 0; i < seminfo.semmnu; i++) {
151 1.5 mycroft suptr = SEMU(i);
152 1.5 mycroft if (suptr->un_proc == NULL) {
153 1.5 mycroft suptr->un_next = semu_list;
154 1.5 mycroft semu_list = suptr;
155 1.5 mycroft suptr->un_cnt = 0;
156 1.5 mycroft suptr->un_proc = p;
157 1.5 mycroft return(suptr);
158 1.5 mycroft }
159 1.5 mycroft }
160 1.1 cgd
161 1.5 mycroft /*
162 1.5 mycroft * We didn't find a free one, if this is the first attempt
163 1.5 mycroft * then try to free some structures.
164 1.5 mycroft */
165 1.5 mycroft
166 1.5 mycroft if (attempt == 0) {
167 1.5 mycroft /* All the structures are in use - try to free some */
168 1.5 mycroft int did_something = 0;
169 1.5 mycroft
170 1.5 mycroft supptr = &semu_list;
171 1.5 mycroft while ((suptr = *supptr) != NULL) {
172 1.5 mycroft if (suptr->un_cnt == 0) {
173 1.5 mycroft suptr->un_proc = NULL;
174 1.5 mycroft *supptr = suptr->un_next;
175 1.5 mycroft did_something = 1;
176 1.5 mycroft } else
177 1.5 mycroft supptr = &(suptr->un_next);
178 1.5 mycroft }
179 1.5 mycroft
180 1.5 mycroft /* If we didn't free anything then just give-up */
181 1.5 mycroft if (!did_something)
182 1.5 mycroft return(NULL);
183 1.5 mycroft } else {
184 1.5 mycroft /*
185 1.5 mycroft * The second pass failed even though we freed
186 1.5 mycroft * something after the first pass!
187 1.5 mycroft * This is IMPOSSIBLE!
188 1.5 mycroft */
189 1.5 mycroft panic("semu_alloc - second attempt failed");
190 1.5 mycroft }
191 1.1 cgd }
192 1.25 christos return NULL;
193 1.1 cgd }
194 1.1 cgd
195 1.1 cgd /*
196 1.1 cgd * Adjust a particular entry for a particular proc
197 1.1 cgd */
198 1.1 cgd
199 1.1 cgd int
200 1.5 mycroft semundo_adjust(p, supptr, semid, semnum, adjval)
201 1.35 augustss struct proc *p;
202 1.5 mycroft struct sem_undo **supptr;
203 1.5 mycroft int semid, semnum;
204 1.5 mycroft int adjval;
205 1.1 cgd {
206 1.35 augustss struct sem_undo *suptr;
207 1.35 augustss struct undo *sunptr;
208 1.5 mycroft int i;
209 1.1 cgd
210 1.5 mycroft /* Look for and remember the sem_undo if the caller doesn't provide
211 1.5 mycroft it */
212 1.1 cgd
213 1.5 mycroft suptr = *supptr;
214 1.4 mycroft if (suptr == NULL) {
215 1.11 mycroft for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) {
216 1.5 mycroft if (suptr->un_proc == p) {
217 1.5 mycroft *supptr = suptr;
218 1.5 mycroft break;
219 1.5 mycroft }
220 1.5 mycroft }
221 1.5 mycroft if (suptr == NULL) {
222 1.5 mycroft if (adjval == 0)
223 1.5 mycroft return(0);
224 1.5 mycroft suptr = semu_alloc(p);
225 1.5 mycroft if (suptr == NULL)
226 1.5 mycroft return(ENOSPC);
227 1.5 mycroft *supptr = suptr;
228 1.5 mycroft }
229 1.1 cgd }
230 1.1 cgd
231 1.6 mycroft /*
232 1.6 mycroft * Look for the requested entry and adjust it (delete if adjval becomes
233 1.6 mycroft * 0).
234 1.6 mycroft */
235 1.6 mycroft sunptr = &suptr->un_ent[0];
236 1.5 mycroft for (i = 0; i < suptr->un_cnt; i++, sunptr++) {
237 1.6 mycroft if (sunptr->un_id != semid || sunptr->un_num != semnum)
238 1.6 mycroft continue;
239 1.6 mycroft if (adjval == 0)
240 1.6 mycroft sunptr->un_adjval = 0;
241 1.6 mycroft else
242 1.6 mycroft sunptr->un_adjval += adjval;
243 1.6 mycroft if (sunptr->un_adjval == 0) {
244 1.6 mycroft suptr->un_cnt--;
245 1.6 mycroft if (i < suptr->un_cnt)
246 1.6 mycroft suptr->un_ent[i] =
247 1.6 mycroft suptr->un_ent[suptr->un_cnt];
248 1.5 mycroft }
249 1.6 mycroft return(0);
250 1.1 cgd }
251 1.1 cgd
252 1.5 mycroft /* Didn't find the right entry - create it */
253 1.5 mycroft if (adjval == 0)
254 1.5 mycroft return(0);
255 1.11 mycroft if (suptr->un_cnt == SEMUME)
256 1.5 mycroft return(EINVAL);
257 1.11 mycroft
258 1.11 mycroft sunptr = &suptr->un_ent[suptr->un_cnt];
259 1.11 mycroft suptr->un_cnt++;
260 1.11 mycroft sunptr->un_adjval = adjval;
261 1.11 mycroft sunptr->un_id = semid;
262 1.11 mycroft sunptr->un_num = semnum;
263 1.1 cgd return(0);
264 1.1 cgd }
265 1.1 cgd
266 1.1 cgd void
267 1.5 mycroft semundo_clear(semid, semnum)
268 1.5 mycroft int semid, semnum;
269 1.1 cgd {
270 1.35 augustss struct sem_undo *suptr;
271 1.1 cgd
272 1.6 mycroft for (suptr = semu_list; suptr != NULL; suptr = suptr->un_next) {
273 1.35 augustss struct undo *sunptr;
274 1.35 augustss int i;
275 1.6 mycroft
276 1.19 mycroft sunptr = &suptr->un_ent[0];
277 1.19 mycroft for (i = 0; i < suptr->un_cnt; i++, sunptr++) {
278 1.6 mycroft if (sunptr->un_id == semid) {
279 1.6 mycroft if (semnum == -1 || sunptr->un_num == semnum) {
280 1.6 mycroft suptr->un_cnt--;
281 1.6 mycroft if (i < suptr->un_cnt) {
282 1.6 mycroft suptr->un_ent[i] =
283 1.6 mycroft suptr->un_ent[suptr->un_cnt];
284 1.19 mycroft i--, sunptr--;
285 1.6 mycroft }
286 1.6 mycroft }
287 1.6 mycroft if (semnum != -1)
288 1.6 mycroft break;
289 1.6 mycroft }
290 1.6 mycroft }
291 1.1 cgd }
292 1.1 cgd }
293 1.1 cgd
294 1.1 cgd int
295 1.45 thorpej sys_____semctl13(l, v, retval)
296 1.45 thorpej struct lwp *l;
297 1.33 thorpej void *v;
298 1.23 thorpej register_t *retval;
299 1.23 thorpej {
300 1.34 christos struct sys_____semctl13_args /* {
301 1.10 cgd syscallarg(int) semid;
302 1.10 cgd syscallarg(int) semnum;
303 1.10 cgd syscallarg(int) cmd;
304 1.34 christos syscallarg(union __semun *) arg;
305 1.23 thorpej } */ *uap = v;
306 1.45 thorpej struct proc *p = l->l_proc;
307 1.33 thorpej struct semid_ds sembuf;
308 1.33 thorpej int cmd, error;
309 1.34 christos void *pass_arg;
310 1.34 christos union __semun karg;
311 1.33 thorpej
312 1.33 thorpej cmd = SCARG(uap, cmd);
313 1.33 thorpej
314 1.33 thorpej switch (cmd) {
315 1.33 thorpej case IPC_SET:
316 1.33 thorpej case IPC_STAT:
317 1.33 thorpej pass_arg = &sembuf;
318 1.33 thorpej break;
319 1.33 thorpej
320 1.33 thorpej case GETALL:
321 1.33 thorpej case SETVAL:
322 1.33 thorpej case SETALL:
323 1.34 christos pass_arg = &karg;
324 1.34 christos break;
325 1.34 christos default:
326 1.34 christos pass_arg = NULL;
327 1.33 thorpej break;
328 1.33 thorpej }
329 1.33 thorpej
330 1.34 christos if (pass_arg) {
331 1.34 christos error = copyin(SCARG(uap, arg), &karg, sizeof(karg));
332 1.33 thorpej if (error)
333 1.34 christos return error;
334 1.34 christos if (cmd == IPC_SET) {
335 1.34 christos error = copyin(karg.buf, &sembuf, sizeof(sembuf));
336 1.34 christos if (error)
337 1.34 christos return (error);
338 1.34 christos }
339 1.33 thorpej }
340 1.33 thorpej
341 1.33 thorpej error = semctl1(p, SCARG(uap, semid), SCARG(uap, semnum), cmd,
342 1.33 thorpej pass_arg, retval);
343 1.33 thorpej
344 1.33 thorpej if (error == 0 && cmd == IPC_STAT)
345 1.34 christos error = copyout(&sembuf, karg.buf, sizeof(sembuf));
346 1.33 thorpej
347 1.33 thorpej return (error);
348 1.33 thorpej }
349 1.33 thorpej
350 1.33 thorpej int
351 1.33 thorpej semctl1(p, semid, semnum, cmd, v, retval)
352 1.33 thorpej struct proc *p;
353 1.33 thorpej int semid, semnum, cmd;
354 1.33 thorpej void *v;
355 1.33 thorpej register_t *retval;
356 1.33 thorpej {
357 1.6 mycroft struct ucred *cred = p->p_ucred;
358 1.33 thorpej union __semun *arg = v;
359 1.33 thorpej struct semid_ds *sembuf = v, *semaptr;
360 1.33 thorpej int i, error, ix;
361 1.1 cgd
362 1.27 christos SEM_PRINTF(("call to semctl(%d, %d, %d, %p)\n",
363 1.33 thorpej semid, semnum, cmd, v));
364 1.1 cgd
365 1.33 thorpej ix = IPCID_TO_IX(semid);
366 1.49 jdolecek if (ix < 0 || ix >= seminfo.semmni)
367 1.33 thorpej return (EINVAL);
368 1.6 mycroft
369 1.33 thorpej semaptr = &sema[ix];
370 1.6 mycroft if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
371 1.33 thorpej semaptr->sem_perm._seq != IPCID_TO_SEQ(semid))
372 1.33 thorpej return (EINVAL);
373 1.1 cgd
374 1.6 mycroft switch (cmd) {
375 1.6 mycroft case IPC_RMID:
376 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)) != 0)
377 1.33 thorpej return (error);
378 1.6 mycroft semaptr->sem_perm.cuid = cred->cr_uid;
379 1.6 mycroft semaptr->sem_perm.uid = cred->cr_uid;
380 1.6 mycroft semtot -= semaptr->sem_nsems;
381 1.33 thorpej for (i = semaptr->_sem_base - sem; i < semtot; i++)
382 1.6 mycroft sem[i] = sem[i + semaptr->sem_nsems];
383 1.6 mycroft for (i = 0; i < seminfo.semmni; i++) {
384 1.6 mycroft if ((sema[i].sem_perm.mode & SEM_ALLOC) &&
385 1.33 thorpej sema[i]._sem_base > semaptr->_sem_base)
386 1.33 thorpej sema[i]._sem_base -= semaptr->sem_nsems;
387 1.6 mycroft }
388 1.6 mycroft semaptr->sem_perm.mode = 0;
389 1.33 thorpej semundo_clear(ix, -1);
390 1.33 thorpej wakeup(semaptr);
391 1.6 mycroft break;
392 1.1 cgd
393 1.6 mycroft case IPC_SET:
394 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_M)))
395 1.33 thorpej return (error);
396 1.33 thorpej semaptr->sem_perm.uid = sembuf->sem_perm.uid;
397 1.33 thorpej semaptr->sem_perm.gid = sembuf->sem_perm.gid;
398 1.6 mycroft semaptr->sem_perm.mode = (semaptr->sem_perm.mode & ~0777) |
399 1.33 thorpej (sembuf->sem_perm.mode & 0777);
400 1.6 mycroft semaptr->sem_ctime = time.tv_sec;
401 1.6 mycroft break;
402 1.1 cgd
403 1.6 mycroft case IPC_STAT:
404 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
405 1.33 thorpej return (error);
406 1.33 thorpej memcpy(sembuf, semaptr, sizeof(struct semid_ds));
407 1.6 mycroft break;
408 1.1 cgd
409 1.6 mycroft case GETNCNT:
410 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
411 1.33 thorpej return (error);
412 1.6 mycroft if (semnum < 0 || semnum >= semaptr->sem_nsems)
413 1.33 thorpej return (EINVAL);
414 1.33 thorpej *retval = semaptr->_sem_base[semnum].semncnt;
415 1.6 mycroft break;
416 1.1 cgd
417 1.6 mycroft case GETPID:
418 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
419 1.33 thorpej return (error);
420 1.6 mycroft if (semnum < 0 || semnum >= semaptr->sem_nsems)
421 1.33 thorpej return (EINVAL);
422 1.33 thorpej *retval = semaptr->_sem_base[semnum].sempid;
423 1.6 mycroft break;
424 1.1 cgd
425 1.6 mycroft case GETVAL:
426 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
427 1.33 thorpej return (error);
428 1.6 mycroft if (semnum < 0 || semnum >= semaptr->sem_nsems)
429 1.33 thorpej return (EINVAL);
430 1.33 thorpej *retval = semaptr->_sem_base[semnum].semval;
431 1.6 mycroft break;
432 1.1 cgd
433 1.6 mycroft case GETALL:
434 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
435 1.33 thorpej return (error);
436 1.6 mycroft for (i = 0; i < semaptr->sem_nsems; i++) {
437 1.33 thorpej error = copyout(&semaptr->_sem_base[i].semval,
438 1.33 thorpej &arg->array[i], sizeof(arg->array[i]));
439 1.33 thorpej if (error != 0)
440 1.6 mycroft break;
441 1.6 mycroft }
442 1.6 mycroft break;
443 1.1 cgd
444 1.6 mycroft case GETZCNT:
445 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_R)))
446 1.33 thorpej return (error);
447 1.6 mycroft if (semnum < 0 || semnum >= semaptr->sem_nsems)
448 1.33 thorpej return (EINVAL);
449 1.33 thorpej *retval = semaptr->_sem_base[semnum].semzcnt;
450 1.6 mycroft break;
451 1.1 cgd
452 1.6 mycroft case SETVAL:
453 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
454 1.33 thorpej return (error);
455 1.6 mycroft if (semnum < 0 || semnum >= semaptr->sem_nsems)
456 1.33 thorpej return (EINVAL);
457 1.33 thorpej semaptr->_sem_base[semnum].semval = arg->val;
458 1.33 thorpej semundo_clear(ix, semnum);
459 1.33 thorpej wakeup(semaptr);
460 1.6 mycroft break;
461 1.1 cgd
462 1.6 mycroft case SETALL:
463 1.33 thorpej if ((error = ipcperm(cred, &semaptr->sem_perm, IPC_W)))
464 1.33 thorpej return (error);
465 1.6 mycroft for (i = 0; i < semaptr->sem_nsems; i++) {
466 1.33 thorpej error = copyin(&arg->array[i],
467 1.33 thorpej &semaptr->_sem_base[i].semval,
468 1.33 thorpej sizeof(arg->array[i]));
469 1.33 thorpej if (error != 0)
470 1.6 mycroft break;
471 1.6 mycroft }
472 1.33 thorpej semundo_clear(ix, -1);
473 1.33 thorpej wakeup(semaptr);
474 1.6 mycroft break;
475 1.1 cgd
476 1.6 mycroft default:
477 1.33 thorpej return (EINVAL);
478 1.6 mycroft }
479 1.4 mycroft
480 1.33 thorpej return (error);
481 1.1 cgd }
482 1.1 cgd
483 1.1 cgd int
484 1.45 thorpej sys_semget(l, v, retval)
485 1.45 thorpej struct lwp *l;
486 1.23 thorpej void *v;
487 1.23 thorpej register_t *retval;
488 1.23 thorpej {
489 1.35 augustss struct sys_semget_args /* {
490 1.10 cgd syscallarg(key_t) key;
491 1.10 cgd syscallarg(int) nsems;
492 1.10 cgd syscallarg(int) semflg;
493 1.23 thorpej } */ *uap = v;
494 1.6 mycroft int semid, eval;
495 1.10 cgd int key = SCARG(uap, key);
496 1.10 cgd int nsems = SCARG(uap, nsems);
497 1.10 cgd int semflg = SCARG(uap, semflg);
498 1.45 thorpej struct ucred *cred = l->l_proc->p_ucred;
499 1.1 cgd
500 1.27 christos SEM_PRINTF(("semget(0x%x, %d, 0%o)\n", key, nsems, semflg));
501 1.1 cgd
502 1.6 mycroft if (key != IPC_PRIVATE) {
503 1.6 mycroft for (semid = 0; semid < seminfo.semmni; semid++) {
504 1.6 mycroft if ((sema[semid].sem_perm.mode & SEM_ALLOC) &&
505 1.33 thorpej sema[semid].sem_perm._key == key)
506 1.6 mycroft break;
507 1.6 mycroft }
508 1.6 mycroft if (semid < seminfo.semmni) {
509 1.27 christos SEM_PRINTF(("found public key\n"));
510 1.7 hpeyerl if ((eval = ipcperm(cred, &sema[semid].sem_perm,
511 1.7 hpeyerl semflg & 0700)))
512 1.6 mycroft return(eval);
513 1.6 mycroft if (nsems > 0 && sema[semid].sem_nsems < nsems) {
514 1.27 christos SEM_PRINTF(("too small\n"));
515 1.6 mycroft return(EINVAL);
516 1.6 mycroft }
517 1.6 mycroft if ((semflg & IPC_CREAT) && (semflg & IPC_EXCL)) {
518 1.27 christos SEM_PRINTF(("not exclusive\n"));
519 1.6 mycroft return(EEXIST);
520 1.6 mycroft }
521 1.6 mycroft goto found;
522 1.6 mycroft }
523 1.6 mycroft }
524 1.6 mycroft
525 1.27 christos SEM_PRINTF(("need to allocate the semid_ds\n"));
526 1.6 mycroft if (key == IPC_PRIVATE || (semflg & IPC_CREAT)) {
527 1.6 mycroft if (nsems <= 0 || nsems > seminfo.semmsl) {
528 1.27 christos SEM_PRINTF(("nsems out of range (0<%d<=%d)\n", nsems,
529 1.27 christos seminfo.semmsl));
530 1.6 mycroft return(EINVAL);
531 1.6 mycroft }
532 1.6 mycroft if (nsems > seminfo.semmns - semtot) {
533 1.27 christos SEM_PRINTF(("not enough semaphores left (need %d, got %d)\n",
534 1.27 christos nsems, seminfo.semmns - semtot));
535 1.6 mycroft return(ENOSPC);
536 1.6 mycroft }
537 1.6 mycroft for (semid = 0; semid < seminfo.semmni; semid++) {
538 1.6 mycroft if ((sema[semid].sem_perm.mode & SEM_ALLOC) == 0)
539 1.6 mycroft break;
540 1.6 mycroft }
541 1.6 mycroft if (semid == seminfo.semmni) {
542 1.27 christos SEM_PRINTF(("no more semid_ds's available\n"));
543 1.6 mycroft return(ENOSPC);
544 1.6 mycroft }
545 1.27 christos SEM_PRINTF(("semid %d is available\n", semid));
546 1.33 thorpej sema[semid].sem_perm._key = key;
547 1.6 mycroft sema[semid].sem_perm.cuid = cred->cr_uid;
548 1.6 mycroft sema[semid].sem_perm.uid = cred->cr_uid;
549 1.6 mycroft sema[semid].sem_perm.cgid = cred->cr_gid;
550 1.6 mycroft sema[semid].sem_perm.gid = cred->cr_gid;
551 1.6 mycroft sema[semid].sem_perm.mode = (semflg & 0777) | SEM_ALLOC;
552 1.33 thorpej sema[semid].sem_perm._seq =
553 1.33 thorpej (sema[semid].sem_perm._seq + 1) & 0x7fff;
554 1.6 mycroft sema[semid].sem_nsems = nsems;
555 1.6 mycroft sema[semid].sem_otime = 0;
556 1.6 mycroft sema[semid].sem_ctime = time.tv_sec;
557 1.33 thorpej sema[semid]._sem_base = &sem[semtot];
558 1.6 mycroft semtot += nsems;
559 1.33 thorpej memset(sema[semid]._sem_base, 0,
560 1.33 thorpej sizeof(sema[semid]._sem_base[0])*nsems);
561 1.33 thorpej SEM_PRINTF(("sembase = %p, next = %p\n", sema[semid]._sem_base,
562 1.27 christos &sem[semtot]));
563 1.1 cgd } else {
564 1.27 christos SEM_PRINTF(("didn't find it and wasn't asked to create it\n"));
565 1.6 mycroft return(ENOENT);
566 1.1 cgd }
567 1.1 cgd
568 1.6 mycroft found:
569 1.6 mycroft *retval = IXSEQ_TO_IPCID(semid, sema[semid].sem_perm);
570 1.6 mycroft return(0);
571 1.1 cgd }
572 1.1 cgd
573 1.1 cgd int
574 1.45 thorpej sys_semop(l, v, retval)
575 1.45 thorpej struct lwp *l;
576 1.23 thorpej void *v;
577 1.23 thorpej register_t *retval;
578 1.23 thorpej {
579 1.35 augustss struct sys_semop_args /* {
580 1.10 cgd syscallarg(int) semid;
581 1.10 cgd syscallarg(struct sembuf *) sops;
582 1.29 kleink syscallarg(size_t) nsops;
583 1.23 thorpej } */ *uap = v;
584 1.45 thorpej struct proc *p = l->l_proc;
585 1.10 cgd int semid = SCARG(uap, semid);
586 1.41 jdolecek size_t nsops = SCARG(uap, nsops);
587 1.6 mycroft struct sembuf sops[MAX_SOPS];
588 1.35 augustss struct semid_ds *semaptr;
589 1.35 augustss struct sembuf *sopptr = NULL;
590 1.35 augustss struct __sem *semptr = NULL;
591 1.6 mycroft struct sem_undo *suptr = NULL;
592 1.6 mycroft struct ucred *cred = p->p_ucred;
593 1.6 mycroft int i, j, eval;
594 1.25 christos int do_wakeup, do_undos;
595 1.1 cgd
596 1.43 nathanw SEM_PRINTF(("call to semop(%d, %p, %lld)\n", semid, sops,
597 1.43 nathanw (long long)nsops));
598 1.1 cgd
599 1.6 mycroft semid = IPCID_TO_IX(semid); /* Convert back to zero origin */
600 1.49 jdolecek if (semid < 0 || semid >= seminfo.semmni)
601 1.6 mycroft return(EINVAL);
602 1.6 mycroft
603 1.6 mycroft semaptr = &sema[semid];
604 1.11 mycroft if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
605 1.33 thorpej semaptr->sem_perm._seq != IPCID_TO_SEQ(SCARG(uap, semid)))
606 1.6 mycroft return(EINVAL);
607 1.6 mycroft
608 1.7 hpeyerl if ((eval = ipcperm(cred, &semaptr->sem_perm, IPC_W))) {
609 1.27 christos SEM_PRINTF(("eval = %d from ipaccess\n", eval));
610 1.6 mycroft return(eval);
611 1.6 mycroft }
612 1.1 cgd
613 1.6 mycroft if (nsops > MAX_SOPS) {
614 1.43 nathanw SEM_PRINTF(("too many sops (max=%d, nsops=%lld)\n", MAX_SOPS,
615 1.43 nathanw (long long)nsops));
616 1.6 mycroft return(E2BIG);
617 1.6 mycroft }
618 1.1 cgd
619 1.10 cgd if ((eval = copyin(SCARG(uap, sops), sops, nsops * sizeof(sops[0])))
620 1.10 cgd != 0) {
621 1.43 nathanw SEM_PRINTF(("eval = %d from copyin(%p, %p, %lld)\n", eval,
622 1.43 nathanw SCARG(uap, sops), &sops,
623 1.43 nathanw (long long)(nsops * sizeof(sops[0]))));
624 1.6 mycroft return(eval);
625 1.6 mycroft }
626 1.1 cgd
627 1.6 mycroft /*
628 1.6 mycroft * Loop trying to satisfy the vector of requests.
629 1.6 mycroft * If we reach a point where we must wait, any requests already
630 1.6 mycroft * performed are rolled back and we go to sleep until some other
631 1.6 mycroft * process wakes us up. At this point, we start all over again.
632 1.6 mycroft *
633 1.6 mycroft * This ensures that from the perspective of other tasks, a set
634 1.6 mycroft * of requests is atomic (never partially satisfied).
635 1.6 mycroft */
636 1.6 mycroft do_undos = 0;
637 1.1 cgd
638 1.6 mycroft for (;;) {
639 1.6 mycroft do_wakeup = 0;
640 1.1 cgd
641 1.6 mycroft for (i = 0; i < nsops; i++) {
642 1.6 mycroft sopptr = &sops[i];
643 1.1 cgd
644 1.6 mycroft if (sopptr->sem_num >= semaptr->sem_nsems)
645 1.6 mycroft return(EFBIG);
646 1.1 cgd
647 1.33 thorpej semptr = &semaptr->_sem_base[sopptr->sem_num];
648 1.1 cgd
649 1.43 nathanw SEM_PRINTF(("semop: semaptr=%p, sem_base=%p, semptr=%p, sem[%d]=%d : op=%d, flag=%s\n",
650 1.33 thorpej semaptr, semaptr->_sem_base, semptr,
651 1.6 mycroft sopptr->sem_num, semptr->semval, sopptr->sem_op,
652 1.27 christos (sopptr->sem_flg & IPC_NOWAIT) ? "nowait" : "wait"));
653 1.1 cgd
654 1.6 mycroft if (sopptr->sem_op < 0) {
655 1.25 christos if ((int)(semptr->semval +
656 1.25 christos sopptr->sem_op) < 0) {
657 1.27 christos SEM_PRINTF(("semop: can't do it now\n"));
658 1.6 mycroft break;
659 1.6 mycroft } else {
660 1.6 mycroft semptr->semval += sopptr->sem_op;
661 1.6 mycroft if (semptr->semval == 0 &&
662 1.6 mycroft semptr->semzcnt > 0)
663 1.6 mycroft do_wakeup = 1;
664 1.6 mycroft }
665 1.6 mycroft if (sopptr->sem_flg & SEM_UNDO)
666 1.6 mycroft do_undos = 1;
667 1.6 mycroft } else if (sopptr->sem_op == 0) {
668 1.6 mycroft if (semptr->semval > 0) {
669 1.27 christos SEM_PRINTF(("semop: not zero now\n"));
670 1.6 mycroft break;
671 1.6 mycroft }
672 1.6 mycroft } else {
673 1.6 mycroft if (semptr->semncnt > 0)
674 1.6 mycroft do_wakeup = 1;
675 1.6 mycroft semptr->semval += sopptr->sem_op;
676 1.6 mycroft if (sopptr->sem_flg & SEM_UNDO)
677 1.6 mycroft do_undos = 1;
678 1.6 mycroft }
679 1.6 mycroft }
680 1.1 cgd
681 1.6 mycroft /*
682 1.6 mycroft * Did we get through the entire vector?
683 1.6 mycroft */
684 1.6 mycroft if (i >= nsops)
685 1.6 mycroft goto done;
686 1.1 cgd
687 1.6 mycroft /*
688 1.6 mycroft * No ... rollback anything that we've already done
689 1.6 mycroft */
690 1.27 christos SEM_PRINTF(("semop: rollback 0 through %d\n", i-1));
691 1.6 mycroft for (j = 0; j < i; j++)
692 1.33 thorpej semaptr->_sem_base[sops[j].sem_num].semval -=
693 1.6 mycroft sops[j].sem_op;
694 1.1 cgd
695 1.6 mycroft /*
696 1.6 mycroft * If the request that we couldn't satisfy has the
697 1.6 mycroft * NOWAIT flag set then return with EAGAIN.
698 1.6 mycroft */
699 1.6 mycroft if (sopptr->sem_flg & IPC_NOWAIT)
700 1.6 mycroft return(EAGAIN);
701 1.1 cgd
702 1.6 mycroft if (sopptr->sem_op == 0)
703 1.6 mycroft semptr->semzcnt++;
704 1.6 mycroft else
705 1.6 mycroft semptr->semncnt++;
706 1.1 cgd
707 1.27 christos SEM_PRINTF(("semop: good night!\n"));
708 1.6 mycroft eval = tsleep((caddr_t)semaptr, (PZERO - 4) | PCATCH,
709 1.6 mycroft "semwait", 0);
710 1.27 christos SEM_PRINTF(("semop: good morning (eval=%d)!\n", eval));
711 1.1 cgd
712 1.6 mycroft suptr = NULL; /* sem_undo may have been reallocated */
713 1.1 cgd
714 1.6 mycroft if (eval != 0)
715 1.6 mycroft return(EINTR);
716 1.27 christos SEM_PRINTF(("semop: good morning!\n"));
717 1.1 cgd
718 1.6 mycroft /*
719 1.6 mycroft * Make sure that the semaphore still exists
720 1.6 mycroft */
721 1.6 mycroft if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0 ||
722 1.33 thorpej semaptr->sem_perm._seq != IPCID_TO_SEQ(SCARG(uap, semid))) {
723 1.6 mycroft /* The man page says to return EIDRM. */
724 1.6 mycroft /* Unfortunately, BSD doesn't define that code! */
725 1.1 cgd #ifdef EIDRM
726 1.6 mycroft return(EIDRM);
727 1.1 cgd #else
728 1.6 mycroft return(EINVAL);
729 1.1 cgd #endif
730 1.6 mycroft }
731 1.1 cgd
732 1.6 mycroft /*
733 1.6 mycroft * The semaphore is still alive. Readjust the count of
734 1.6 mycroft * waiting processes.
735 1.6 mycroft */
736 1.6 mycroft if (sopptr->sem_op == 0)
737 1.6 mycroft semptr->semzcnt--;
738 1.6 mycroft else
739 1.6 mycroft semptr->semncnt--;
740 1.6 mycroft }
741 1.1 cgd
742 1.6 mycroft done:
743 1.6 mycroft /*
744 1.6 mycroft * Process any SEM_UNDO requests.
745 1.6 mycroft */
746 1.6 mycroft if (do_undos) {
747 1.5 mycroft for (i = 0; i < nsops; i++) {
748 1.6 mycroft /*
749 1.6 mycroft * We only need to deal with SEM_UNDO's for non-zero
750 1.6 mycroft * op's.
751 1.6 mycroft */
752 1.6 mycroft int adjval;
753 1.1 cgd
754 1.6 mycroft if ((sops[i].sem_flg & SEM_UNDO) == 0)
755 1.6 mycroft continue;
756 1.6 mycroft adjval = sops[i].sem_op;
757 1.6 mycroft if (adjval == 0)
758 1.6 mycroft continue;
759 1.6 mycroft eval = semundo_adjust(p, &suptr, semid,
760 1.6 mycroft sops[i].sem_num, -adjval);
761 1.6 mycroft if (eval == 0)
762 1.6 mycroft continue;
763 1.1 cgd
764 1.6 mycroft /*
765 1.6 mycroft * Oh-Oh! We ran out of either sem_undo's or undo's.
766 1.6 mycroft * Rollback the adjustments to this point and then
767 1.6 mycroft * rollback the semaphore ups and down so we can return
768 1.6 mycroft * with an error with all structures restored. We
769 1.6 mycroft * rollback the undo's in the exact reverse order that
770 1.6 mycroft * we applied them. This guarantees that we won't run
771 1.6 mycroft * out of space as we roll things back out.
772 1.6 mycroft */
773 1.6 mycroft for (j = i - 1; j >= 0; j--) {
774 1.6 mycroft if ((sops[j].sem_flg & SEM_UNDO) == 0)
775 1.6 mycroft continue;
776 1.6 mycroft adjval = sops[j].sem_op;
777 1.6 mycroft if (adjval == 0)
778 1.6 mycroft continue;
779 1.6 mycroft if (semundo_adjust(p, &suptr, semid,
780 1.6 mycroft sops[j].sem_num, adjval) != 0)
781 1.1 cgd panic("semop - can't undo undos");
782 1.6 mycroft }
783 1.1 cgd
784 1.6 mycroft for (j = 0; j < nsops; j++)
785 1.33 thorpej semaptr->_sem_base[sops[j].sem_num].semval -=
786 1.6 mycroft sops[j].sem_op;
787 1.1 cgd
788 1.27 christos SEM_PRINTF(("eval = %d from semundo_adjust\n", eval));
789 1.6 mycroft return(eval);
790 1.1 cgd } /* loop through the sops */
791 1.6 mycroft } /* if (do_undos) */
792 1.1 cgd
793 1.6 mycroft /* We're definitely done - set the sempid's */
794 1.6 mycroft for (i = 0; i < nsops; i++) {
795 1.1 cgd sopptr = &sops[i];
796 1.33 thorpej semptr = &semaptr->_sem_base[sopptr->sem_num];
797 1.1 cgd semptr->sempid = p->p_pid;
798 1.6 mycroft }
799 1.1 cgd
800 1.6 mycroft /* Do a wakeup if any semaphore was up'd. */
801 1.6 mycroft if (do_wakeup) {
802 1.27 christos SEM_PRINTF(("semop: doing wakeup\n"));
803 1.1 cgd #ifdef SEM_WAKEUP
804 1.4 mycroft sem_wakeup((caddr_t)semaptr);
805 1.1 cgd #else
806 1.4 mycroft wakeup((caddr_t)semaptr);
807 1.1 cgd #endif
808 1.27 christos SEM_PRINTF(("semop: back from wakeup\n"));
809 1.6 mycroft }
810 1.27 christos SEM_PRINTF(("semop: done\n"));
811 1.6 mycroft *retval = 0;
812 1.6 mycroft return(0);
813 1.1 cgd }
814 1.1 cgd
815 1.1 cgd /*
816 1.6 mycroft * Go through the undo structures for this process and apply the adjustments to
817 1.6 mycroft * semaphores.
818 1.1 cgd */
819 1.44 christos /*ARGSUSED*/
820 1.25 christos void
821 1.47 fvdl semexit(p, v)
822 1.47 fvdl struct proc *p;
823 1.44 christos void *v;
824 1.1 cgd {
825 1.35 augustss struct sem_undo *suptr;
826 1.35 augustss struct sem_undo **supptr;
827 1.1 cgd
828 1.6 mycroft /*
829 1.17 mycroft * Go through the chain of undo vectors looking for one associated with
830 1.17 mycroft * this process.
831 1.17 mycroft */
832 1.17 mycroft
833 1.17 mycroft for (supptr = &semu_list; (suptr = *supptr) != NULL;
834 1.17 mycroft supptr = &suptr->un_next) {
835 1.17 mycroft if (suptr->un_proc == p)
836 1.17 mycroft break;
837 1.17 mycroft }
838 1.17 mycroft
839 1.17 mycroft /*
840 1.37 sommerfe * If there is no undo vector, skip to the end.
841 1.14 mycroft */
842 1.14 mycroft
843 1.37 sommerfe if (suptr == NULL)
844 1.37 sommerfe return;
845 1.37 sommerfe
846 1.14 mycroft /*
847 1.37 sommerfe * We now have an undo vector for this process.
848 1.15 mycroft */
849 1.1 cgd
850 1.27 christos SEM_PRINTF(("proc @%p has undo structure with %d entries\n", p,
851 1.27 christos suptr->un_cnt));
852 1.1 cgd
853 1.5 mycroft /*
854 1.5 mycroft * If there are any active undo elements then process them.
855 1.5 mycroft */
856 1.5 mycroft if (suptr->un_cnt > 0) {
857 1.6 mycroft int ix;
858 1.1 cgd
859 1.6 mycroft for (ix = 0; ix < suptr->un_cnt; ix++) {
860 1.6 mycroft int semid = suptr->un_ent[ix].un_id;
861 1.6 mycroft int semnum = suptr->un_ent[ix].un_num;
862 1.6 mycroft int adjval = suptr->un_ent[ix].un_adjval;
863 1.6 mycroft struct semid_ds *semaptr;
864 1.6 mycroft
865 1.6 mycroft semaptr = &sema[semid];
866 1.6 mycroft if ((semaptr->sem_perm.mode & SEM_ALLOC) == 0)
867 1.6 mycroft panic("semexit - semid not allocated");
868 1.6 mycroft if (semnum >= semaptr->sem_nsems)
869 1.6 mycroft panic("semexit - semnum out of range");
870 1.6 mycroft
871 1.27 christos SEM_PRINTF(("semexit: %p id=%d num=%d(adj=%d) ; sem=%d\n",
872 1.6 mycroft suptr->un_proc, suptr->un_ent[ix].un_id,
873 1.6 mycroft suptr->un_ent[ix].un_num,
874 1.6 mycroft suptr->un_ent[ix].un_adjval,
875 1.33 thorpej semaptr->_sem_base[semnum].semval));
876 1.6 mycroft
877 1.14 mycroft if (adjval < 0 &&
878 1.33 thorpej semaptr->_sem_base[semnum].semval < -adjval)
879 1.33 thorpej semaptr->_sem_base[semnum].semval = 0;
880 1.14 mycroft else
881 1.33 thorpej semaptr->_sem_base[semnum].semval += adjval;
882 1.1 cgd
883 1.1 cgd #ifdef SEM_WAKEUP
884 1.6 mycroft sem_wakeup((caddr_t)semaptr);
885 1.1 cgd #else
886 1.6 mycroft wakeup((caddr_t)semaptr);
887 1.1 cgd #endif
888 1.27 christos SEM_PRINTF(("semexit: back from wakeup\n"));
889 1.6 mycroft }
890 1.5 mycroft }
891 1.1 cgd
892 1.5 mycroft /*
893 1.5 mycroft * Deallocate the undo vector.
894 1.5 mycroft */
895 1.27 christos SEM_PRINTF(("removing vector\n"));
896 1.5 mycroft suptr->un_proc = NULL;
897 1.5 mycroft *supptr = suptr->un_next;
898 1.1 cgd }
899