xref: /freebsd/sys/kern/uipc_sem.c (revision b68cf25fe65a9e79ed0bd1b34129fcd245d087d0)
19454b2d8SWarner Losh /*-
2efaa6588SAlfred Perlstein  * Copyright (c) 2002 Alfred Perlstein <alfred@FreeBSD.org>
352648411SRobert Watson  * Copyright (c) 2003-2005 SPARTA, Inc.
4590f242cSRobert Watson  * Copyright (c) 2005 Robert N. M. Watson
5efaa6588SAlfred Perlstein  * All rights reserved.
6efaa6588SAlfred Perlstein  *
752648411SRobert Watson  * This software was developed for the FreeBSD Project in part by Network
852648411SRobert Watson  * Associates Laboratories, the Security Research Division of Network
952648411SRobert Watson  * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"),
1052648411SRobert Watson  * as part of the DARPA CHATS research program.
1152648411SRobert Watson  *
12efaa6588SAlfred Perlstein  * Redistribution and use in source and binary forms, with or without
13efaa6588SAlfred Perlstein  * modification, are permitted provided that the following conditions
14efaa6588SAlfred Perlstein  * are met:
15efaa6588SAlfred Perlstein  * 1. Redistributions of source code must retain the above copyright
16efaa6588SAlfred Perlstein  *    notice, this list of conditions and the following disclaimer.
17efaa6588SAlfred Perlstein  * 2. Redistributions in binary form must reproduce the above copyright
18efaa6588SAlfred Perlstein  *    notice, this list of conditions and the following disclaimer in the
19efaa6588SAlfred Perlstein  *    documentation and/or other materials provided with the distribution.
20efaa6588SAlfred Perlstein  *
21efaa6588SAlfred Perlstein  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22efaa6588SAlfred Perlstein  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23efaa6588SAlfred Perlstein  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24efaa6588SAlfred Perlstein  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25efaa6588SAlfred Perlstein  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26efaa6588SAlfred Perlstein  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27efaa6588SAlfred Perlstein  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28efaa6588SAlfred Perlstein  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29efaa6588SAlfred Perlstein  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30efaa6588SAlfred Perlstein  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31efaa6588SAlfred Perlstein  * SUCH DAMAGE.
32efaa6588SAlfred Perlstein  */
33efaa6588SAlfred Perlstein 
34677b542eSDavid E. O'Brien #include <sys/cdefs.h>
35677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
36677b542eSDavid E. O'Brien 
370e5d5bc2SKonstantin Belousov #include "opt_compat.h"
38efaa6588SAlfred Perlstein #include "opt_posix.h"
39efaa6588SAlfred Perlstein 
40efaa6588SAlfred Perlstein #include <sys/param.h>
41a9d2f8d8SRobert Watson #include <sys/capability.h>
426bc1e9cdSJohn Baldwin #include <sys/condvar.h>
436bc1e9cdSJohn Baldwin #include <sys/fcntl.h>
446bc1e9cdSJohn Baldwin #include <sys/file.h>
456bc1e9cdSJohn Baldwin #include <sys/filedesc.h>
466bc1e9cdSJohn Baldwin #include <sys/fnv_hash.h>
47efaa6588SAlfred Perlstein #include <sys/kernel.h>
486aeb05d7STom Rhodes #include <sys/ksem.h>
496bc1e9cdSJohn Baldwin #include <sys/lock.h>
506bc1e9cdSJohn Baldwin #include <sys/malloc.h>
516bc1e9cdSJohn Baldwin #include <sys/module.h>
526bc1e9cdSJohn Baldwin #include <sys/mutex.h>
53acd3428bSRobert Watson #include <sys/priv.h>
54efaa6588SAlfred Perlstein #include <sys/proc.h>
556aeb05d7STom Rhodes #include <sys/posix4.h>
566aeb05d7STom Rhodes #include <sys/_semaphore.h>
576bc1e9cdSJohn Baldwin #include <sys/stat.h>
586bc1e9cdSJohn Baldwin #include <sys/syscall.h>
596bc1e9cdSJohn Baldwin #include <sys/syscallsubr.h>
606bc1e9cdSJohn Baldwin #include <sys/sysctl.h>
616bc1e9cdSJohn Baldwin #include <sys/sysent.h>
626bc1e9cdSJohn Baldwin #include <sys/sysproto.h>
636bc1e9cdSJohn Baldwin #include <sys/systm.h>
646bc1e9cdSJohn Baldwin #include <sys/sx.h>
656bc1e9cdSJohn Baldwin #include <sys/vnode.h>
66efaa6588SAlfred Perlstein 
67aed55708SRobert Watson #include <security/mac/mac_framework.h>
68aed55708SRobert Watson 
699a253c10SAlexander Leidinger FEATURE(p1003_1b_semaphores, "POSIX P1003.1B semaphores support");
706bc1e9cdSJohn Baldwin /*
716bc1e9cdSJohn Baldwin  * TODO
726bc1e9cdSJohn Baldwin  *
736bc1e9cdSJohn Baldwin  * - Resource limits?
746bc1e9cdSJohn Baldwin  * - Update fstat(1)
756bc1e9cdSJohn Baldwin  * - Replace global sem_lock with mtx_pool locks?
766bc1e9cdSJohn Baldwin  * - Add a MAC check_create() hook for creating new named semaphores.
776bc1e9cdSJohn Baldwin  */
78efaa6588SAlfred Perlstein 
79efaa6588SAlfred Perlstein #ifndef SEM_MAX
80efaa6588SAlfred Perlstein #define	SEM_MAX	30
81efaa6588SAlfred Perlstein #endif
82efaa6588SAlfred Perlstein 
83c814aa3fSAlfred Perlstein #ifdef SEM_DEBUG
84c814aa3fSAlfred Perlstein #define	DP(x)	printf x
85c814aa3fSAlfred Perlstein #else
86c814aa3fSAlfred Perlstein #define	DP(x)
87c814aa3fSAlfred Perlstein #endif
88c814aa3fSAlfred Perlstein 
896bc1e9cdSJohn Baldwin struct ksem_mapping {
906bc1e9cdSJohn Baldwin 	char		*km_path;
916bc1e9cdSJohn Baldwin 	Fnv32_t		km_fnv;
926bc1e9cdSJohn Baldwin 	struct ksem	*km_ksem;
936bc1e9cdSJohn Baldwin 	LIST_ENTRY(ksem_mapping) km_link;
946bc1e9cdSJohn Baldwin };
956bc1e9cdSJohn Baldwin 
966bc1e9cdSJohn Baldwin static MALLOC_DEFINE(M_KSEM, "ksem", "semaphore file descriptor");
976bc1e9cdSJohn Baldwin static LIST_HEAD(, ksem_mapping) *ksem_dictionary;
986bc1e9cdSJohn Baldwin static struct sx ksem_dict_lock;
996bc1e9cdSJohn Baldwin static struct mtx ksem_count_lock;
1006bc1e9cdSJohn Baldwin static struct mtx sem_lock;
1016bc1e9cdSJohn Baldwin static u_long ksem_hash;
1026bc1e9cdSJohn Baldwin static int ksem_dead;
1036bc1e9cdSJohn Baldwin 
1046bc1e9cdSJohn Baldwin #define	KSEM_HASH(fnv)	(&ksem_dictionary[(fnv) & ksem_hash])
1056bc1e9cdSJohn Baldwin 
1066bc1e9cdSJohn Baldwin static int nsems = 0;
1076bc1e9cdSJohn Baldwin SYSCTL_DECL(_p1003_1b);
1086bc1e9cdSJohn Baldwin SYSCTL_INT(_p1003_1b, OID_AUTO, nsems, CTLFLAG_RD, &nsems, 0,
1096bc1e9cdSJohn Baldwin     "Number of active kernel POSIX semaphores");
1106bc1e9cdSJohn Baldwin 
1116bc1e9cdSJohn Baldwin static int	kern_sem_wait(struct thread *td, semid_t id, int tryflag,
1126bc1e9cdSJohn Baldwin 		    struct timespec *abstime);
1136bc1e9cdSJohn Baldwin static int	ksem_access(struct ksem *ks, struct ucred *ucred);
1146bc1e9cdSJohn Baldwin static struct ksem *ksem_alloc(struct ucred *ucred, mode_t mode,
1156bc1e9cdSJohn Baldwin 		    unsigned int value);
1166bc1e9cdSJohn Baldwin static int	ksem_create(struct thread *td, const char *path,
1176bc1e9cdSJohn Baldwin 		    semid_t *semidp, mode_t mode, unsigned int value,
1180e5d5bc2SKonstantin Belousov 		    int flags, int compat32);
1196bc1e9cdSJohn Baldwin static void	ksem_drop(struct ksem *ks);
120a9d2f8d8SRobert Watson static int	ksem_get(struct thread *td, semid_t id, cap_rights_t rights,
121a9d2f8d8SRobert Watson     struct file **fpp);
1226bc1e9cdSJohn Baldwin static struct ksem *ksem_hold(struct ksem *ks);
1236bc1e9cdSJohn Baldwin static void	ksem_insert(char *path, Fnv32_t fnv, struct ksem *ks);
1246bc1e9cdSJohn Baldwin static struct ksem *ksem_lookup(char *path, Fnv32_t fnv);
1256bc1e9cdSJohn Baldwin static void	ksem_module_destroy(void);
1266bc1e9cdSJohn Baldwin static int	ksem_module_init(void);
1276bc1e9cdSJohn Baldwin static int	ksem_remove(char *path, Fnv32_t fnv, struct ucred *ucred);
1286bc1e9cdSJohn Baldwin static int	sem_modload(struct module *module, int cmd, void *arg);
1296bc1e9cdSJohn Baldwin 
1306bc1e9cdSJohn Baldwin static fo_rdwr_t	ksem_read;
1316bc1e9cdSJohn Baldwin static fo_rdwr_t	ksem_write;
1326bc1e9cdSJohn Baldwin static fo_truncate_t	ksem_truncate;
1336bc1e9cdSJohn Baldwin static fo_ioctl_t	ksem_ioctl;
1346bc1e9cdSJohn Baldwin static fo_poll_t	ksem_poll;
1356bc1e9cdSJohn Baldwin static fo_kqfilter_t	ksem_kqfilter;
1366bc1e9cdSJohn Baldwin static fo_stat_t	ksem_stat;
1376bc1e9cdSJohn Baldwin static fo_close_t	ksem_closef;
1389c00bb91SKonstantin Belousov static fo_chmod_t	ksem_chmod;
1399c00bb91SKonstantin Belousov static fo_chown_t	ksem_chown;
1406bc1e9cdSJohn Baldwin 
1416bc1e9cdSJohn Baldwin /* File descriptor operations. */
1426bc1e9cdSJohn Baldwin static struct fileops ksem_ops = {
1436bc1e9cdSJohn Baldwin 	.fo_read = ksem_read,
1446bc1e9cdSJohn Baldwin 	.fo_write = ksem_write,
1456bc1e9cdSJohn Baldwin 	.fo_truncate = ksem_truncate,
1466bc1e9cdSJohn Baldwin 	.fo_ioctl = ksem_ioctl,
1476bc1e9cdSJohn Baldwin 	.fo_poll = ksem_poll,
1486bc1e9cdSJohn Baldwin 	.fo_kqfilter = ksem_kqfilter,
1496bc1e9cdSJohn Baldwin 	.fo_stat = ksem_stat,
1506bc1e9cdSJohn Baldwin 	.fo_close = ksem_closef,
1519c00bb91SKonstantin Belousov 	.fo_chmod = ksem_chmod,
1529c00bb91SKonstantin Belousov 	.fo_chown = ksem_chown,
1536bc1e9cdSJohn Baldwin 	.fo_flags = DFLAG_PASSABLE
1546bc1e9cdSJohn Baldwin };
1556bc1e9cdSJohn Baldwin 
1566bc1e9cdSJohn Baldwin FEATURE(posix_sem, "POSIX semaphores");
1576bc1e9cdSJohn Baldwin 
1586bc1e9cdSJohn Baldwin static int
1596bc1e9cdSJohn Baldwin ksem_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
1606bc1e9cdSJohn Baldwin     int flags, struct thread *td)
161efaa6588SAlfred Perlstein {
162efaa6588SAlfred Perlstein 
1636bc1e9cdSJohn Baldwin 	return (EOPNOTSUPP);
164efaa6588SAlfred Perlstein }
165efaa6588SAlfred Perlstein 
166c3053131SPoul-Henning Kamp static int
1676bc1e9cdSJohn Baldwin ksem_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
1686bc1e9cdSJohn Baldwin     int flags, struct thread *td)
169efaa6588SAlfred Perlstein {
1706bc1e9cdSJohn Baldwin 
1716bc1e9cdSJohn Baldwin 	return (EOPNOTSUPP);
1726bc1e9cdSJohn Baldwin }
1736bc1e9cdSJohn Baldwin 
1746bc1e9cdSJohn Baldwin static int
1756bc1e9cdSJohn Baldwin ksem_truncate(struct file *fp, off_t length, struct ucred *active_cred,
1766bc1e9cdSJohn Baldwin     struct thread *td)
1776bc1e9cdSJohn Baldwin {
1786bc1e9cdSJohn Baldwin 
1796bc1e9cdSJohn Baldwin 	return (EINVAL);
1806bc1e9cdSJohn Baldwin }
1816bc1e9cdSJohn Baldwin 
1826bc1e9cdSJohn Baldwin static int
1836bc1e9cdSJohn Baldwin ksem_ioctl(struct file *fp, u_long com, void *data,
1846bc1e9cdSJohn Baldwin     struct ucred *active_cred, struct thread *td)
1856bc1e9cdSJohn Baldwin {
1866bc1e9cdSJohn Baldwin 
1876bc1e9cdSJohn Baldwin 	return (EOPNOTSUPP);
1886bc1e9cdSJohn Baldwin }
1896bc1e9cdSJohn Baldwin 
1906bc1e9cdSJohn Baldwin static int
1916bc1e9cdSJohn Baldwin ksem_poll(struct file *fp, int events, struct ucred *active_cred,
1926bc1e9cdSJohn Baldwin     struct thread *td)
1936bc1e9cdSJohn Baldwin {
1946bc1e9cdSJohn Baldwin 
1956bc1e9cdSJohn Baldwin 	return (EOPNOTSUPP);
1966bc1e9cdSJohn Baldwin }
1976bc1e9cdSJohn Baldwin 
1986bc1e9cdSJohn Baldwin static int
1996bc1e9cdSJohn Baldwin ksem_kqfilter(struct file *fp, struct knote *kn)
2006bc1e9cdSJohn Baldwin {
2016bc1e9cdSJohn Baldwin 
2026bc1e9cdSJohn Baldwin 	return (EOPNOTSUPP);
2036bc1e9cdSJohn Baldwin }
2046bc1e9cdSJohn Baldwin 
2056bc1e9cdSJohn Baldwin static int
2066bc1e9cdSJohn Baldwin ksem_stat(struct file *fp, struct stat *sb, struct ucred *active_cred,
2076bc1e9cdSJohn Baldwin     struct thread *td)
2086bc1e9cdSJohn Baldwin {
2096bc1e9cdSJohn Baldwin 	struct ksem *ks;
2106bc1e9cdSJohn Baldwin #ifdef MAC
2116bc1e9cdSJohn Baldwin 	int error;
2126bc1e9cdSJohn Baldwin #endif
2136bc1e9cdSJohn Baldwin 
2146bc1e9cdSJohn Baldwin 	ks = fp->f_data;
2156bc1e9cdSJohn Baldwin 
2166bc1e9cdSJohn Baldwin #ifdef MAC
2176bc1e9cdSJohn Baldwin 	error = mac_posixsem_check_stat(active_cred, fp->f_cred, ks);
2186bc1e9cdSJohn Baldwin 	if (error)
2196bc1e9cdSJohn Baldwin 		return (error);
2206bc1e9cdSJohn Baldwin #endif
2216bc1e9cdSJohn Baldwin 
2226bc1e9cdSJohn Baldwin 	/*
2236bc1e9cdSJohn Baldwin 	 * Attempt to return sanish values for fstat() on a semaphore
2246bc1e9cdSJohn Baldwin 	 * file descriptor.
2256bc1e9cdSJohn Baldwin 	 */
2266bc1e9cdSJohn Baldwin 	bzero(sb, sizeof(*sb));
2276bc1e9cdSJohn Baldwin 
2289c00bb91SKonstantin Belousov 	mtx_lock(&sem_lock);
229510ea843SEd Schouten 	sb->st_atim = ks->ks_atime;
230510ea843SEd Schouten 	sb->st_ctim = ks->ks_ctime;
231510ea843SEd Schouten 	sb->st_mtim = ks->ks_mtime;
232510ea843SEd Schouten 	sb->st_birthtim = ks->ks_birthtime;
2336bc1e9cdSJohn Baldwin 	sb->st_uid = ks->ks_uid;
2346bc1e9cdSJohn Baldwin 	sb->st_gid = ks->ks_gid;
2359c00bb91SKonstantin Belousov 	sb->st_mode = S_IFREG | ks->ks_mode;		/* XXX */
2369c00bb91SKonstantin Belousov 	mtx_unlock(&sem_lock);
2376bc1e9cdSJohn Baldwin 
2386bc1e9cdSJohn Baldwin 	return (0);
2396bc1e9cdSJohn Baldwin }
2406bc1e9cdSJohn Baldwin 
2416bc1e9cdSJohn Baldwin static int
2429c00bb91SKonstantin Belousov ksem_chmod(struct file *fp, mode_t mode, struct ucred *active_cred,
2439c00bb91SKonstantin Belousov     struct thread *td)
2449c00bb91SKonstantin Belousov {
2459c00bb91SKonstantin Belousov 	struct ksem *ks;
2469c00bb91SKonstantin Belousov 	int error;
2479c00bb91SKonstantin Belousov 
2489c00bb91SKonstantin Belousov 	error = 0;
2499c00bb91SKonstantin Belousov 	ks = fp->f_data;
2509c00bb91SKonstantin Belousov 	mtx_lock(&sem_lock);
2519c00bb91SKonstantin Belousov #ifdef MAC
2529c00bb91SKonstantin Belousov 	error = mac_posixsem_check_setmode(active_cred, ks, mode);
2539c00bb91SKonstantin Belousov 	if (error != 0)
2549c00bb91SKonstantin Belousov 		goto out;
2559c00bb91SKonstantin Belousov #endif
2569c00bb91SKonstantin Belousov 	error = vaccess(VREG, ks->ks_mode, ks->ks_uid, ks->ks_gid, VADMIN,
2579c00bb91SKonstantin Belousov 	    active_cred, NULL);
2589c00bb91SKonstantin Belousov 	if (error != 0)
2599c00bb91SKonstantin Belousov 		goto out;
2609c00bb91SKonstantin Belousov 	ks->ks_mode = mode & ACCESSPERMS;
2619c00bb91SKonstantin Belousov out:
2629c00bb91SKonstantin Belousov 	mtx_unlock(&sem_lock);
2639c00bb91SKonstantin Belousov 	return (error);
2649c00bb91SKonstantin Belousov }
2659c00bb91SKonstantin Belousov 
2669c00bb91SKonstantin Belousov static int
2679c00bb91SKonstantin Belousov ksem_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred,
2689c00bb91SKonstantin Belousov     struct thread *td)
2699c00bb91SKonstantin Belousov {
2709c00bb91SKonstantin Belousov 	struct ksem *ks;
2719c00bb91SKonstantin Belousov 	int error;
2729c00bb91SKonstantin Belousov 
27368889ed6SKonstantin Belousov 	error = 0;
2749c00bb91SKonstantin Belousov 	ks = fp->f_data;
2759c00bb91SKonstantin Belousov 	mtx_lock(&sem_lock);
2769c00bb91SKonstantin Belousov #ifdef MAC
2779c00bb91SKonstantin Belousov 	error = mac_posixsem_check_setowner(active_cred, ks, uid, gid);
2789c00bb91SKonstantin Belousov 	if (error != 0)
2799c00bb91SKonstantin Belousov 		goto out;
2809c00bb91SKonstantin Belousov #endif
2819c00bb91SKonstantin Belousov 	if (uid == (uid_t)-1)
2829c00bb91SKonstantin Belousov 		uid = ks->ks_uid;
2839c00bb91SKonstantin Belousov 	if (gid == (gid_t)-1)
2849c00bb91SKonstantin Belousov                  gid = ks->ks_gid;
2859c00bb91SKonstantin Belousov 	if (((uid != ks->ks_uid && uid != active_cred->cr_uid) ||
2869c00bb91SKonstantin Belousov 	    (gid != ks->ks_gid && !groupmember(gid, active_cred))) &&
2879c00bb91SKonstantin Belousov 	    (error = priv_check_cred(active_cred, PRIV_VFS_CHOWN, 0)))
2889c00bb91SKonstantin Belousov 		goto out;
2899c00bb91SKonstantin Belousov 	ks->ks_uid = uid;
2909c00bb91SKonstantin Belousov 	ks->ks_gid = gid;
2919c00bb91SKonstantin Belousov out:
2929c00bb91SKonstantin Belousov 	mtx_unlock(&sem_lock);
2939c00bb91SKonstantin Belousov 	return (error);
2949c00bb91SKonstantin Belousov }
2959c00bb91SKonstantin Belousov 
2969c00bb91SKonstantin Belousov static int
2976bc1e9cdSJohn Baldwin ksem_closef(struct file *fp, struct thread *td)
2986bc1e9cdSJohn Baldwin {
2996bc1e9cdSJohn Baldwin 	struct ksem *ks;
3006bc1e9cdSJohn Baldwin 
3016bc1e9cdSJohn Baldwin 	ks = fp->f_data;
3026bc1e9cdSJohn Baldwin 	fp->f_data = NULL;
3036bc1e9cdSJohn Baldwin 	ksem_drop(ks);
3046bc1e9cdSJohn Baldwin 
3056bc1e9cdSJohn Baldwin 	return (0);
3066bc1e9cdSJohn Baldwin }
3076bc1e9cdSJohn Baldwin 
3086bc1e9cdSJohn Baldwin /*
3096bc1e9cdSJohn Baldwin  * ksem object management including creation and reference counting
3106bc1e9cdSJohn Baldwin  * routines.
3116bc1e9cdSJohn Baldwin  */
3126bc1e9cdSJohn Baldwin static struct ksem *
3136bc1e9cdSJohn Baldwin ksem_alloc(struct ucred *ucred, mode_t mode, unsigned int value)
3146bc1e9cdSJohn Baldwin {
3156bc1e9cdSJohn Baldwin 	struct ksem *ks;
3166bc1e9cdSJohn Baldwin 
3176bc1e9cdSJohn Baldwin 	mtx_lock(&ksem_count_lock);
3186bc1e9cdSJohn Baldwin 	if (nsems == p31b_getcfg(CTL_P1003_1B_SEM_NSEMS_MAX) || ksem_dead) {
3196bc1e9cdSJohn Baldwin 		mtx_unlock(&ksem_count_lock);
3206bc1e9cdSJohn Baldwin 		return (NULL);
3216bc1e9cdSJohn Baldwin 	}
3226bc1e9cdSJohn Baldwin 	nsems++;
3236bc1e9cdSJohn Baldwin 	mtx_unlock(&ksem_count_lock);
3246bc1e9cdSJohn Baldwin 	ks = malloc(sizeof(*ks), M_KSEM, M_WAITOK | M_ZERO);
3256bc1e9cdSJohn Baldwin 	ks->ks_uid = ucred->cr_uid;
3266bc1e9cdSJohn Baldwin 	ks->ks_gid = ucred->cr_gid;
3276bc1e9cdSJohn Baldwin 	ks->ks_mode = mode;
3286bc1e9cdSJohn Baldwin 	ks->ks_value = value;
3296bc1e9cdSJohn Baldwin 	cv_init(&ks->ks_cv, "ksem");
3306bc1e9cdSJohn Baldwin 	vfs_timestamp(&ks->ks_birthtime);
3316bc1e9cdSJohn Baldwin 	ks->ks_atime = ks->ks_mtime = ks->ks_ctime = ks->ks_birthtime;
3326bc1e9cdSJohn Baldwin 	refcount_init(&ks->ks_ref, 1);
3336bc1e9cdSJohn Baldwin #ifdef MAC
3346bc1e9cdSJohn Baldwin 	mac_posixsem_init(ks);
3356bc1e9cdSJohn Baldwin 	mac_posixsem_create(ucred, ks);
3366bc1e9cdSJohn Baldwin #endif
3376bc1e9cdSJohn Baldwin 
3386bc1e9cdSJohn Baldwin 	return (ks);
3396bc1e9cdSJohn Baldwin }
3406bc1e9cdSJohn Baldwin 
3416bc1e9cdSJohn Baldwin static struct ksem *
3426bc1e9cdSJohn Baldwin ksem_hold(struct ksem *ks)
3436bc1e9cdSJohn Baldwin {
3446bc1e9cdSJohn Baldwin 
3456bc1e9cdSJohn Baldwin 	refcount_acquire(&ks->ks_ref);
3466bc1e9cdSJohn Baldwin 	return (ks);
3476bc1e9cdSJohn Baldwin }
3486bc1e9cdSJohn Baldwin 
3496bc1e9cdSJohn Baldwin static void
3506bc1e9cdSJohn Baldwin ksem_drop(struct ksem *ks)
3516bc1e9cdSJohn Baldwin {
3526bc1e9cdSJohn Baldwin 
3536bc1e9cdSJohn Baldwin 	if (refcount_release(&ks->ks_ref)) {
3546bc1e9cdSJohn Baldwin #ifdef MAC
3556bc1e9cdSJohn Baldwin 		mac_posixsem_destroy(ks);
3566bc1e9cdSJohn Baldwin #endif
3576bc1e9cdSJohn Baldwin 		cv_destroy(&ks->ks_cv);
3586bc1e9cdSJohn Baldwin 		free(ks, M_KSEM);
3596bc1e9cdSJohn Baldwin 		mtx_lock(&ksem_count_lock);
3606bc1e9cdSJohn Baldwin 		nsems--;
3616bc1e9cdSJohn Baldwin 		mtx_unlock(&ksem_count_lock);
3626bc1e9cdSJohn Baldwin 	}
3636bc1e9cdSJohn Baldwin }
3646bc1e9cdSJohn Baldwin 
3656bc1e9cdSJohn Baldwin /*
3666bc1e9cdSJohn Baldwin  * Determine if the credentials have sufficient permissions for read
3676bc1e9cdSJohn Baldwin  * and write access.
3686bc1e9cdSJohn Baldwin  */
3696bc1e9cdSJohn Baldwin static int
3706bc1e9cdSJohn Baldwin ksem_access(struct ksem *ks, struct ucred *ucred)
3716bc1e9cdSJohn Baldwin {
372efaa6588SAlfred Perlstein 	int error;
373efaa6588SAlfred Perlstein 
3746bc1e9cdSJohn Baldwin 	error = vaccess(VREG, ks->ks_mode, ks->ks_uid, ks->ks_gid,
3756bc1e9cdSJohn Baldwin 	    VREAD | VWRITE, ucred, NULL);
3766bc1e9cdSJohn Baldwin 	if (error)
3776bc1e9cdSJohn Baldwin 		error = priv_check_cred(ucred, PRIV_SEM_WRITE, 0);
378efaa6588SAlfred Perlstein 	return (error);
379efaa6588SAlfred Perlstein }
380efaa6588SAlfred Perlstein 
3816bc1e9cdSJohn Baldwin /*
3826bc1e9cdSJohn Baldwin  * Dictionary management.  We maintain an in-kernel dictionary to map
3836bc1e9cdSJohn Baldwin  * paths to semaphore objects.  We use the FNV hash on the path to
3846bc1e9cdSJohn Baldwin  * store the mappings in a hash table.
3856bc1e9cdSJohn Baldwin  */
3866bc1e9cdSJohn Baldwin static struct ksem *
3876bc1e9cdSJohn Baldwin ksem_lookup(char *path, Fnv32_t fnv)
3886bc1e9cdSJohn Baldwin {
3896bc1e9cdSJohn Baldwin 	struct ksem_mapping *map;
3906bc1e9cdSJohn Baldwin 
3916bc1e9cdSJohn Baldwin 	LIST_FOREACH(map, KSEM_HASH(fnv), km_link) {
3926bc1e9cdSJohn Baldwin 		if (map->km_fnv != fnv)
3936bc1e9cdSJohn Baldwin 			continue;
3946bc1e9cdSJohn Baldwin 		if (strcmp(map->km_path, path) == 0)
3956bc1e9cdSJohn Baldwin 			return (map->km_ksem);
3966bc1e9cdSJohn Baldwin 	}
3976bc1e9cdSJohn Baldwin 
3986bc1e9cdSJohn Baldwin 	return (NULL);
3996bc1e9cdSJohn Baldwin }
4006bc1e9cdSJohn Baldwin 
4016bc1e9cdSJohn Baldwin static void
4026bc1e9cdSJohn Baldwin ksem_insert(char *path, Fnv32_t fnv, struct ksem *ks)
4036bc1e9cdSJohn Baldwin {
4046bc1e9cdSJohn Baldwin 	struct ksem_mapping *map;
4056bc1e9cdSJohn Baldwin 
4066bc1e9cdSJohn Baldwin 	map = malloc(sizeof(struct ksem_mapping), M_KSEM, M_WAITOK);
4076bc1e9cdSJohn Baldwin 	map->km_path = path;
4086bc1e9cdSJohn Baldwin 	map->km_fnv = fnv;
4096bc1e9cdSJohn Baldwin 	map->km_ksem = ksem_hold(ks);
4106bc1e9cdSJohn Baldwin 	LIST_INSERT_HEAD(KSEM_HASH(fnv), map, km_link);
4116bc1e9cdSJohn Baldwin }
4126bc1e9cdSJohn Baldwin 
4136bc1e9cdSJohn Baldwin static int
4146bc1e9cdSJohn Baldwin ksem_remove(char *path, Fnv32_t fnv, struct ucred *ucred)
4156bc1e9cdSJohn Baldwin {
4166bc1e9cdSJohn Baldwin 	struct ksem_mapping *map;
4176bc1e9cdSJohn Baldwin 	int error;
4186bc1e9cdSJohn Baldwin 
4196bc1e9cdSJohn Baldwin 	LIST_FOREACH(map, KSEM_HASH(fnv), km_link) {
4206bc1e9cdSJohn Baldwin 		if (map->km_fnv != fnv)
4216bc1e9cdSJohn Baldwin 			continue;
4226bc1e9cdSJohn Baldwin 		if (strcmp(map->km_path, path) == 0) {
4236bc1e9cdSJohn Baldwin #ifdef MAC
4246bc1e9cdSJohn Baldwin 			error = mac_posixsem_check_unlink(ucred, map->km_ksem);
4256bc1e9cdSJohn Baldwin 			if (error)
4266bc1e9cdSJohn Baldwin 				return (error);
4276bc1e9cdSJohn Baldwin #endif
4286bc1e9cdSJohn Baldwin 			error = ksem_access(map->km_ksem, ucred);
4296bc1e9cdSJohn Baldwin 			if (error)
4306bc1e9cdSJohn Baldwin 				return (error);
4316bc1e9cdSJohn Baldwin 			LIST_REMOVE(map, km_link);
4326bc1e9cdSJohn Baldwin 			ksem_drop(map->km_ksem);
4336bc1e9cdSJohn Baldwin 			free(map->km_path, M_KSEM);
4346bc1e9cdSJohn Baldwin 			free(map, M_KSEM);
4356bc1e9cdSJohn Baldwin 			return (0);
4366bc1e9cdSJohn Baldwin 		}
4376bc1e9cdSJohn Baldwin 	}
4386bc1e9cdSJohn Baldwin 
4396bc1e9cdSJohn Baldwin 	return (ENOENT);
4406bc1e9cdSJohn Baldwin }
4416bc1e9cdSJohn Baldwin 
4420e5d5bc2SKonstantin Belousov static int
4430e5d5bc2SKonstantin Belousov ksem_create_copyout_semid(struct thread *td, semid_t *semidp, int fd,
4440e5d5bc2SKonstantin Belousov     int compat32)
4450e5d5bc2SKonstantin Belousov {
4460e5d5bc2SKonstantin Belousov 	semid_t semid;
4470e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32
4480e5d5bc2SKonstantin Belousov 	int32_t semid32;
4490e5d5bc2SKonstantin Belousov #endif
4500e5d5bc2SKonstantin Belousov 	void *ptr;
4510e5d5bc2SKonstantin Belousov 	size_t ptrs;
4520e5d5bc2SKonstantin Belousov 
4530e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32
4540e5d5bc2SKonstantin Belousov 	if (compat32) {
4550e5d5bc2SKonstantin Belousov 		semid32 = fd;
4560e5d5bc2SKonstantin Belousov 		ptr = &semid32;
4570e5d5bc2SKonstantin Belousov 		ptrs = sizeof(semid32);
4580e5d5bc2SKonstantin Belousov 	} else {
4590e5d5bc2SKonstantin Belousov #endif
4600e5d5bc2SKonstantin Belousov 		semid = fd;
4610e5d5bc2SKonstantin Belousov 		ptr = &semid;
4620e5d5bc2SKonstantin Belousov 		ptrs = sizeof(semid);
4630e5d5bc2SKonstantin Belousov 		compat32 = 0; /* silence gcc */
4640e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32
4650e5d5bc2SKonstantin Belousov 	}
4660e5d5bc2SKonstantin Belousov #endif
4670e5d5bc2SKonstantin Belousov 
4680e5d5bc2SKonstantin Belousov 	return (copyout(ptr, semidp, ptrs));
4690e5d5bc2SKonstantin Belousov }
4700e5d5bc2SKonstantin Belousov 
4716bc1e9cdSJohn Baldwin /* Other helper routines. */
4726bc1e9cdSJohn Baldwin static int
4736bc1e9cdSJohn Baldwin ksem_create(struct thread *td, const char *name, semid_t *semidp, mode_t mode,
4740e5d5bc2SKonstantin Belousov     unsigned int value, int flags, int compat32)
4756bc1e9cdSJohn Baldwin {
4766bc1e9cdSJohn Baldwin 	struct filedesc *fdp;
4776bc1e9cdSJohn Baldwin 	struct ksem *ks;
4786bc1e9cdSJohn Baldwin 	struct file *fp;
4796bc1e9cdSJohn Baldwin 	char *path;
4806bc1e9cdSJohn Baldwin 	Fnv32_t fnv;
4816bc1e9cdSJohn Baldwin 	int error, fd;
4826bc1e9cdSJohn Baldwin 
4836bc1e9cdSJohn Baldwin 	if (value > SEM_VALUE_MAX)
4846bc1e9cdSJohn Baldwin 		return (EINVAL);
4856bc1e9cdSJohn Baldwin 
4866bc1e9cdSJohn Baldwin 	fdp = td->td_proc->p_fd;
4876bc1e9cdSJohn Baldwin 	mode = (mode & ~fdp->fd_cmask) & ACCESSPERMS;
488*b68cf25fSJilles Tjoelker 	error = falloc(td, &fp, &fd, O_CLOEXEC);
4896bc1e9cdSJohn Baldwin 	if (error) {
4906bc1e9cdSJohn Baldwin 		if (name == NULL)
4916bc1e9cdSJohn Baldwin 			error = ENOSPC;
4926bc1e9cdSJohn Baldwin 		return (error);
4936bc1e9cdSJohn Baldwin 	}
4946bc1e9cdSJohn Baldwin 
4956bc1e9cdSJohn Baldwin 	/*
4966bc1e9cdSJohn Baldwin 	 * Go ahead and copyout the file descriptor now.  This is a bit
4976bc1e9cdSJohn Baldwin 	 * premature, but it is a lot easier to handle errors as opposed
4986bc1e9cdSJohn Baldwin 	 * to later when we've possibly created a new semaphore, etc.
4996bc1e9cdSJohn Baldwin 	 */
5000e5d5bc2SKonstantin Belousov 	error = ksem_create_copyout_semid(td, semidp, fd, compat32);
5016bc1e9cdSJohn Baldwin 	if (error) {
5026bc1e9cdSJohn Baldwin 		fdclose(fdp, fp, fd, td);
5036bc1e9cdSJohn Baldwin 		fdrop(fp, td);
5046bc1e9cdSJohn Baldwin 		return (error);
5056bc1e9cdSJohn Baldwin 	}
5066bc1e9cdSJohn Baldwin 
5076bc1e9cdSJohn Baldwin 	if (name == NULL) {
5086bc1e9cdSJohn Baldwin 		/* Create an anonymous semaphore. */
5096bc1e9cdSJohn Baldwin 		ks = ksem_alloc(td->td_ucred, mode, value);
5106bc1e9cdSJohn Baldwin 		if (ks == NULL)
5116bc1e9cdSJohn Baldwin 			error = ENOSPC;
5126bc1e9cdSJohn Baldwin 		else
5136bc1e9cdSJohn Baldwin 			ks->ks_flags |= KS_ANONYMOUS;
5146bc1e9cdSJohn Baldwin 	} else {
5156bc1e9cdSJohn Baldwin 		path = malloc(MAXPATHLEN, M_KSEM, M_WAITOK);
5166bc1e9cdSJohn Baldwin 		error = copyinstr(name, path, MAXPATHLEN, NULL);
5176bc1e9cdSJohn Baldwin 
5186bc1e9cdSJohn Baldwin 		/* Require paths to start with a '/' character. */
5196bc1e9cdSJohn Baldwin 		if (error == 0 && path[0] != '/')
5206bc1e9cdSJohn Baldwin 			error = EINVAL;
5216bc1e9cdSJohn Baldwin 		if (error) {
5226bc1e9cdSJohn Baldwin 			fdclose(fdp, fp, fd, td);
5236bc1e9cdSJohn Baldwin 			fdrop(fp, td);
5246bc1e9cdSJohn Baldwin 			free(path, M_KSEM);
5256bc1e9cdSJohn Baldwin 			return (error);
5266bc1e9cdSJohn Baldwin 		}
5276bc1e9cdSJohn Baldwin 
5286bc1e9cdSJohn Baldwin 		fnv = fnv_32_str(path, FNV1_32_INIT);
5296bc1e9cdSJohn Baldwin 		sx_xlock(&ksem_dict_lock);
5306bc1e9cdSJohn Baldwin 		ks = ksem_lookup(path, fnv);
5316bc1e9cdSJohn Baldwin 		if (ks == NULL) {
5326bc1e9cdSJohn Baldwin 			/* Object does not exist, create it if requested. */
5336bc1e9cdSJohn Baldwin 			if (flags & O_CREAT) {
5346bc1e9cdSJohn Baldwin 				ks = ksem_alloc(td->td_ucred, mode, value);
5356bc1e9cdSJohn Baldwin 				if (ks == NULL)
5366bc1e9cdSJohn Baldwin 					error = ENFILE;
5376bc1e9cdSJohn Baldwin 				else {
5386bc1e9cdSJohn Baldwin 					ksem_insert(path, fnv, ks);
5396bc1e9cdSJohn Baldwin 					path = NULL;
5406bc1e9cdSJohn Baldwin 				}
5416bc1e9cdSJohn Baldwin 			} else
5426bc1e9cdSJohn Baldwin 				error = ENOENT;
5436bc1e9cdSJohn Baldwin 		} else {
5446bc1e9cdSJohn Baldwin 			/*
5456bc1e9cdSJohn Baldwin 			 * Object already exists, obtain a new
5466bc1e9cdSJohn Baldwin 			 * reference if requested and permitted.
5476bc1e9cdSJohn Baldwin 			 */
5486bc1e9cdSJohn Baldwin 			if ((flags & (O_CREAT | O_EXCL)) ==
5496bc1e9cdSJohn Baldwin 			    (O_CREAT | O_EXCL))
5506bc1e9cdSJohn Baldwin 				error = EEXIST;
5516bc1e9cdSJohn Baldwin 			else {
5526bc1e9cdSJohn Baldwin #ifdef MAC
5536bc1e9cdSJohn Baldwin 				error = mac_posixsem_check_open(td->td_ucred,
5546bc1e9cdSJohn Baldwin 				    ks);
5556bc1e9cdSJohn Baldwin 				if (error == 0)
5566bc1e9cdSJohn Baldwin #endif
5576bc1e9cdSJohn Baldwin 				error = ksem_access(ks, td->td_ucred);
5586bc1e9cdSJohn Baldwin 			}
5596bc1e9cdSJohn Baldwin 			if (error == 0)
5606bc1e9cdSJohn Baldwin 				ksem_hold(ks);
5616bc1e9cdSJohn Baldwin #ifdef INVARIANTS
5626bc1e9cdSJohn Baldwin 			else
5636bc1e9cdSJohn Baldwin 				ks = NULL;
5646bc1e9cdSJohn Baldwin #endif
5656bc1e9cdSJohn Baldwin 		}
5666bc1e9cdSJohn Baldwin 		sx_xunlock(&ksem_dict_lock);
5676bc1e9cdSJohn Baldwin 		if (path)
5686bc1e9cdSJohn Baldwin 			free(path, M_KSEM);
5696bc1e9cdSJohn Baldwin 	}
5706bc1e9cdSJohn Baldwin 
5716bc1e9cdSJohn Baldwin 	if (error) {
5726bc1e9cdSJohn Baldwin 		KASSERT(ks == NULL, ("ksem_create error with a ksem"));
5736bc1e9cdSJohn Baldwin 		fdclose(fdp, fp, fd, td);
5746bc1e9cdSJohn Baldwin 		fdrop(fp, td);
5756bc1e9cdSJohn Baldwin 		return (error);
5766bc1e9cdSJohn Baldwin 	}
5776bc1e9cdSJohn Baldwin 	KASSERT(ks != NULL, ("ksem_create w/o a ksem"));
5786bc1e9cdSJohn Baldwin 
5796bc1e9cdSJohn Baldwin 	finit(fp, FREAD | FWRITE, DTYPE_SEM, ks, &ksem_ops);
5806bc1e9cdSJohn Baldwin 
5816bc1e9cdSJohn Baldwin 	fdrop(fp, td);
5826bc1e9cdSJohn Baldwin 
5836bc1e9cdSJohn Baldwin 	return (0);
5846bc1e9cdSJohn Baldwin }
5856bc1e9cdSJohn Baldwin 
5866bc1e9cdSJohn Baldwin static int
587a9d2f8d8SRobert Watson ksem_get(struct thread *td, semid_t id, cap_rights_t rights, struct file **fpp)
5886bc1e9cdSJohn Baldwin {
5896bc1e9cdSJohn Baldwin 	struct ksem *ks;
5906bc1e9cdSJohn Baldwin 	struct file *fp;
5916bc1e9cdSJohn Baldwin 	int error;
5926bc1e9cdSJohn Baldwin 
593a9d2f8d8SRobert Watson 	error = fget(td, id, rights, &fp);
5946bc1e9cdSJohn Baldwin 	if (error)
5956bc1e9cdSJohn Baldwin 		return (EINVAL);
5966bc1e9cdSJohn Baldwin 	if (fp->f_type != DTYPE_SEM) {
5976bc1e9cdSJohn Baldwin 		fdrop(fp, td);
5986bc1e9cdSJohn Baldwin 		return (EINVAL);
5996bc1e9cdSJohn Baldwin 	}
6006bc1e9cdSJohn Baldwin 	ks = fp->f_data;
6016bc1e9cdSJohn Baldwin 	if (ks->ks_flags & KS_DEAD) {
6026bc1e9cdSJohn Baldwin 		fdrop(fp, td);
6036bc1e9cdSJohn Baldwin 		return (EINVAL);
6046bc1e9cdSJohn Baldwin 	}
6056bc1e9cdSJohn Baldwin 	*fpp = fp;
6066bc1e9cdSJohn Baldwin 	return (0);
6076bc1e9cdSJohn Baldwin }
6086bc1e9cdSJohn Baldwin 
6096bc1e9cdSJohn Baldwin /* System calls. */
610efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
611efaa6588SAlfred Perlstein struct ksem_init_args {
612efaa6588SAlfred Perlstein 	unsigned int	value;
613efaa6588SAlfred Perlstein 	semid_t		*idp;
614efaa6588SAlfred Perlstein };
615efaa6588SAlfred Perlstein #endif
616efaa6588SAlfred Perlstein int
6178451d0ddSKip Macy sys_ksem_init(struct thread *td, struct ksem_init_args *uap)
618efaa6588SAlfred Perlstein {
619efaa6588SAlfred Perlstein 
6206bc1e9cdSJohn Baldwin 	return (ksem_create(td, NULL, uap->idp, S_IRWXU | S_IRWXG, uap->value,
6210e5d5bc2SKonstantin Belousov 	    0, 0));
622efaa6588SAlfred Perlstein }
623efaa6588SAlfred Perlstein 
624efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
625efaa6588SAlfred Perlstein struct ksem_open_args {
626efaa6588SAlfred Perlstein 	char		*name;
627efaa6588SAlfred Perlstein 	int		oflag;
628efaa6588SAlfred Perlstein 	mode_t		mode;
629efaa6588SAlfred Perlstein 	unsigned int	value;
630efaa6588SAlfred Perlstein 	semid_t		*idp;
631efaa6588SAlfred Perlstein };
632efaa6588SAlfred Perlstein #endif
633efaa6588SAlfred Perlstein int
6348451d0ddSKip Macy sys_ksem_open(struct thread *td, struct ksem_open_args *uap)
635efaa6588SAlfred Perlstein {
636efaa6588SAlfred Perlstein 
637b2966a5aSBruce M Simpson 	DP((">>> ksem_open start, pid=%d\n", (int)td->td_proc->p_pid));
638b2966a5aSBruce M Simpson 
6396bc1e9cdSJohn Baldwin 	if ((uap->oflag & ~(O_CREAT | O_EXCL)) != 0)
640b3890a1cSAlfred Perlstein 		return (EINVAL);
6416bc1e9cdSJohn Baldwin 	return (ksem_create(td, uap->name, uap->idp, uap->mode, uap->value,
6420e5d5bc2SKonstantin Belousov 	    uap->oflag, 0));
643efaa6588SAlfred Perlstein }
644efaa6588SAlfred Perlstein 
645efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
646efaa6588SAlfred Perlstein struct ksem_unlink_args {
647efaa6588SAlfred Perlstein 	char		*name;
648efaa6588SAlfred Perlstein };
649efaa6588SAlfred Perlstein #endif
650efaa6588SAlfred Perlstein int
6518451d0ddSKip Macy sys_ksem_unlink(struct thread *td, struct ksem_unlink_args *uap)
652efaa6588SAlfred Perlstein {
6536bc1e9cdSJohn Baldwin 	char *path;
6546bc1e9cdSJohn Baldwin 	Fnv32_t fnv;
655efaa6588SAlfred Perlstein 	int error;
656efaa6588SAlfred Perlstein 
6576bc1e9cdSJohn Baldwin 	path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
6586bc1e9cdSJohn Baldwin 	error = copyinstr(uap->name, path, MAXPATHLEN, NULL);
65952648411SRobert Watson 	if (error) {
6606bc1e9cdSJohn Baldwin 		free(path, M_TEMP);
66152648411SRobert Watson 		return (error);
66252648411SRobert Watson 	}
6636bc1e9cdSJohn Baldwin 
6646bc1e9cdSJohn Baldwin 	fnv = fnv_32_str(path, FNV1_32_INIT);
6656bc1e9cdSJohn Baldwin 	sx_xlock(&ksem_dict_lock);
6666bc1e9cdSJohn Baldwin 	error = ksem_remove(path, fnv, td->td_ucred);
6676bc1e9cdSJohn Baldwin 	sx_xunlock(&ksem_dict_lock);
6686bc1e9cdSJohn Baldwin 	free(path, M_TEMP);
6696bc1e9cdSJohn Baldwin 
670efaa6588SAlfred Perlstein 	return (error);
671efaa6588SAlfred Perlstein }
672efaa6588SAlfred Perlstein 
673efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
674efaa6588SAlfred Perlstein struct ksem_close_args {
675efaa6588SAlfred Perlstein 	semid_t		id;
676efaa6588SAlfred Perlstein };
677efaa6588SAlfred Perlstein #endif
678efaa6588SAlfred Perlstein int
6798451d0ddSKip Macy sys_ksem_close(struct thread *td, struct ksem_close_args *uap)
680efaa6588SAlfred Perlstein {
681efaa6588SAlfred Perlstein 	struct ksem *ks;
6826bc1e9cdSJohn Baldwin 	struct file *fp;
683efaa6588SAlfred Perlstein 	int error;
684efaa6588SAlfred Perlstein 
685a9d2f8d8SRobert Watson 	/* No capability rights required to close a semaphore. */
686a9d2f8d8SRobert Watson 	error = ksem_get(td, uap->id, 0, &fp);
6876bc1e9cdSJohn Baldwin 	if (error)
6886bc1e9cdSJohn Baldwin 		return (error);
6896bc1e9cdSJohn Baldwin 	ks = fp->f_data;
6906bc1e9cdSJohn Baldwin 	if (ks->ks_flags & KS_ANONYMOUS) {
6916bc1e9cdSJohn Baldwin 		fdrop(fp, td);
6926bc1e9cdSJohn Baldwin 		return (EINVAL);
6936bc1e9cdSJohn Baldwin 	}
6946bc1e9cdSJohn Baldwin 	error = kern_close(td, uap->id);
6956bc1e9cdSJohn Baldwin 	fdrop(fp, td);
696b3890a1cSAlfred Perlstein 	return (error);
697efaa6588SAlfred Perlstein }
698efaa6588SAlfred Perlstein 
699efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
700efaa6588SAlfred Perlstein struct ksem_post_args {
701efaa6588SAlfred Perlstein 	semid_t	id;
702efaa6588SAlfred Perlstein };
703efaa6588SAlfred Perlstein #endif
704efaa6588SAlfred Perlstein int
7058451d0ddSKip Macy sys_ksem_post(struct thread *td, struct ksem_post_args *uap)
706efaa6588SAlfred Perlstein {
7076bc1e9cdSJohn Baldwin 	struct file *fp;
708efaa6588SAlfred Perlstein 	struct ksem *ks;
709efaa6588SAlfred Perlstein 	int error;
710efaa6588SAlfred Perlstein 
711a9d2f8d8SRobert Watson 	error = ksem_get(td, uap->id, CAP_SEM_POST, &fp);
7126bc1e9cdSJohn Baldwin 	if (error)
7136bc1e9cdSJohn Baldwin 		return (error);
7146bc1e9cdSJohn Baldwin 	ks = fp->f_data;
7156bc1e9cdSJohn Baldwin 
716efaa6588SAlfred Perlstein 	mtx_lock(&sem_lock);
71752648411SRobert Watson #ifdef MAC
7186bc1e9cdSJohn Baldwin 	error = mac_posixsem_check_post(td->td_ucred, fp->f_cred, ks);
71952648411SRobert Watson 	if (error)
72052648411SRobert Watson 		goto err;
72152648411SRobert Watson #endif
722efaa6588SAlfred Perlstein 	if (ks->ks_value == SEM_VALUE_MAX) {
723efaa6588SAlfred Perlstein 		error = EOVERFLOW;
724efaa6588SAlfred Perlstein 		goto err;
725efaa6588SAlfred Perlstein 	}
726efaa6588SAlfred Perlstein 	++ks->ks_value;
727efaa6588SAlfred Perlstein 	if (ks->ks_waiters > 0)
728efaa6588SAlfred Perlstein 		cv_signal(&ks->ks_cv);
729efaa6588SAlfred Perlstein 	error = 0;
7306bc1e9cdSJohn Baldwin 	vfs_timestamp(&ks->ks_ctime);
731efaa6588SAlfred Perlstein err:
732efaa6588SAlfred Perlstein 	mtx_unlock(&sem_lock);
7336bc1e9cdSJohn Baldwin 	fdrop(fp, td);
734efaa6588SAlfred Perlstein 	return (error);
735efaa6588SAlfred Perlstein }
736efaa6588SAlfred Perlstein 
737efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
738efaa6588SAlfred Perlstein struct ksem_wait_args {
739efaa6588SAlfred Perlstein 	semid_t		id;
740efaa6588SAlfred Perlstein };
741efaa6588SAlfred Perlstein #endif
742efaa6588SAlfred Perlstein int
7438451d0ddSKip Macy sys_ksem_wait(struct thread *td, struct ksem_wait_args *uap)
744efaa6588SAlfred Perlstein {
745efaa6588SAlfred Perlstein 
746aae94fbbSDaniel Eischen 	return (kern_sem_wait(td, uap->id, 0, NULL));
747aae94fbbSDaniel Eischen }
748aae94fbbSDaniel Eischen 
749aae94fbbSDaniel Eischen #ifndef _SYS_SYSPROTO_H_
750aae94fbbSDaniel Eischen struct ksem_timedwait_args {
751aae94fbbSDaniel Eischen 	semid_t		id;
752d60e86c8SStefan Farfeleder 	const struct timespec *abstime;
753aae94fbbSDaniel Eischen };
754aae94fbbSDaniel Eischen #endif
755aae94fbbSDaniel Eischen int
7568451d0ddSKip Macy sys_ksem_timedwait(struct thread *td, struct ksem_timedwait_args *uap)
757aae94fbbSDaniel Eischen {
758aae94fbbSDaniel Eischen 	struct timespec abstime;
759aae94fbbSDaniel Eischen 	struct timespec *ts;
760aae94fbbSDaniel Eischen 	int error;
761aae94fbbSDaniel Eischen 
7628e230e30SRobert Watson 	/*
7638e230e30SRobert Watson 	 * We allow a null timespec (wait forever).
7648e230e30SRobert Watson 	 */
765aae94fbbSDaniel Eischen 	if (uap->abstime == NULL)
766aae94fbbSDaniel Eischen 		ts = NULL;
767aae94fbbSDaniel Eischen 	else {
768aae94fbbSDaniel Eischen 		error = copyin(uap->abstime, &abstime, sizeof(abstime));
769aae94fbbSDaniel Eischen 		if (error != 0)
770aae94fbbSDaniel Eischen 			return (error);
771aae94fbbSDaniel Eischen 		if (abstime.tv_nsec >= 1000000000 || abstime.tv_nsec < 0)
772aae94fbbSDaniel Eischen 			return (EINVAL);
773aae94fbbSDaniel Eischen 		ts = &abstime;
774aae94fbbSDaniel Eischen 	}
775aae94fbbSDaniel Eischen 	return (kern_sem_wait(td, uap->id, 0, ts));
776efaa6588SAlfred Perlstein }
777efaa6588SAlfred Perlstein 
778efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
779efaa6588SAlfred Perlstein struct ksem_trywait_args {
780efaa6588SAlfred Perlstein 	semid_t		id;
781efaa6588SAlfred Perlstein };
782efaa6588SAlfred Perlstein #endif
783efaa6588SAlfred Perlstein int
7848451d0ddSKip Macy sys_ksem_trywait(struct thread *td, struct ksem_trywait_args *uap)
785efaa6588SAlfred Perlstein {
786efaa6588SAlfred Perlstein 
787aae94fbbSDaniel Eischen 	return (kern_sem_wait(td, uap->id, 1, NULL));
788efaa6588SAlfred Perlstein }
789efaa6588SAlfred Perlstein 
790c3053131SPoul-Henning Kamp static int
791c1250af6SRobert Watson kern_sem_wait(struct thread *td, semid_t id, int tryflag,
792c1250af6SRobert Watson     struct timespec *abstime)
793efaa6588SAlfred Perlstein {
794aae94fbbSDaniel Eischen 	struct timespec ts1, ts2;
795aae94fbbSDaniel Eischen 	struct timeval tv;
7966bc1e9cdSJohn Baldwin 	struct file *fp;
797efaa6588SAlfred Perlstein 	struct ksem *ks;
798efaa6588SAlfred Perlstein 	int error;
799efaa6588SAlfred Perlstein 
800b2966a5aSBruce M Simpson 	DP((">>> kern_sem_wait entered! pid=%d\n", (int)td->td_proc->p_pid));
801a9d2f8d8SRobert Watson 	error = ksem_get(td, id, CAP_SEM_WAIT, &fp);
8026bc1e9cdSJohn Baldwin 	if (error)
8036bc1e9cdSJohn Baldwin 		return (error);
8046bc1e9cdSJohn Baldwin 	ks = fp->f_data;
805efaa6588SAlfred Perlstein 	mtx_lock(&sem_lock);
806b2966a5aSBruce M Simpson 	DP((">>> kern_sem_wait critical section entered! pid=%d\n",
807b2966a5aSBruce M Simpson 	    (int)td->td_proc->p_pid));
80852648411SRobert Watson #ifdef MAC
8096bc1e9cdSJohn Baldwin 	error = mac_posixsem_check_wait(td->td_ucred, fp->f_cred, ks);
81052648411SRobert Watson 	if (error) {
81152648411SRobert Watson 		DP(("kern_sem_wait mac failed\n"));
81252648411SRobert Watson 		goto err;
81352648411SRobert Watson 	}
81452648411SRobert Watson #endif
815c814aa3fSAlfred Perlstein 	DP(("kern_sem_wait value = %d, tryflag %d\n", ks->ks_value, tryflag));
8166bc1e9cdSJohn Baldwin 	vfs_timestamp(&ks->ks_atime);
81777d8bf9cSBruce M Simpson 	while (ks->ks_value == 0) {
818efaa6588SAlfred Perlstein 		ks->ks_waiters++;
819aae94fbbSDaniel Eischen 		if (tryflag != 0)
820aae94fbbSDaniel Eischen 			error = EAGAIN;
821aae94fbbSDaniel Eischen 		else if (abstime == NULL)
822aae94fbbSDaniel Eischen 			error = cv_wait_sig(&ks->ks_cv, &sem_lock);
823aae94fbbSDaniel Eischen 		else {
824aae94fbbSDaniel Eischen 			for (;;) {
825aae94fbbSDaniel Eischen 				ts1 = *abstime;
826aae94fbbSDaniel Eischen 				getnanotime(&ts2);
827aae94fbbSDaniel Eischen 				timespecsub(&ts1, &ts2);
828aae94fbbSDaniel Eischen 				TIMESPEC_TO_TIMEVAL(&tv, &ts1);
829aae94fbbSDaniel Eischen 				if (tv.tv_sec < 0) {
830aae94fbbSDaniel Eischen 					error = ETIMEDOUT;
831aae94fbbSDaniel Eischen 					break;
832aae94fbbSDaniel Eischen 				}
833aae94fbbSDaniel Eischen 				error = cv_timedwait_sig(&ks->ks_cv,
834aae94fbbSDaniel Eischen 				    &sem_lock, tvtohz(&tv));
835aae94fbbSDaniel Eischen 				if (error != EWOULDBLOCK)
836aae94fbbSDaniel Eischen 					break;
837aae94fbbSDaniel Eischen 			}
838aae94fbbSDaniel Eischen 		}
839efaa6588SAlfred Perlstein 		ks->ks_waiters--;
840efaa6588SAlfred Perlstein 		if (error)
841efaa6588SAlfred Perlstein 			goto err;
842efaa6588SAlfred Perlstein 	}
843efaa6588SAlfred Perlstein 	ks->ks_value--;
844b2966a5aSBruce M Simpson 	DP(("kern_sem_wait value post-decrement = %d\n", ks->ks_value));
845efaa6588SAlfred Perlstein 	error = 0;
846efaa6588SAlfred Perlstein err:
847efaa6588SAlfred Perlstein 	mtx_unlock(&sem_lock);
8486bc1e9cdSJohn Baldwin 	fdrop(fp, td);
849b2966a5aSBruce M Simpson 	DP(("<<< kern_sem_wait leaving, pid=%d, error = %d\n",
850b2966a5aSBruce M Simpson 	    (int)td->td_proc->p_pid, error));
851efaa6588SAlfred Perlstein 	return (error);
852efaa6588SAlfred Perlstein }
853efaa6588SAlfred Perlstein 
854efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
855efaa6588SAlfred Perlstein struct ksem_getvalue_args {
856efaa6588SAlfred Perlstein 	semid_t		id;
857efaa6588SAlfred Perlstein 	int		*val;
858efaa6588SAlfred Perlstein };
859efaa6588SAlfred Perlstein #endif
860efaa6588SAlfred Perlstein int
8618451d0ddSKip Macy sys_ksem_getvalue(struct thread *td, struct ksem_getvalue_args *uap)
862efaa6588SAlfred Perlstein {
8636bc1e9cdSJohn Baldwin 	struct file *fp;
864efaa6588SAlfred Perlstein 	struct ksem *ks;
865efaa6588SAlfred Perlstein 	int error, val;
866efaa6588SAlfred Perlstein 
867a9d2f8d8SRobert Watson 	error = ksem_get(td, uap->id, CAP_SEM_GETVALUE, &fp);
8686bc1e9cdSJohn Baldwin 	if (error)
8696bc1e9cdSJohn Baldwin 		return (error);
8706bc1e9cdSJohn Baldwin 	ks = fp->f_data;
8716bc1e9cdSJohn Baldwin 
872efaa6588SAlfred Perlstein 	mtx_lock(&sem_lock);
87352648411SRobert Watson #ifdef MAC
8746bc1e9cdSJohn Baldwin 	error = mac_posixsem_check_getvalue(td->td_ucred, fp->f_cred, ks);
87552648411SRobert Watson 	if (error) {
87652648411SRobert Watson 		mtx_unlock(&sem_lock);
8776bc1e9cdSJohn Baldwin 		fdrop(fp, td);
87852648411SRobert Watson 		return (error);
87952648411SRobert Watson 	}
88052648411SRobert Watson #endif
881efaa6588SAlfred Perlstein 	val = ks->ks_value;
8826bc1e9cdSJohn Baldwin 	vfs_timestamp(&ks->ks_atime);
883efaa6588SAlfred Perlstein 	mtx_unlock(&sem_lock);
8846bc1e9cdSJohn Baldwin 	fdrop(fp, td);
885efaa6588SAlfred Perlstein 	error = copyout(&val, uap->val, sizeof(val));
886efaa6588SAlfred Perlstein 	return (error);
887efaa6588SAlfred Perlstein }
888efaa6588SAlfred Perlstein 
889efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_
890efaa6588SAlfred Perlstein struct ksem_destroy_args {
891efaa6588SAlfred Perlstein 	semid_t		id;
892efaa6588SAlfred Perlstein };
893efaa6588SAlfred Perlstein #endif
894efaa6588SAlfred Perlstein int
8958451d0ddSKip Macy sys_ksem_destroy(struct thread *td, struct ksem_destroy_args *uap)
896efaa6588SAlfred Perlstein {
8976bc1e9cdSJohn Baldwin 	struct file *fp;
898efaa6588SAlfred Perlstein 	struct ksem *ks;
899efaa6588SAlfred Perlstein 	int error;
900efaa6588SAlfred Perlstein 
901a9d2f8d8SRobert Watson 	/* No capability rights required to close a semaphore. */
902a9d2f8d8SRobert Watson 	error = ksem_get(td, uap->id, 0, &fp);
9036bc1e9cdSJohn Baldwin 	if (error)
9046bc1e9cdSJohn Baldwin 		return (error);
9056bc1e9cdSJohn Baldwin 	ks = fp->f_data;
9066bc1e9cdSJohn Baldwin 	if (!(ks->ks_flags & KS_ANONYMOUS)) {
9076bc1e9cdSJohn Baldwin 		fdrop(fp, td);
9086bc1e9cdSJohn Baldwin 		return (EINVAL);
909efaa6588SAlfred Perlstein 	}
9106bc1e9cdSJohn Baldwin 	mtx_lock(&sem_lock);
911efaa6588SAlfred Perlstein 	if (ks->ks_waiters != 0) {
9126bc1e9cdSJohn Baldwin 		mtx_unlock(&sem_lock);
913efaa6588SAlfred Perlstein 		error = EBUSY;
914efaa6588SAlfred Perlstein 		goto err;
915efaa6588SAlfred Perlstein 	}
9166bc1e9cdSJohn Baldwin 	ks->ks_flags |= KS_DEAD;
917efaa6588SAlfred Perlstein 	mtx_unlock(&sem_lock);
9186bc1e9cdSJohn Baldwin 
9196bc1e9cdSJohn Baldwin 	error = kern_close(td, uap->id);
9206bc1e9cdSJohn Baldwin err:
9216bc1e9cdSJohn Baldwin 	fdrop(fp, td);
922efaa6588SAlfred Perlstein 	return (error);
923efaa6588SAlfred Perlstein }
924efaa6588SAlfred Perlstein 
9250e5d5bc2SKonstantin Belousov static struct syscall_helper_data ksem_syscalls[] = {
9260e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_init),
9270e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_open),
9280e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_unlink),
9290e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_close),
9300e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_post),
9310e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_wait),
9320e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_timedwait),
9330e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_trywait),
9340e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_getvalue),
9350e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_HELPER(ksem_destroy),
9360e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_LAST
9370e5d5bc2SKonstantin Belousov };
9386bc1e9cdSJohn Baldwin 
9390e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32
9400e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32.h>
9410e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_proto.h>
9420e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_signal.h>
9430e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_syscall.h>
9440e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_util.h>
9456bc1e9cdSJohn Baldwin 
9460e5d5bc2SKonstantin Belousov int
9470e5d5bc2SKonstantin Belousov freebsd32_ksem_init(struct thread *td, struct freebsd32_ksem_init_args *uap)
9480e5d5bc2SKonstantin Belousov {
9496bc1e9cdSJohn Baldwin 
9500e5d5bc2SKonstantin Belousov 	return (ksem_create(td, NULL, uap->idp, S_IRWXU | S_IRWXG, uap->value,
9510e5d5bc2SKonstantin Belousov 	    0, 1));
9520e5d5bc2SKonstantin Belousov }
9530e5d5bc2SKonstantin Belousov 
9540e5d5bc2SKonstantin Belousov int
9550e5d5bc2SKonstantin Belousov freebsd32_ksem_open(struct thread *td, struct freebsd32_ksem_open_args *uap)
9560e5d5bc2SKonstantin Belousov {
9570e5d5bc2SKonstantin Belousov 
9580e5d5bc2SKonstantin Belousov 	if ((uap->oflag & ~(O_CREAT | O_EXCL)) != 0)
9590e5d5bc2SKonstantin Belousov 		return (EINVAL);
9600e5d5bc2SKonstantin Belousov 	return (ksem_create(td, uap->name, uap->idp, uap->mode, uap->value,
9610e5d5bc2SKonstantin Belousov 	    uap->oflag, 1));
9620e5d5bc2SKonstantin Belousov }
9630e5d5bc2SKonstantin Belousov 
9640e5d5bc2SKonstantin Belousov int
9650e5d5bc2SKonstantin Belousov freebsd32_ksem_timedwait(struct thread *td,
9660e5d5bc2SKonstantin Belousov     struct freebsd32_ksem_timedwait_args *uap)
9670e5d5bc2SKonstantin Belousov {
9680e5d5bc2SKonstantin Belousov 	struct timespec32 abstime32;
9690e5d5bc2SKonstantin Belousov 	struct timespec *ts, abstime;
9700e5d5bc2SKonstantin Belousov 	int error;
9710e5d5bc2SKonstantin Belousov 
9720e5d5bc2SKonstantin Belousov 	/*
9730e5d5bc2SKonstantin Belousov 	 * We allow a null timespec (wait forever).
9740e5d5bc2SKonstantin Belousov 	 */
9750e5d5bc2SKonstantin Belousov 	if (uap->abstime == NULL)
9760e5d5bc2SKonstantin Belousov 		ts = NULL;
9770e5d5bc2SKonstantin Belousov 	else {
9780e5d5bc2SKonstantin Belousov 		error = copyin(uap->abstime, &abstime32, sizeof(abstime32));
9790e5d5bc2SKonstantin Belousov 		if (error != 0)
9800e5d5bc2SKonstantin Belousov 			return (error);
9810e5d5bc2SKonstantin Belousov 		CP(abstime32, abstime, tv_sec);
9820e5d5bc2SKonstantin Belousov 		CP(abstime32, abstime, tv_nsec);
9830e5d5bc2SKonstantin Belousov 		if (abstime.tv_nsec >= 1000000000 || abstime.tv_nsec < 0)
9840e5d5bc2SKonstantin Belousov 			return (EINVAL);
9850e5d5bc2SKonstantin Belousov 		ts = &abstime;
9860e5d5bc2SKonstantin Belousov 	}
9870e5d5bc2SKonstantin Belousov 	return (kern_sem_wait(td, uap->id, 0, ts));
9880e5d5bc2SKonstantin Belousov }
9890e5d5bc2SKonstantin Belousov 
9900e5d5bc2SKonstantin Belousov static struct syscall_helper_data ksem32_syscalls[] = {
9910e5d5bc2SKonstantin Belousov 	SYSCALL32_INIT_HELPER(freebsd32_ksem_init),
9920e5d5bc2SKonstantin Belousov 	SYSCALL32_INIT_HELPER(freebsd32_ksem_open),
9938451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_unlink),
9948451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_close),
9958451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_post),
9968451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_wait),
9970e5d5bc2SKonstantin Belousov 	SYSCALL32_INIT_HELPER(freebsd32_ksem_timedwait),
9988451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_trywait),
9998451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_getvalue),
10008451d0ddSKip Macy 	SYSCALL32_INIT_HELPER_COMPAT(ksem_destroy),
10010e5d5bc2SKonstantin Belousov 	SYSCALL_INIT_LAST
10020e5d5bc2SKonstantin Belousov };
10030e5d5bc2SKonstantin Belousov #endif
10046bc1e9cdSJohn Baldwin 
1005590f242cSRobert Watson static int
10066bc1e9cdSJohn Baldwin ksem_module_init(void)
1007590f242cSRobert Watson {
10086bc1e9cdSJohn Baldwin 	int error;
1009590f242cSRobert Watson 
10106bc1e9cdSJohn Baldwin 	mtx_init(&sem_lock, "sem", NULL, MTX_DEF);
10116bc1e9cdSJohn Baldwin 	mtx_init(&ksem_count_lock, "ksem count", NULL, MTX_DEF);
10126bc1e9cdSJohn Baldwin 	sx_init(&ksem_dict_lock, "ksem dictionary");
10136bc1e9cdSJohn Baldwin 	ksem_dictionary = hashinit(1024, M_KSEM, &ksem_hash);
10142e7758a8SJohn Baldwin 	p31b_setcfg(CTL_P1003_1B_SEMAPHORES, 200112L);
10156bc1e9cdSJohn Baldwin 	p31b_setcfg(CTL_P1003_1B_SEM_NSEMS_MAX, SEM_MAX);
10166bc1e9cdSJohn Baldwin 	p31b_setcfg(CTL_P1003_1B_SEM_VALUE_MAX, SEM_VALUE_MAX);
1017590f242cSRobert Watson 
10180e5d5bc2SKonstantin Belousov 	error = syscall_helper_register(ksem_syscalls);
10190e5d5bc2SKonstantin Belousov 	if (error)
10200e5d5bc2SKonstantin Belousov 		return (error);
10210e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32
10220e5d5bc2SKonstantin Belousov 	error = syscall32_helper_register(ksem32_syscalls);
10230e5d5bc2SKonstantin Belousov 	if (error)
10240e5d5bc2SKonstantin Belousov 		return (error);
10250e5d5bc2SKonstantin Belousov #endif
10266bc1e9cdSJohn Baldwin 	return (0);
1027590f242cSRobert Watson }
1028590f242cSRobert Watson 
1029c3053131SPoul-Henning Kamp static void
10306bc1e9cdSJohn Baldwin ksem_module_destroy(void)
1031993182e5SAlexander Leidinger {
1032993182e5SAlexander Leidinger 
10330e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32
10340e5d5bc2SKonstantin Belousov 	syscall32_helper_unregister(ksem32_syscalls);
10350e5d5bc2SKonstantin Belousov #endif
10360e5d5bc2SKonstantin Belousov 	syscall_helper_unregister(ksem_syscalls);
1037efaa6588SAlfred Perlstein 
10382e7758a8SJohn Baldwin 	p31b_setcfg(CTL_P1003_1B_SEMAPHORES, 0);
10396bc1e9cdSJohn Baldwin 	hashdestroy(ksem_dictionary, M_KSEM, ksem_hash);
10406bc1e9cdSJohn Baldwin 	sx_destroy(&ksem_dict_lock);
10416bc1e9cdSJohn Baldwin 	mtx_destroy(&ksem_count_lock);
10426bc1e9cdSJohn Baldwin 	mtx_destroy(&sem_lock);
104332863754SKonstantin Belousov 	p31b_unsetcfg(CTL_P1003_1B_SEM_VALUE_MAX);
104432863754SKonstantin Belousov 	p31b_unsetcfg(CTL_P1003_1B_SEM_NSEMS_MAX);
1045efaa6588SAlfred Perlstein }
1046efaa6588SAlfred Perlstein 
1047efaa6588SAlfred Perlstein static int
1048efaa6588SAlfred Perlstein sem_modload(struct module *module, int cmd, void *arg)
1049efaa6588SAlfred Perlstein {
1050efaa6588SAlfred Perlstein         int error = 0;
1051efaa6588SAlfred Perlstein 
1052efaa6588SAlfred Perlstein         switch (cmd) {
1053efaa6588SAlfred Perlstein         case MOD_LOAD:
10546bc1e9cdSJohn Baldwin 		error = ksem_module_init();
10556bc1e9cdSJohn Baldwin 		if (error)
10566bc1e9cdSJohn Baldwin 			ksem_module_destroy();
1057efaa6588SAlfred Perlstein                 break;
10588e230e30SRobert Watson 
1059efaa6588SAlfred Perlstein         case MOD_UNLOAD:
10606bc1e9cdSJohn Baldwin 		mtx_lock(&ksem_count_lock);
1061efaa6588SAlfred Perlstein 		if (nsems != 0) {
1062efaa6588SAlfred Perlstein 			error = EOPNOTSUPP;
10636bc1e9cdSJohn Baldwin 			mtx_unlock(&ksem_count_lock);
1064efaa6588SAlfred Perlstein 			break;
1065efaa6588SAlfred Perlstein 		}
10666bc1e9cdSJohn Baldwin 		ksem_dead = 1;
10676bc1e9cdSJohn Baldwin 		mtx_unlock(&ksem_count_lock);
10686bc1e9cdSJohn Baldwin 		ksem_module_destroy();
1069efaa6588SAlfred Perlstein                 break;
10708e230e30SRobert Watson 
1071efaa6588SAlfred Perlstein         case MOD_SHUTDOWN:
1072efaa6588SAlfred Perlstein                 break;
1073efaa6588SAlfred Perlstein         default:
1074efaa6588SAlfred Perlstein                 error = EINVAL;
1075efaa6588SAlfred Perlstein                 break;
1076efaa6588SAlfred Perlstein         }
1077efaa6588SAlfred Perlstein         return (error);
1078efaa6588SAlfred Perlstein }
1079efaa6588SAlfred Perlstein 
1080efaa6588SAlfred Perlstein static moduledata_t sem_mod = {
1081efaa6588SAlfred Perlstein         "sem",
1082efaa6588SAlfred Perlstein         &sem_modload,
1083efaa6588SAlfred Perlstein         NULL
1084efaa6588SAlfred Perlstein };
1085efaa6588SAlfred Perlstein 
1086efaa6588SAlfred Perlstein DECLARE_MODULE(sem, sem_mod, SI_SUB_SYSV_SEM, SI_ORDER_FIRST);
1087efaa6588SAlfred Perlstein MODULE_VERSION(sem, 1);
1088