1/* $NetBSD: uipc_sem.c,v 1.47 2016/10/31 15:08:45 maxv Exp $ */
2
3/*-
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Mindaugas Rasiukevicius.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*
33 * Copyright (c) 2002 Alfred Perlstein <alfred@FreeBSD.org>
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
46 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
49 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55 * SUCH DAMAGE.
56 */
57
58/*
59 * Implementation of POSIX semaphore.
60 */
61
62#include <sys/cdefs.h>
63__KERNEL_RCSID(0, "$NetBSD: uipc_sem.c,v 1.47 2016/10/31 15:08:45 maxv Exp $");
64
65#include <sys/param.h>
66#include <sys/kernel.h>
67
68#include <sys/atomic.h>
69#include <sys/proc.h>
70#include <sys/ksem.h>
71#include <sys/syscall.h>
72#include <sys/stat.h>
73#include <sys/kmem.h>
74#include <sys/fcntl.h>
75#include <sys/file.h>
76#include <sys/filedesc.h>
77#include <sys/kauth.h>
78#include <sys/module.h>
79#include <sys/mount.h>
80#include <sys/semaphore.h>
81#include <sys/syscall.h>
82#include <sys/syscallargs.h>
83#include <sys/syscallvar.h>
84#include <sys/sysctl.h>
85
86MODULE(MODULE_CLASS_MISC, ksem, NULL);
87
88#define SEM_MAX_NAMELEN 14
89
90#define SEM_NSEMS_MAX 256
91#define KS_UNLINKED 0x01
92
93static kmutex_t ksem_lock __cacheline_aligned;
94static LIST_HEAD(,ksem) ksem_head __cacheline_aligned;
95static u_int nsems_total __cacheline_aligned;
96static u_int nsems __cacheline_aligned;
97
98static kauth_listener_t ksem_listener;
99
100static int ksem_sysinit(void);
101static int ksem_sysfini(bool);
102static int ksem_modcmd(modcmd_t, void *);
103static int ksem_close_fop(file_t *);
104static int ksem_stat_fop(file_t *, struct stat *);
105static int ksem_read_fop(file_t *, off_t *, struct uio *,
106 kauth_cred_t, int);
107
108static const struct fileops semops = {
109 .fo_read = ksem_read_fop,
110 .fo_write = fbadop_write,
111 .fo_ioctl = fbadop_ioctl,
112 .fo_fcntl = fnullop_fcntl,
113 .fo_poll = fnullop_poll,
114 .fo_stat = ksem_stat_fop,
115 .fo_close = ksem_close_fop,
116 .fo_kqfilter = fnullop_kqfilter,
117 .fo_restart = fnullop_restart,
118};
119
120static const struct syscall_package ksem_syscalls[] = {
121 { SYS__ksem_init, 0, (sy_call_t *)sys__ksem_init },
122 { SYS__ksem_open, 0, (sy_call_t *)sys__ksem_open },
123 { SYS__ksem_unlink, 0, (sy_call_t *)sys__ksem_unlink },
124 { SYS__ksem_close, 0, (sy_call_t *)sys__ksem_close },
125 { SYS__ksem_post, 0, (sy_call_t *)sys__ksem_post },
126 { SYS__ksem_wait, 0, (sy_call_t *)sys__ksem_wait },
127 { SYS__ksem_trywait, 0, (sy_call_t *)sys__ksem_trywait },
128 { SYS__ksem_getvalue, 0, (sy_call_t *)sys__ksem_getvalue },
129 { SYS__ksem_destroy, 0, (sy_call_t *)sys__ksem_destroy },
130 { SYS__ksem_timedwait, 0, (sy_call_t *)sys__ksem_timedwait },
131 { 0, 0, NULL },
132};
133
134struct sysctllog *ksem_clog;
135int ksem_max;
136
137static int
138ksem_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
139 void *arg0, void *arg1, void *arg2, void *arg3)
140{
141 ksem_t *ks;
142 mode_t mode;
143
144 if (action != KAUTH_SYSTEM_SEMAPHORE)
145 return KAUTH_RESULT_DEFER;
146
147 ks = arg1;
148 mode = ks->ks_mode;
149
150 if ((kauth_cred_geteuid(cred) == ks->ks_uid && (mode & S_IWUSR) != 0) ||
151 (kauth_cred_getegid(cred) == ks->ks_gid && (mode & S_IWGRP) != 0) ||
152 (mode & S_IWOTH) != 0)
153 return KAUTH_RESULT_ALLOW;
154
155 return KAUTH_RESULT_DEFER;
156}
157
158static int
159ksem_sysinit(void)
160{
161 int error;
162 const struct sysctlnode *rnode;
163
164 mutex_init(&ksem_lock, MUTEX_DEFAULT, IPL_NONE);
165 LIST_INIT(&ksem_head);
166 nsems_total = 0;
167 nsems = 0;
168
169 error = syscall_establish(NULL, ksem_syscalls);
170 if (error) {
171 (void)ksem_sysfini(false);
172 }
173
174 ksem_listener = kauth_listen_scope(KAUTH_SCOPE_SYSTEM,
175 ksem_listener_cb, NULL);
176
177 /* Define module-specific sysctl tree */
178
179 ksem_max = KSEM_MAX;
180 ksem_clog = NULL;
181
182 sysctl_createv(&ksem_clog, 0, NULL, &rnode,
183 CTLFLAG_PERMANENT,
184 CTLTYPE_NODE, "posix",
185 SYSCTL_DESCR("POSIX options"),
186 NULL, 0, NULL, 0,
187 CTL_KERN, CTL_CREATE, CTL_EOL);
188 sysctl_createv(&ksem_clog, 0, &rnode, NULL,
189 CTLFLAG_PERMANENT | CTLFLAG_READWRITE,
190 CTLTYPE_INT, "semmax",
191 SYSCTL_DESCR("Maximal number of semaphores"),
192 NULL, 0, &ksem_max, 0,
193 CTL_CREATE, CTL_EOL);
194 sysctl_createv(&ksem_clog, 0, &rnode, NULL,
195 CTLFLAG_PERMANENT | CTLFLAG_READONLY,
196 CTLTYPE_INT, "semcnt",
197 SYSCTL_DESCR("Current number of semaphores"),
198 NULL, 0, &nsems, 0,
199 CTL_CREATE, CTL_EOL);
200
201 return error;
202}
203
204static int
205ksem_sysfini(bool interface)
206{
207 int error;
208
209 if (interface) {
210 error = syscall_disestablish(NULL, ksem_syscalls);
211 if (error != 0) {
212 return error;
213 }
214 /*
215 * Make sure that no semaphores are in use. Note: semops
216 * must be unused at this point.
217 */
218 if (nsems_total) {
219 error = syscall_establish(NULL, ksem_syscalls);
220 KASSERT(error == 0);
221 return EBUSY;
222 }
223 }
224 kauth_unlisten_scope(ksem_listener);
225 mutex_destroy(&ksem_lock);
226 sysctl_teardown(&ksem_clog);
227 return 0;
228}
229
230static int
231ksem_modcmd(modcmd_t cmd, void *arg)
232{
233
234 switch (cmd) {
235 case MODULE_CMD_INIT:
236 return ksem_sysinit();
237
238 case MODULE_CMD_FINI:
239 return ksem_sysfini(true);
240
241 default:
242 return ENOTTY;
243 }
244}
245
246static ksem_t *
247ksem_lookup(const char *name)
248{
249 ksem_t *ks;
250
251 KASSERT(mutex_owned(&ksem_lock));
252
253 LIST_FOREACH(ks, &ksem_head, ks_entry) {
254 if (strcmp(ks->ks_name, name) == 0) {
255 mutex_enter(&ks->ks_lock);
256 return ks;
257 }
258 }
259 return NULL;
260}
261
262static int
263ksem_perm(lwp_t *l, ksem_t *ks)
264{
265 kauth_cred_t uc = l->l_cred;
266
267 KASSERT(mutex_owned(&ks->ks_lock));
268
269 if (kauth_authorize_system(uc, KAUTH_SYSTEM_SEMAPHORE, 0, ks, NULL, NULL) != 0)
270 return EACCES;
271
272 return 0;
273}
274
275/*
276 * ksem_get: get the semaphore from the descriptor.
277 *
278 * => locks the semaphore, if found.
279 * => holds a reference on the file descriptor.
280 */
281static int
282ksem_get(int fd, ksem_t **ksret)
283{
284 ksem_t *ks;
285 file_t *fp;
286
287 fp = fd_getfile(fd);
288 if (__predict_false(fp == NULL))
289 return EINVAL;
290 if (__predict_false(fp->f_type != DTYPE_SEM)) {
291 fd_putfile(fd);
292 return EINVAL;
293 }
294 ks = fp->f_ksem;
295 mutex_enter(&ks->ks_lock);
296
297 *ksret = ks;
298 return 0;
299}
300
301/*
302 * ksem_create: allocate and setup a new semaphore structure.
303 */
304static int
305ksem_create(lwp_t *l, const char *name, ksem_t **ksret, mode_t mode, u_int val)
306{
307 ksem_t *ks;
308 kauth_cred_t uc;
309 char *kname;
310 size_t len;
311
312 /* Pre-check for the limit. */
313 if (nsems >= ksem_max) {
314 return ENFILE;
315 }
316
317 if (val > SEM_VALUE_MAX) {
318 return EINVAL;
319 }
320
321 if (name != NULL) {
322 len = strlen(name);
323 if (len > SEM_MAX_NAMELEN) {
324 return ENAMETOOLONG;
325 }
326 /* Name must start with a '/' but not contain one. */
327 if (*name != '/' || len < 2 || strchr(name + 1, '/') != NULL) {
328 return EINVAL;
329 }
330 kname = kmem_alloc(++len, KM_SLEEP);
331 strlcpy(kname, name, len);
332 } else {
333 kname = NULL;
334 len = 0;
335 }
336
337 if (atomic_inc_uint_nv(&l->l_proc->p_nsems) > SEM_NSEMS_MAX) {
338 atomic_dec_uint(&l->l_proc->p_nsems);
339 if (kname != NULL)
340 kmem_free(kname, len);
341 return -1;
342 }
343
344 ks = kmem_zalloc(sizeof(ksem_t), KM_SLEEP);
345 mutex_init(&ks->ks_lock, MUTEX_DEFAULT, IPL_NONE);
346 cv_init(&ks->ks_cv, "psem");
347 ks->ks_name = kname;
348 ks->ks_namelen = len;
349 ks->ks_mode = mode;
350 ks->ks_value = val;
351 ks->ks_ref = 1;
352
353 uc = l->l_cred;
354 ks->ks_uid = kauth_cred_geteuid(uc);
355 ks->ks_gid = kauth_cred_getegid(uc);
356
357 atomic_inc_uint(&nsems_total);
358 *ksret = ks;
359 return 0;
360}
361
362static void
363ksem_free(ksem_t *ks)
364{
365
366 KASSERT(!cv_has_waiters(&ks->ks_cv));
367
368 if (ks->ks_name) {
369 KASSERT(ks->ks_namelen > 0);
370 kmem_free(ks->ks_name, ks->ks_namelen);
371 }
372 mutex_destroy(&ks->ks_lock);
373 cv_destroy(&ks->ks_cv);
374 kmem_free(ks, sizeof(ksem_t));
375
376 atomic_dec_uint(&nsems_total);
377 atomic_dec_uint(&curproc->p_nsems);
378}
379
380int
381sys__ksem_init(struct lwp *l, const struct sys__ksem_init_args *uap,
382 register_t *retval)
383{
384 /* {
385 unsigned int value;
386 intptr_t *idp;
387 } */
388
389 return do_ksem_init(l, SCARG(uap, value), SCARG(uap, idp), copyout);
390}
391
392int
393do_ksem_init(lwp_t *l, u_int val, intptr_t *idp, copyout_t docopyout)
394{
395 proc_t *p = l->l_proc;
396 ksem_t *ks;
397 file_t *fp;
398 intptr_t id;
399 int fd, error;
400
401 error = fd_allocfile(&fp, &fd);
402 if (error) {
403 return error;
404 }
405 fp->f_type = DTYPE_SEM;
406 fp->f_flag = FREAD | FWRITE;
407 fp->f_ops = &semops;
408
409 id = (intptr_t)fd;
410 error = (*docopyout)(&id, idp, sizeof(*idp));
411 if (error) {
412 fd_abort(p, fp, fd);
413 return error;
414 }
415
416 /* Note the mode does not matter for anonymous semaphores. */
417 error = ksem_create(l, NULL, &ks, 0, val);
418 if (error) {
419 fd_abort(p, fp, fd);
420 return error;
421 }
422 fp->f_ksem = ks;
423 fd_affix(p, fp, fd);
424 return error;
425}
426
427int
428sys__ksem_open(struct lwp *l, const struct sys__ksem_open_args *uap,
429 register_t *retval)
430{
431 /* {
432 const char *name;
433 int oflag;
434 mode_t mode;
435 unsigned int value;
436 intptr_t *idp;
437 } */
438
439 return do_ksem_open(l, SCARG(uap, name), SCARG(uap, oflag),
440 SCARG(uap, mode), SCARG(uap, value), SCARG(uap, idp), copyout);
441}
442
443int
444do_ksem_open(struct lwp *l, const char *semname, int oflag, mode_t mode,
445 unsigned int value, intptr_t *idp, copyout_t docopyout)
446{
447 char name[SEM_MAX_NAMELEN + 1];
448 proc_t *p = l->l_proc;
449 ksem_t *ksnew = NULL, *ks;
450 file_t *fp;
451 intptr_t id;
452 int fd, error;
453
454 error = copyinstr(semname, name, sizeof(name), NULL);
455 if (error) {
456 return error;
457 }
458 error = fd_allocfile(&fp, &fd);
459 if (error) {
460 return error;
461 }
462 fp->f_type = DTYPE_SEM;
463 fp->f_flag = FREAD | FWRITE;
464 fp->f_ops = &semops;
465
466 /*
467 * The ID (file descriptor number) can be stored early.
468 * Note that zero is a special value for libpthread.
469 */
470 id = (intptr_t)fd;
471 error = (*docopyout)(&id, idp, sizeof(*idp));
472 if (error) {
473 goto err;
474 }
475
476 if (oflag & O_CREAT) {
477 /* Create a new semaphore. */
478 error = ksem_create(l, name, &ksnew, mode, value);
479 if (error) {
480 goto err;
481 }
482 KASSERT(ksnew != NULL);
483 }
484
485 /* Lookup for a semaphore with such name. */
486 mutex_enter(&ksem_lock);
487 ks = ksem_lookup(name);
488 if (ks) {
489 KASSERT(mutex_owned(&ks->ks_lock));
490 mutex_exit(&ksem_lock);
491
492 /* Check for exclusive create. */
493 if (oflag & O_EXCL) {
494 mutex_exit(&ks->ks_lock);
495 error = EEXIST;
496 goto err;
497 }
498 /*
499 * Verify permissions. If we can access it,
500 * add the reference of this thread.
501 */
502 error = ksem_perm(l, ks);
503 if (error == 0) {
504 ks->ks_ref++;
505 }
506 mutex_exit(&ks->ks_lock);
507 if (error) {
508 goto err;
509 }
510 } else {
511 /* Fail if not found and not creating. */
512 if ((oflag & O_CREAT) == 0) {
513 mutex_exit(&ksem_lock);
514 KASSERT(ksnew == NULL);
515 error = ENOENT;
516 goto err;
517 }
518
519 /* Check for the limit locked. */
520 if (nsems >= ksem_max) {
521 mutex_exit(&ksem_lock);
522 error = ENFILE;
523 goto err;
524 }
525
526 /*
527 * Finally, insert semaphore into the list.
528 * Note: it already has the initial reference.
529 */
530 ks = ksnew;
531 LIST_INSERT_HEAD(&ksem_head, ks, ks_entry);
532 nsems++;
533 mutex_exit(&ksem_lock);
534
535 ksnew = NULL;
536 }
537 KASSERT(ks != NULL);
538 fp->f_ksem = ks;
539 fd_affix(p, fp, fd);
540err:
541 if (error) {
542 fd_abort(p, fp, fd);
543 }
544 if (ksnew) {
545 ksem_free(ksnew);
546 }
547 return error;
548}
549
550int
551sys__ksem_close(struct lwp *l, const struct sys__ksem_close_args *uap,
552 register_t *retval)
553{
554 /* {
555 intptr_t id;
556 } */
557 int fd = (int)SCARG(uap, id);
558
559 if (fd_getfile(fd) == NULL) {
560 return EBADF;
561 }
562 return fd_close(fd);
563}
564
565static int
566ksem_read_fop(file_t *fp, off_t *offset, struct uio *uio, kauth_cred_t cred,
567 int flags)
568{
569 size_t len;
570 char *name;
571 ksem_t *ks = fp->f_ksem;
572
573 mutex_enter(&ks->ks_lock);
574 len = ks->ks_namelen;
575 name = ks->ks_name;
576 mutex_exit(&ks->ks_lock);
577 if (name == NULL || len == 0)
578 return 0;
579 return uiomove(name, len, uio);
580}
581
582static int
583ksem_stat_fop(file_t *fp, struct stat *ub)
584{
585 ksem_t *ks = fp->f_ksem;
586
587 mutex_enter(&ks->ks_lock);
588
589 memset(ub, 0, sizeof(*ub));
590
591 ub->st_mode = ks->ks_mode | ((ks->ks_name && ks->ks_namelen)
592 ? _S_IFLNK : _S_IFREG);
593 ub->st_uid = ks->ks_uid;
594 ub->st_gid = ks->ks_gid;
595 ub->st_size = ks->ks_value;
596 ub->st_blocks = (ub->st_size) ? 1 : 0;
597 ub->st_nlink = ks->ks_ref;
598 ub->st_blksize = 4096;
599
600 nanotime(&ub->st_atimespec);
601 ub->st_mtimespec = ub->st_ctimespec = ub->st_birthtimespec =
602 ub->st_atimespec;
603
604 /*
605 * Left as 0: st_dev, st_ino, st_rdev, st_flags, st_gen.
606 * XXX (st_dev, st_ino) should be unique.
607 */
608 mutex_exit(&ks->ks_lock);
609 return 0;
610}
611
612static int
613ksem_close_fop(file_t *fp)
614{
615 ksem_t *ks = fp->f_ksem;
616 bool destroy = false;
617
618 mutex_enter(&ks->ks_lock);
619 KASSERT(ks->ks_ref > 0);
620 if (--ks->ks_ref == 0) {
621 /*
622 * Destroy if the last reference and semaphore is unnamed,
623 * or unlinked (for named semaphore).
624 */
625 destroy = (ks->ks_flags & KS_UNLINKED) || (ks->ks_name == NULL);
626 }
627 mutex_exit(&ks->ks_lock);
628
629 if (destroy) {
630 ksem_free(ks);
631 }
632 return 0;
633}
634
635int
636sys__ksem_unlink(struct lwp *l, const struct sys__ksem_unlink_args *uap,
637 register_t *retval)
638{
639 /* {
640 const char *name;
641 } */
642 char name[SEM_MAX_NAMELEN + 1];
643 ksem_t *ks;
644 u_int refcnt;
645 int error;
646
647 error = copyinstr(SCARG(uap, name), name, sizeof(name), NULL);
648 if (error)
649 return error;
650
651 mutex_enter(&ksem_lock);
652 ks = ksem_lookup(name);
653 if (ks == NULL) {
654 mutex_exit(&ksem_lock);
655 return ENOENT;
656 }
657 KASSERT(mutex_owned(&ks->ks_lock));
658
659 /* Verify permissions. */
660 error = ksem_perm(l, ks);
661 if (error) {
662 mutex_exit(&ks->ks_lock);
663 mutex_exit(&ksem_lock);
664 return error;
665 }
666
667 /* Remove from the global list. */
668 LIST_REMOVE(ks, ks_entry);
669 nsems--;
670 mutex_exit(&ksem_lock);
671
672 refcnt = ks->ks_ref;
673 if (refcnt) {
674 /* Mark as unlinked, if there are references. */
675 ks->ks_flags |= KS_UNLINKED;
676 }
677 mutex_exit(&ks->ks_lock);
678
679 if (refcnt == 0) {
680 ksem_free(ks);
681 }
682 return 0;
683}
684
685int
686sys__ksem_post(struct lwp *l, const struct sys__ksem_post_args *uap,
687 register_t *retval)
688{
689 /* {
690 intptr_t id;
691 } */
692 int fd = (int)SCARG(uap, id), error;
693 ksem_t *ks;
694
695 error = ksem_get(fd, &ks);
696 if (error) {
697 return error;
698 }
699 KASSERT(mutex_owned(&ks->ks_lock));
700 if (ks->ks_value == SEM_VALUE_MAX) {
701 error = EOVERFLOW;
702 goto out;
703 }
704 ks->ks_value++;
705 if (ks->ks_waiters) {
706 cv_broadcast(&ks->ks_cv);
707 }
708out:
709 mutex_exit(&ks->ks_lock);
710 fd_putfile(fd);
711 return error;
712}
713
714int
715do_ksem_wait(lwp_t *l, intptr_t id, bool try_p, struct timespec *abstime)
716{
717 int fd = (int)id, error, timeo;
718 ksem_t *ks;
719
720 error = ksem_get(fd, &ks);
721 if (error) {
722 return error;
723 }
724 KASSERT(mutex_owned(&ks->ks_lock));
725 while (ks->ks_value == 0) {
726 ks->ks_waiters++;
727 if (!try_p && abstime != NULL) {
728 error = ts2timo(CLOCK_REALTIME, TIMER_ABSTIME, abstime,
729 &timeo, NULL);
730 if (error != 0)
731 goto out;
732 } else {
733 timeo = 0;
734 }
735 error = try_p ? EAGAIN : cv_timedwait_sig(&ks->ks_cv,
736 &ks->ks_lock, timeo);
737 ks->ks_waiters--;
738 if (error)
739 goto out;
740 }
741 ks->ks_value--;
742out:
743 mutex_exit(&ks->ks_lock);
744 fd_putfile(fd);
745 return error;
746}
747
748int
749sys__ksem_wait(struct lwp *l, const struct sys__ksem_wait_args *uap,
750 register_t *retval)
751{
752 /* {
753 intptr_t id;
754 } */
755
756 return do_ksem_wait(l, SCARG(uap, id), false, NULL);
757}
758
759int
760sys__ksem_timedwait(struct lwp *l, const struct sys__ksem_timedwait_args *uap,
761 register_t *retval)
762{
763 /* {
764 intptr_t id;
765 const struct timespec *abstime;
766 } */
767 struct timespec ts;
768 int error;
769
770 error = copyin(SCARG(uap, abstime), &ts, sizeof(ts));
771 if (error != 0)
772 return error;
773
774 if (ts.tv_sec < 0 || ts.tv_nsec < 0 || ts.tv_nsec >= 1000000000)
775 return EINVAL;
776
777 error = do_ksem_wait(l, SCARG(uap, id), false, &ts);
778 if (error == EWOULDBLOCK)
779 error = ETIMEDOUT;
780 return error;
781}
782
783int
784sys__ksem_trywait(struct lwp *l, const struct sys__ksem_trywait_args *uap,
785 register_t *retval)
786{
787 /* {
788 intptr_t id;
789 } */
790
791 return do_ksem_wait(l, SCARG(uap, id), true, NULL);
792}
793
794int
795sys__ksem_getvalue(struct lwp *l, const struct sys__ksem_getvalue_args *uap,
796 register_t *retval)
797{
798 /* {
799 intptr_t id;
800 unsigned int *value;
801 } */
802 int fd = (int)SCARG(uap, id), error;
803 ksem_t *ks;
804 unsigned int val;
805
806 error = ksem_get(fd, &ks);
807 if (error) {
808 return error;
809 }
810 KASSERT(mutex_owned(&ks->ks_lock));
811 val = ks->ks_value;
812 mutex_exit(&ks->ks_lock);
813 fd_putfile(fd);
814
815 return copyout(&val, SCARG(uap, value), sizeof(val));
816}
817
818int
819sys__ksem_destroy(struct lwp *l, const struct sys__ksem_destroy_args *uap,
820 register_t *retval)
821{
822 /* {
823 intptr_t id;
824 } */
825 int fd = (int)SCARG(uap, id), error;
826 ksem_t *ks;
827
828 error = ksem_get(fd, &ks);
829 if (error) {
830 return error;
831 }
832 KASSERT(mutex_owned(&ks->ks_lock));
833
834 /* Operation is only for unnamed semaphores. */
835 if (ks->ks_name != NULL) {
836 error = EINVAL;
837 goto out;
838 }
839 /* Cannot destroy if there are waiters. */
840 if (ks->ks_waiters) {
841 error = EBUSY;
842 goto out;
843 }
844out:
845 mutex_exit(&ks->ks_lock);
846 if (error) {
847 fd_putfile(fd);
848 return error;
849 }
850 return fd_close(fd);
851}
852