19454b2d8SWarner Losh /*- 28a36da99SPedro F. Giffuni * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 38a36da99SPedro F. Giffuni * 4efaa6588SAlfred Perlstein * Copyright (c) 2002 Alfred Perlstein <alfred@FreeBSD.org> 552648411SRobert Watson * Copyright (c) 2003-2005 SPARTA, Inc. 615bcf785SRobert Watson * Copyright (c) 2005, 2016-2017 Robert N. M. Watson 7efaa6588SAlfred Perlstein * All rights reserved. 8efaa6588SAlfred Perlstein * 952648411SRobert Watson * This software was developed for the FreeBSD Project in part by Network 1052648411SRobert Watson * Associates Laboratories, the Security Research Division of Network 1152648411SRobert Watson * Associates, Inc. under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), 1252648411SRobert Watson * as part of the DARPA CHATS research program. 1352648411SRobert Watson * 1415bcf785SRobert Watson * Portions of this software were developed by BAE Systems, the University of 1515bcf785SRobert Watson * Cambridge Computer Laboratory, and Memorial University under DARPA/AFRL 1615bcf785SRobert Watson * contract FA8650-15-C-7558 ("CADETS"), as part of the DARPA Transparent 1715bcf785SRobert Watson * Computing (TC) research program. 1815bcf785SRobert Watson * 19efaa6588SAlfred Perlstein * Redistribution and use in source and binary forms, with or without 20efaa6588SAlfred Perlstein * modification, are permitted provided that the following conditions 21efaa6588SAlfred Perlstein * are met: 22efaa6588SAlfred Perlstein * 1. Redistributions of source code must retain the above copyright 23efaa6588SAlfred Perlstein * notice, this list of conditions and the following disclaimer. 24efaa6588SAlfred Perlstein * 2. Redistributions in binary form must reproduce the above copyright 25efaa6588SAlfred Perlstein * notice, this list of conditions and the following disclaimer in the 26efaa6588SAlfred Perlstein * documentation and/or other materials provided with the distribution. 27efaa6588SAlfred Perlstein * 28efaa6588SAlfred Perlstein * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 29efaa6588SAlfred Perlstein * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30efaa6588SAlfred Perlstein * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31efaa6588SAlfred Perlstein * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 32efaa6588SAlfred Perlstein * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33efaa6588SAlfred Perlstein * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34efaa6588SAlfred Perlstein * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35efaa6588SAlfred Perlstein * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36efaa6588SAlfred Perlstein * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37efaa6588SAlfred Perlstein * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38efaa6588SAlfred Perlstein * SUCH DAMAGE. 39efaa6588SAlfred Perlstein */ 40efaa6588SAlfred Perlstein 41677b542eSDavid E. O'Brien #include <sys/cdefs.h> 42677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 43677b542eSDavid E. O'Brien 44efaa6588SAlfred Perlstein #include "opt_posix.h" 45efaa6588SAlfred Perlstein 46efaa6588SAlfred Perlstein #include <sys/param.h> 474a144410SRobert Watson #include <sys/capsicum.h> 486bc1e9cdSJohn Baldwin #include <sys/condvar.h> 496bc1e9cdSJohn Baldwin #include <sys/fcntl.h> 506bc1e9cdSJohn Baldwin #include <sys/file.h> 516bc1e9cdSJohn Baldwin #include <sys/filedesc.h> 526bc1e9cdSJohn Baldwin #include <sys/fnv_hash.h> 53cc7b259aSJamie Gritton #include <sys/jail.h> 54efaa6588SAlfred Perlstein #include <sys/kernel.h> 556aeb05d7STom Rhodes #include <sys/ksem.h> 566bc1e9cdSJohn Baldwin #include <sys/lock.h> 576bc1e9cdSJohn Baldwin #include <sys/malloc.h> 586bc1e9cdSJohn Baldwin #include <sys/module.h> 596bc1e9cdSJohn Baldwin #include <sys/mutex.h> 60acd3428bSRobert Watson #include <sys/priv.h> 61efaa6588SAlfred Perlstein #include <sys/proc.h> 626aeb05d7STom Rhodes #include <sys/posix4.h> 636aeb05d7STom Rhodes #include <sys/_semaphore.h> 646bc1e9cdSJohn Baldwin #include <sys/stat.h> 656bc1e9cdSJohn Baldwin #include <sys/syscall.h> 666bc1e9cdSJohn Baldwin #include <sys/syscallsubr.h> 676bc1e9cdSJohn Baldwin #include <sys/sysctl.h> 686bc1e9cdSJohn Baldwin #include <sys/sysent.h> 696bc1e9cdSJohn Baldwin #include <sys/sysproto.h> 706bc1e9cdSJohn Baldwin #include <sys/systm.h> 716bc1e9cdSJohn Baldwin #include <sys/sx.h> 729696feebSJohn Baldwin #include <sys/user.h> 736bc1e9cdSJohn Baldwin #include <sys/vnode.h> 74efaa6588SAlfred Perlstein 7515bcf785SRobert Watson #include <security/audit/audit.h> 76aed55708SRobert Watson #include <security/mac/mac_framework.h> 77aed55708SRobert Watson 789a253c10SAlexander Leidinger FEATURE(p1003_1b_semaphores, "POSIX P1003.1B semaphores support"); 796bc1e9cdSJohn Baldwin /* 806bc1e9cdSJohn Baldwin * TODO 816bc1e9cdSJohn Baldwin * 826bc1e9cdSJohn Baldwin * - Resource limits? 836bc1e9cdSJohn Baldwin * - Replace global sem_lock with mtx_pool locks? 846bc1e9cdSJohn Baldwin * - Add a MAC check_create() hook for creating new named semaphores. 856bc1e9cdSJohn Baldwin */ 86efaa6588SAlfred Perlstein 87efaa6588SAlfred Perlstein #ifndef SEM_MAX 88efaa6588SAlfred Perlstein #define SEM_MAX 30 89efaa6588SAlfred Perlstein #endif 90efaa6588SAlfred Perlstein 91c814aa3fSAlfred Perlstein #ifdef SEM_DEBUG 92c814aa3fSAlfred Perlstein #define DP(x) printf x 93c814aa3fSAlfred Perlstein #else 94c814aa3fSAlfred Perlstein #define DP(x) 95c814aa3fSAlfred Perlstein #endif 96c814aa3fSAlfred Perlstein 976bc1e9cdSJohn Baldwin struct ksem_mapping { 986bc1e9cdSJohn Baldwin char *km_path; 996bc1e9cdSJohn Baldwin Fnv32_t km_fnv; 1006bc1e9cdSJohn Baldwin struct ksem *km_ksem; 1016bc1e9cdSJohn Baldwin LIST_ENTRY(ksem_mapping) km_link; 1026bc1e9cdSJohn Baldwin }; 1036bc1e9cdSJohn Baldwin 1046bc1e9cdSJohn Baldwin static MALLOC_DEFINE(M_KSEM, "ksem", "semaphore file descriptor"); 1056bc1e9cdSJohn Baldwin static LIST_HEAD(, ksem_mapping) *ksem_dictionary; 1066bc1e9cdSJohn Baldwin static struct sx ksem_dict_lock; 1076bc1e9cdSJohn Baldwin static struct mtx ksem_count_lock; 1086bc1e9cdSJohn Baldwin static struct mtx sem_lock; 1096bc1e9cdSJohn Baldwin static u_long ksem_hash; 1106bc1e9cdSJohn Baldwin static int ksem_dead; 1116bc1e9cdSJohn Baldwin 1126bc1e9cdSJohn Baldwin #define KSEM_HASH(fnv) (&ksem_dictionary[(fnv) & ksem_hash]) 1136bc1e9cdSJohn Baldwin 1146bc1e9cdSJohn Baldwin static int nsems = 0; 1156bc1e9cdSJohn Baldwin SYSCTL_DECL(_p1003_1b); 1166bc1e9cdSJohn Baldwin SYSCTL_INT(_p1003_1b, OID_AUTO, nsems, CTLFLAG_RD, &nsems, 0, 1176bc1e9cdSJohn Baldwin "Number of active kernel POSIX semaphores"); 1186bc1e9cdSJohn Baldwin 1196bc1e9cdSJohn Baldwin static int kern_sem_wait(struct thread *td, semid_t id, int tryflag, 1206bc1e9cdSJohn Baldwin struct timespec *abstime); 1216bc1e9cdSJohn Baldwin static int ksem_access(struct ksem *ks, struct ucred *ucred); 1226bc1e9cdSJohn Baldwin static struct ksem *ksem_alloc(struct ucred *ucred, mode_t mode, 1236bc1e9cdSJohn Baldwin unsigned int value); 1246bc1e9cdSJohn Baldwin static int ksem_create(struct thread *td, const char *path, 1256bc1e9cdSJohn Baldwin semid_t *semidp, mode_t mode, unsigned int value, 1260e5d5bc2SKonstantin Belousov int flags, int compat32); 1276bc1e9cdSJohn Baldwin static void ksem_drop(struct ksem *ks); 1287008be5bSPawel Jakub Dawidek static int ksem_get(struct thread *td, semid_t id, cap_rights_t *rightsp, 129a9d2f8d8SRobert Watson struct file **fpp); 1306bc1e9cdSJohn Baldwin static struct ksem *ksem_hold(struct ksem *ks); 1316bc1e9cdSJohn Baldwin static void ksem_insert(char *path, Fnv32_t fnv, struct ksem *ks); 1326bc1e9cdSJohn Baldwin static struct ksem *ksem_lookup(char *path, Fnv32_t fnv); 1336bc1e9cdSJohn Baldwin static void ksem_module_destroy(void); 1346bc1e9cdSJohn Baldwin static int ksem_module_init(void); 1356bc1e9cdSJohn Baldwin static int ksem_remove(char *path, Fnv32_t fnv, struct ucred *ucred); 1366bc1e9cdSJohn Baldwin static int sem_modload(struct module *module, int cmd, void *arg); 1376bc1e9cdSJohn Baldwin 1386bc1e9cdSJohn Baldwin static fo_stat_t ksem_stat; 1396bc1e9cdSJohn Baldwin static fo_close_t ksem_closef; 1409c00bb91SKonstantin Belousov static fo_chmod_t ksem_chmod; 1419c00bb91SKonstantin Belousov static fo_chown_t ksem_chown; 1429696feebSJohn Baldwin static fo_fill_kinfo_t ksem_fill_kinfo; 1436bc1e9cdSJohn Baldwin 1446bc1e9cdSJohn Baldwin /* File descriptor operations. */ 1456bc1e9cdSJohn Baldwin static struct fileops ksem_ops = { 1462d69d0dcSJohn Baldwin .fo_read = invfo_rdwr, 1472d69d0dcSJohn Baldwin .fo_write = invfo_rdwr, 1482d69d0dcSJohn Baldwin .fo_truncate = invfo_truncate, 1492d69d0dcSJohn Baldwin .fo_ioctl = invfo_ioctl, 1502d69d0dcSJohn Baldwin .fo_poll = invfo_poll, 1512d69d0dcSJohn Baldwin .fo_kqfilter = invfo_kqfilter, 1526bc1e9cdSJohn Baldwin .fo_stat = ksem_stat, 1536bc1e9cdSJohn Baldwin .fo_close = ksem_closef, 1549c00bb91SKonstantin Belousov .fo_chmod = ksem_chmod, 1559c00bb91SKonstantin Belousov .fo_chown = ksem_chown, 156ca04d21dSGleb Smirnoff .fo_sendfile = invfo_sendfile, 1579696feebSJohn Baldwin .fo_fill_kinfo = ksem_fill_kinfo, 1586bc1e9cdSJohn Baldwin .fo_flags = DFLAG_PASSABLE 1596bc1e9cdSJohn Baldwin }; 1606bc1e9cdSJohn Baldwin 1616bc1e9cdSJohn Baldwin FEATURE(posix_sem, "POSIX semaphores"); 1626bc1e9cdSJohn Baldwin 1636bc1e9cdSJohn Baldwin static int 1646bc1e9cdSJohn Baldwin ksem_stat(struct file *fp, struct stat *sb, struct ucred *active_cred, 1656bc1e9cdSJohn Baldwin struct thread *td) 1666bc1e9cdSJohn Baldwin { 1676bc1e9cdSJohn Baldwin struct ksem *ks; 1686bc1e9cdSJohn Baldwin #ifdef MAC 1696bc1e9cdSJohn Baldwin int error; 1706bc1e9cdSJohn Baldwin #endif 1716bc1e9cdSJohn Baldwin 1726bc1e9cdSJohn Baldwin ks = fp->f_data; 1736bc1e9cdSJohn Baldwin 1746bc1e9cdSJohn Baldwin #ifdef MAC 1756bc1e9cdSJohn Baldwin error = mac_posixsem_check_stat(active_cred, fp->f_cred, ks); 1766bc1e9cdSJohn Baldwin if (error) 1776bc1e9cdSJohn Baldwin return (error); 1786bc1e9cdSJohn Baldwin #endif 1796bc1e9cdSJohn Baldwin 1806bc1e9cdSJohn Baldwin /* 1816bc1e9cdSJohn Baldwin * Attempt to return sanish values for fstat() on a semaphore 1826bc1e9cdSJohn Baldwin * file descriptor. 1836bc1e9cdSJohn Baldwin */ 1846bc1e9cdSJohn Baldwin bzero(sb, sizeof(*sb)); 1856bc1e9cdSJohn Baldwin 1869c00bb91SKonstantin Belousov mtx_lock(&sem_lock); 187510ea843SEd Schouten sb->st_atim = ks->ks_atime; 188510ea843SEd Schouten sb->st_ctim = ks->ks_ctime; 189510ea843SEd Schouten sb->st_mtim = ks->ks_mtime; 190510ea843SEd Schouten sb->st_birthtim = ks->ks_birthtime; 1916bc1e9cdSJohn Baldwin sb->st_uid = ks->ks_uid; 1926bc1e9cdSJohn Baldwin sb->st_gid = ks->ks_gid; 1939c00bb91SKonstantin Belousov sb->st_mode = S_IFREG | ks->ks_mode; /* XXX */ 1949c00bb91SKonstantin Belousov mtx_unlock(&sem_lock); 1956bc1e9cdSJohn Baldwin 1966bc1e9cdSJohn Baldwin return (0); 1976bc1e9cdSJohn Baldwin } 1986bc1e9cdSJohn Baldwin 1996bc1e9cdSJohn Baldwin static int 2009c00bb91SKonstantin Belousov ksem_chmod(struct file *fp, mode_t mode, struct ucred *active_cred, 2019c00bb91SKonstantin Belousov struct thread *td) 2029c00bb91SKonstantin Belousov { 2039c00bb91SKonstantin Belousov struct ksem *ks; 2049c00bb91SKonstantin Belousov int error; 2059c00bb91SKonstantin Belousov 2069c00bb91SKonstantin Belousov error = 0; 2079c00bb91SKonstantin Belousov ks = fp->f_data; 2089c00bb91SKonstantin Belousov mtx_lock(&sem_lock); 2099c00bb91SKonstantin Belousov #ifdef MAC 2109c00bb91SKonstantin Belousov error = mac_posixsem_check_setmode(active_cred, ks, mode); 2119c00bb91SKonstantin Belousov if (error != 0) 2129c00bb91SKonstantin Belousov goto out; 2139c00bb91SKonstantin Belousov #endif 2149c00bb91SKonstantin Belousov error = vaccess(VREG, ks->ks_mode, ks->ks_uid, ks->ks_gid, VADMIN, 2159c00bb91SKonstantin Belousov active_cred, NULL); 2169c00bb91SKonstantin Belousov if (error != 0) 2179c00bb91SKonstantin Belousov goto out; 2189c00bb91SKonstantin Belousov ks->ks_mode = mode & ACCESSPERMS; 2199c00bb91SKonstantin Belousov out: 2209c00bb91SKonstantin Belousov mtx_unlock(&sem_lock); 2219c00bb91SKonstantin Belousov return (error); 2229c00bb91SKonstantin Belousov } 2239c00bb91SKonstantin Belousov 2249c00bb91SKonstantin Belousov static int 2259c00bb91SKonstantin Belousov ksem_chown(struct file *fp, uid_t uid, gid_t gid, struct ucred *active_cred, 2269c00bb91SKonstantin Belousov struct thread *td) 2279c00bb91SKonstantin Belousov { 2289c00bb91SKonstantin Belousov struct ksem *ks; 2299c00bb91SKonstantin Belousov int error; 2309c00bb91SKonstantin Belousov 23168889ed6SKonstantin Belousov error = 0; 2329c00bb91SKonstantin Belousov ks = fp->f_data; 2339c00bb91SKonstantin Belousov mtx_lock(&sem_lock); 2349c00bb91SKonstantin Belousov #ifdef MAC 2359c00bb91SKonstantin Belousov error = mac_posixsem_check_setowner(active_cred, ks, uid, gid); 2369c00bb91SKonstantin Belousov if (error != 0) 2379c00bb91SKonstantin Belousov goto out; 2389c00bb91SKonstantin Belousov #endif 2399c00bb91SKonstantin Belousov if (uid == (uid_t)-1) 2409c00bb91SKonstantin Belousov uid = ks->ks_uid; 2419c00bb91SKonstantin Belousov if (gid == (gid_t)-1) 2429c00bb91SKonstantin Belousov gid = ks->ks_gid; 2439c00bb91SKonstantin Belousov if (((uid != ks->ks_uid && uid != active_cred->cr_uid) || 2449c00bb91SKonstantin Belousov (gid != ks->ks_gid && !groupmember(gid, active_cred))) && 2459c00bb91SKonstantin Belousov (error = priv_check_cred(active_cred, PRIV_VFS_CHOWN, 0))) 2469c00bb91SKonstantin Belousov goto out; 2479c00bb91SKonstantin Belousov ks->ks_uid = uid; 2489c00bb91SKonstantin Belousov ks->ks_gid = gid; 2499c00bb91SKonstantin Belousov out: 2509c00bb91SKonstantin Belousov mtx_unlock(&sem_lock); 2519c00bb91SKonstantin Belousov return (error); 2529c00bb91SKonstantin Belousov } 2539c00bb91SKonstantin Belousov 2549c00bb91SKonstantin Belousov static int 2556bc1e9cdSJohn Baldwin ksem_closef(struct file *fp, struct thread *td) 2566bc1e9cdSJohn Baldwin { 2576bc1e9cdSJohn Baldwin struct ksem *ks; 2586bc1e9cdSJohn Baldwin 2596bc1e9cdSJohn Baldwin ks = fp->f_data; 2606bc1e9cdSJohn Baldwin fp->f_data = NULL; 2616bc1e9cdSJohn Baldwin ksem_drop(ks); 2626bc1e9cdSJohn Baldwin 2636bc1e9cdSJohn Baldwin return (0); 2646bc1e9cdSJohn Baldwin } 2656bc1e9cdSJohn Baldwin 2669696feebSJohn Baldwin static int 2679696feebSJohn Baldwin ksem_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp) 2689696feebSJohn Baldwin { 269cc7b259aSJamie Gritton const char *path, *pr_path; 2709696feebSJohn Baldwin struct ksem *ks; 271cc7b259aSJamie Gritton size_t pr_pathlen; 2729696feebSJohn Baldwin 2739696feebSJohn Baldwin kif->kf_type = KF_TYPE_SEM; 2749696feebSJohn Baldwin ks = fp->f_data; 2759696feebSJohn Baldwin mtx_lock(&sem_lock); 2769696feebSJohn Baldwin kif->kf_un.kf_sem.kf_sem_value = ks->ks_value; 2779696feebSJohn Baldwin kif->kf_un.kf_sem.kf_sem_mode = S_IFREG | ks->ks_mode; /* XXX */ 2789696feebSJohn Baldwin mtx_unlock(&sem_lock); 2799696feebSJohn Baldwin if (ks->ks_path != NULL) { 2809696feebSJohn Baldwin sx_slock(&ksem_dict_lock); 28144c16975SJamie Gritton if (ks->ks_path != NULL) { 282cc7b259aSJamie Gritton path = ks->ks_path; 283cc7b259aSJamie Gritton pr_path = curthread->td_ucred->cr_prison->pr_path; 28444c16975SJamie Gritton if (strcmp(pr_path, "/") != 0) { 28544c16975SJamie Gritton /* Return the jail-rooted pathname. */ 286cc7b259aSJamie Gritton pr_pathlen = strlen(pr_path); 287cc7b259aSJamie Gritton if (strncmp(path, pr_path, pr_pathlen) == 0 && 288cc7b259aSJamie Gritton path[pr_pathlen] == '/') 289cc7b259aSJamie Gritton path += pr_pathlen; 290cc7b259aSJamie Gritton } 291cc7b259aSJamie Gritton strlcpy(kif->kf_path, path, sizeof(kif->kf_path)); 292cc7b259aSJamie Gritton } 2939696feebSJohn Baldwin sx_sunlock(&ksem_dict_lock); 2949696feebSJohn Baldwin } 2959696feebSJohn Baldwin return (0); 2969696feebSJohn Baldwin } 2979696feebSJohn Baldwin 2986bc1e9cdSJohn Baldwin /* 2996bc1e9cdSJohn Baldwin * ksem object management including creation and reference counting 3006bc1e9cdSJohn Baldwin * routines. 3016bc1e9cdSJohn Baldwin */ 3026bc1e9cdSJohn Baldwin static struct ksem * 3036bc1e9cdSJohn Baldwin ksem_alloc(struct ucred *ucred, mode_t mode, unsigned int value) 3046bc1e9cdSJohn Baldwin { 3056bc1e9cdSJohn Baldwin struct ksem *ks; 3066bc1e9cdSJohn Baldwin 3076bc1e9cdSJohn Baldwin mtx_lock(&ksem_count_lock); 3086bc1e9cdSJohn Baldwin if (nsems == p31b_getcfg(CTL_P1003_1B_SEM_NSEMS_MAX) || ksem_dead) { 3096bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 3106bc1e9cdSJohn Baldwin return (NULL); 3116bc1e9cdSJohn Baldwin } 3126bc1e9cdSJohn Baldwin nsems++; 3136bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 3146bc1e9cdSJohn Baldwin ks = malloc(sizeof(*ks), M_KSEM, M_WAITOK | M_ZERO); 3156bc1e9cdSJohn Baldwin ks->ks_uid = ucred->cr_uid; 3166bc1e9cdSJohn Baldwin ks->ks_gid = ucred->cr_gid; 3176bc1e9cdSJohn Baldwin ks->ks_mode = mode; 3186bc1e9cdSJohn Baldwin ks->ks_value = value; 3196bc1e9cdSJohn Baldwin cv_init(&ks->ks_cv, "ksem"); 3206bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_birthtime); 3216bc1e9cdSJohn Baldwin ks->ks_atime = ks->ks_mtime = ks->ks_ctime = ks->ks_birthtime; 3226bc1e9cdSJohn Baldwin refcount_init(&ks->ks_ref, 1); 3236bc1e9cdSJohn Baldwin #ifdef MAC 3246bc1e9cdSJohn Baldwin mac_posixsem_init(ks); 3256bc1e9cdSJohn Baldwin mac_posixsem_create(ucred, ks); 3266bc1e9cdSJohn Baldwin #endif 3276bc1e9cdSJohn Baldwin 3286bc1e9cdSJohn Baldwin return (ks); 3296bc1e9cdSJohn Baldwin } 3306bc1e9cdSJohn Baldwin 3316bc1e9cdSJohn Baldwin static struct ksem * 3326bc1e9cdSJohn Baldwin ksem_hold(struct ksem *ks) 3336bc1e9cdSJohn Baldwin { 3346bc1e9cdSJohn Baldwin 3356bc1e9cdSJohn Baldwin refcount_acquire(&ks->ks_ref); 3366bc1e9cdSJohn Baldwin return (ks); 3376bc1e9cdSJohn Baldwin } 3386bc1e9cdSJohn Baldwin 3396bc1e9cdSJohn Baldwin static void 3406bc1e9cdSJohn Baldwin ksem_drop(struct ksem *ks) 3416bc1e9cdSJohn Baldwin { 3426bc1e9cdSJohn Baldwin 3436bc1e9cdSJohn Baldwin if (refcount_release(&ks->ks_ref)) { 3446bc1e9cdSJohn Baldwin #ifdef MAC 3456bc1e9cdSJohn Baldwin mac_posixsem_destroy(ks); 3466bc1e9cdSJohn Baldwin #endif 3476bc1e9cdSJohn Baldwin cv_destroy(&ks->ks_cv); 3486bc1e9cdSJohn Baldwin free(ks, M_KSEM); 3496bc1e9cdSJohn Baldwin mtx_lock(&ksem_count_lock); 3506bc1e9cdSJohn Baldwin nsems--; 3516bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 3526bc1e9cdSJohn Baldwin } 3536bc1e9cdSJohn Baldwin } 3546bc1e9cdSJohn Baldwin 3556bc1e9cdSJohn Baldwin /* 3566bc1e9cdSJohn Baldwin * Determine if the credentials have sufficient permissions for read 3576bc1e9cdSJohn Baldwin * and write access. 3586bc1e9cdSJohn Baldwin */ 3596bc1e9cdSJohn Baldwin static int 3606bc1e9cdSJohn Baldwin ksem_access(struct ksem *ks, struct ucred *ucred) 3616bc1e9cdSJohn Baldwin { 362efaa6588SAlfred Perlstein int error; 363efaa6588SAlfred Perlstein 3646bc1e9cdSJohn Baldwin error = vaccess(VREG, ks->ks_mode, ks->ks_uid, ks->ks_gid, 3656bc1e9cdSJohn Baldwin VREAD | VWRITE, ucred, NULL); 3666bc1e9cdSJohn Baldwin if (error) 3676bc1e9cdSJohn Baldwin error = priv_check_cred(ucred, PRIV_SEM_WRITE, 0); 368efaa6588SAlfred Perlstein return (error); 369efaa6588SAlfred Perlstein } 370efaa6588SAlfred Perlstein 3716bc1e9cdSJohn Baldwin /* 3726bc1e9cdSJohn Baldwin * Dictionary management. We maintain an in-kernel dictionary to map 3736bc1e9cdSJohn Baldwin * paths to semaphore objects. We use the FNV hash on the path to 3746bc1e9cdSJohn Baldwin * store the mappings in a hash table. 3756bc1e9cdSJohn Baldwin */ 3766bc1e9cdSJohn Baldwin static struct ksem * 3776bc1e9cdSJohn Baldwin ksem_lookup(char *path, Fnv32_t fnv) 3786bc1e9cdSJohn Baldwin { 3796bc1e9cdSJohn Baldwin struct ksem_mapping *map; 3806bc1e9cdSJohn Baldwin 3816bc1e9cdSJohn Baldwin LIST_FOREACH(map, KSEM_HASH(fnv), km_link) { 3826bc1e9cdSJohn Baldwin if (map->km_fnv != fnv) 3836bc1e9cdSJohn Baldwin continue; 3846bc1e9cdSJohn Baldwin if (strcmp(map->km_path, path) == 0) 3856bc1e9cdSJohn Baldwin return (map->km_ksem); 3866bc1e9cdSJohn Baldwin } 3876bc1e9cdSJohn Baldwin 3886bc1e9cdSJohn Baldwin return (NULL); 3896bc1e9cdSJohn Baldwin } 3906bc1e9cdSJohn Baldwin 3916bc1e9cdSJohn Baldwin static void 3926bc1e9cdSJohn Baldwin ksem_insert(char *path, Fnv32_t fnv, struct ksem *ks) 3936bc1e9cdSJohn Baldwin { 3946bc1e9cdSJohn Baldwin struct ksem_mapping *map; 3956bc1e9cdSJohn Baldwin 3966bc1e9cdSJohn Baldwin map = malloc(sizeof(struct ksem_mapping), M_KSEM, M_WAITOK); 3976bc1e9cdSJohn Baldwin map->km_path = path; 3986bc1e9cdSJohn Baldwin map->km_fnv = fnv; 3996bc1e9cdSJohn Baldwin map->km_ksem = ksem_hold(ks); 400958aa575SJohn Baldwin ks->ks_path = path; 4016bc1e9cdSJohn Baldwin LIST_INSERT_HEAD(KSEM_HASH(fnv), map, km_link); 4026bc1e9cdSJohn Baldwin } 4036bc1e9cdSJohn Baldwin 4046bc1e9cdSJohn Baldwin static int 4056bc1e9cdSJohn Baldwin ksem_remove(char *path, Fnv32_t fnv, struct ucred *ucred) 4066bc1e9cdSJohn Baldwin { 4076bc1e9cdSJohn Baldwin struct ksem_mapping *map; 4086bc1e9cdSJohn Baldwin int error; 4096bc1e9cdSJohn Baldwin 4106bc1e9cdSJohn Baldwin LIST_FOREACH(map, KSEM_HASH(fnv), km_link) { 4116bc1e9cdSJohn Baldwin if (map->km_fnv != fnv) 4126bc1e9cdSJohn Baldwin continue; 4136bc1e9cdSJohn Baldwin if (strcmp(map->km_path, path) == 0) { 4146bc1e9cdSJohn Baldwin #ifdef MAC 4156bc1e9cdSJohn Baldwin error = mac_posixsem_check_unlink(ucred, map->km_ksem); 4166bc1e9cdSJohn Baldwin if (error) 4176bc1e9cdSJohn Baldwin return (error); 4186bc1e9cdSJohn Baldwin #endif 4196bc1e9cdSJohn Baldwin error = ksem_access(map->km_ksem, ucred); 4206bc1e9cdSJohn Baldwin if (error) 4216bc1e9cdSJohn Baldwin return (error); 422958aa575SJohn Baldwin map->km_ksem->ks_path = NULL; 4236bc1e9cdSJohn Baldwin LIST_REMOVE(map, km_link); 4246bc1e9cdSJohn Baldwin ksem_drop(map->km_ksem); 4256bc1e9cdSJohn Baldwin free(map->km_path, M_KSEM); 4266bc1e9cdSJohn Baldwin free(map, M_KSEM); 4276bc1e9cdSJohn Baldwin return (0); 4286bc1e9cdSJohn Baldwin } 4296bc1e9cdSJohn Baldwin } 4306bc1e9cdSJohn Baldwin 4316bc1e9cdSJohn Baldwin return (ENOENT); 4326bc1e9cdSJohn Baldwin } 4336bc1e9cdSJohn Baldwin 4340e5d5bc2SKonstantin Belousov static int 4350e5d5bc2SKonstantin Belousov ksem_create_copyout_semid(struct thread *td, semid_t *semidp, int fd, 4360e5d5bc2SKonstantin Belousov int compat32) 4370e5d5bc2SKonstantin Belousov { 4380e5d5bc2SKonstantin Belousov semid_t semid; 4390e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32 4400e5d5bc2SKonstantin Belousov int32_t semid32; 4410e5d5bc2SKonstantin Belousov #endif 4420e5d5bc2SKonstantin Belousov void *ptr; 4430e5d5bc2SKonstantin Belousov size_t ptrs; 4440e5d5bc2SKonstantin Belousov 4450e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32 4460e5d5bc2SKonstantin Belousov if (compat32) { 4470e5d5bc2SKonstantin Belousov semid32 = fd; 4480e5d5bc2SKonstantin Belousov ptr = &semid32; 4490e5d5bc2SKonstantin Belousov ptrs = sizeof(semid32); 4500e5d5bc2SKonstantin Belousov } else { 4510e5d5bc2SKonstantin Belousov #endif 4520e5d5bc2SKonstantin Belousov semid = fd; 4530e5d5bc2SKonstantin Belousov ptr = &semid; 4540e5d5bc2SKonstantin Belousov ptrs = sizeof(semid); 4550e5d5bc2SKonstantin Belousov compat32 = 0; /* silence gcc */ 4560e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32 4570e5d5bc2SKonstantin Belousov } 4580e5d5bc2SKonstantin Belousov #endif 4590e5d5bc2SKonstantin Belousov 4600e5d5bc2SKonstantin Belousov return (copyout(ptr, semidp, ptrs)); 4610e5d5bc2SKonstantin Belousov } 4620e5d5bc2SKonstantin Belousov 4636bc1e9cdSJohn Baldwin /* Other helper routines. */ 4646bc1e9cdSJohn Baldwin static int 4656bc1e9cdSJohn Baldwin ksem_create(struct thread *td, const char *name, semid_t *semidp, mode_t mode, 4660e5d5bc2SKonstantin Belousov unsigned int value, int flags, int compat32) 4676bc1e9cdSJohn Baldwin { 4686bc1e9cdSJohn Baldwin struct filedesc *fdp; 4696bc1e9cdSJohn Baldwin struct ksem *ks; 4706bc1e9cdSJohn Baldwin struct file *fp; 4716bc1e9cdSJohn Baldwin char *path; 472cc7b259aSJamie Gritton const char *pr_path; 473cc7b259aSJamie Gritton size_t pr_pathlen; 4746bc1e9cdSJohn Baldwin Fnv32_t fnv; 4756bc1e9cdSJohn Baldwin int error, fd; 4766bc1e9cdSJohn Baldwin 47715bcf785SRobert Watson AUDIT_ARG_FFLAGS(flags); 47815bcf785SRobert Watson AUDIT_ARG_MODE(mode); 47915bcf785SRobert Watson AUDIT_ARG_VALUE(value); 48015bcf785SRobert Watson 4816bc1e9cdSJohn Baldwin if (value > SEM_VALUE_MAX) 4826bc1e9cdSJohn Baldwin return (EINVAL); 4836bc1e9cdSJohn Baldwin 4846bc1e9cdSJohn Baldwin fdp = td->td_proc->p_fd; 4856bc1e9cdSJohn Baldwin mode = (mode & ~fdp->fd_cmask) & ACCESSPERMS; 486b68cf25fSJilles Tjoelker error = falloc(td, &fp, &fd, O_CLOEXEC); 4876bc1e9cdSJohn Baldwin if (error) { 4886bc1e9cdSJohn Baldwin if (name == NULL) 4896bc1e9cdSJohn Baldwin error = ENOSPC; 4906bc1e9cdSJohn Baldwin return (error); 4916bc1e9cdSJohn Baldwin } 4926bc1e9cdSJohn Baldwin 4936bc1e9cdSJohn Baldwin /* 4946bc1e9cdSJohn Baldwin * Go ahead and copyout the file descriptor now. This is a bit 4956bc1e9cdSJohn Baldwin * premature, but it is a lot easier to handle errors as opposed 4966bc1e9cdSJohn Baldwin * to later when we've possibly created a new semaphore, etc. 4976bc1e9cdSJohn Baldwin */ 4980e5d5bc2SKonstantin Belousov error = ksem_create_copyout_semid(td, semidp, fd, compat32); 4996bc1e9cdSJohn Baldwin if (error) { 50090f54cbfSMateusz Guzik fdclose(td, fp, fd); 5016bc1e9cdSJohn Baldwin fdrop(fp, td); 5026bc1e9cdSJohn Baldwin return (error); 5036bc1e9cdSJohn Baldwin } 5046bc1e9cdSJohn Baldwin 5056bc1e9cdSJohn Baldwin if (name == NULL) { 5066bc1e9cdSJohn Baldwin /* Create an anonymous semaphore. */ 5076bc1e9cdSJohn Baldwin ks = ksem_alloc(td->td_ucred, mode, value); 5086bc1e9cdSJohn Baldwin if (ks == NULL) 5096bc1e9cdSJohn Baldwin error = ENOSPC; 5106bc1e9cdSJohn Baldwin else 5116bc1e9cdSJohn Baldwin ks->ks_flags |= KS_ANONYMOUS; 5126bc1e9cdSJohn Baldwin } else { 5136bc1e9cdSJohn Baldwin path = malloc(MAXPATHLEN, M_KSEM, M_WAITOK); 514cc7b259aSJamie Gritton pr_path = td->td_ucred->cr_prison->pr_path; 51544c16975SJamie Gritton 51644c16975SJamie Gritton /* Construct a full pathname for jailed callers. */ 517cc7b259aSJamie Gritton pr_pathlen = strcmp(pr_path, "/") == 0 ? 0 518cc7b259aSJamie Gritton : strlcpy(path, pr_path, MAXPATHLEN); 519cc7b259aSJamie Gritton error = copyinstr(name, path + pr_pathlen, 520cc7b259aSJamie Gritton MAXPATHLEN - pr_pathlen, NULL); 5216bc1e9cdSJohn Baldwin 5226bc1e9cdSJohn Baldwin /* Require paths to start with a '/' character. */ 523cc7b259aSJamie Gritton if (error == 0 && path[pr_pathlen] != '/') 5246bc1e9cdSJohn Baldwin error = EINVAL; 5256bc1e9cdSJohn Baldwin if (error) { 52690f54cbfSMateusz Guzik fdclose(td, fp, fd); 5276bc1e9cdSJohn Baldwin fdrop(fp, td); 5286bc1e9cdSJohn Baldwin free(path, M_KSEM); 5296bc1e9cdSJohn Baldwin return (error); 5306bc1e9cdSJohn Baldwin } 5316bc1e9cdSJohn Baldwin 53215bcf785SRobert Watson AUDIT_ARG_UPATH1_CANON(path); 5336bc1e9cdSJohn Baldwin fnv = fnv_32_str(path, FNV1_32_INIT); 5346bc1e9cdSJohn Baldwin sx_xlock(&ksem_dict_lock); 5356bc1e9cdSJohn Baldwin ks = ksem_lookup(path, fnv); 5366bc1e9cdSJohn Baldwin if (ks == NULL) { 5376bc1e9cdSJohn Baldwin /* Object does not exist, create it if requested. */ 5386bc1e9cdSJohn Baldwin if (flags & O_CREAT) { 5396bc1e9cdSJohn Baldwin ks = ksem_alloc(td->td_ucred, mode, value); 5406bc1e9cdSJohn Baldwin if (ks == NULL) 5416bc1e9cdSJohn Baldwin error = ENFILE; 5426bc1e9cdSJohn Baldwin else { 5436bc1e9cdSJohn Baldwin ksem_insert(path, fnv, ks); 5446bc1e9cdSJohn Baldwin path = NULL; 5456bc1e9cdSJohn Baldwin } 5466bc1e9cdSJohn Baldwin } else 5476bc1e9cdSJohn Baldwin error = ENOENT; 5486bc1e9cdSJohn Baldwin } else { 5496bc1e9cdSJohn Baldwin /* 5506bc1e9cdSJohn Baldwin * Object already exists, obtain a new 5516bc1e9cdSJohn Baldwin * reference if requested and permitted. 5526bc1e9cdSJohn Baldwin */ 5536bc1e9cdSJohn Baldwin if ((flags & (O_CREAT | O_EXCL)) == 5546bc1e9cdSJohn Baldwin (O_CREAT | O_EXCL)) 5556bc1e9cdSJohn Baldwin error = EEXIST; 5566bc1e9cdSJohn Baldwin else { 5576bc1e9cdSJohn Baldwin #ifdef MAC 5586bc1e9cdSJohn Baldwin error = mac_posixsem_check_open(td->td_ucred, 5596bc1e9cdSJohn Baldwin ks); 5606bc1e9cdSJohn Baldwin if (error == 0) 5616bc1e9cdSJohn Baldwin #endif 5626bc1e9cdSJohn Baldwin error = ksem_access(ks, td->td_ucred); 5636bc1e9cdSJohn Baldwin } 5646bc1e9cdSJohn Baldwin if (error == 0) 5656bc1e9cdSJohn Baldwin ksem_hold(ks); 5666bc1e9cdSJohn Baldwin #ifdef INVARIANTS 5676bc1e9cdSJohn Baldwin else 5686bc1e9cdSJohn Baldwin ks = NULL; 5696bc1e9cdSJohn Baldwin #endif 5706bc1e9cdSJohn Baldwin } 5716bc1e9cdSJohn Baldwin sx_xunlock(&ksem_dict_lock); 5726bc1e9cdSJohn Baldwin if (path) 5736bc1e9cdSJohn Baldwin free(path, M_KSEM); 5746bc1e9cdSJohn Baldwin } 5756bc1e9cdSJohn Baldwin 5766bc1e9cdSJohn Baldwin if (error) { 5776bc1e9cdSJohn Baldwin KASSERT(ks == NULL, ("ksem_create error with a ksem")); 57890f54cbfSMateusz Guzik fdclose(td, fp, fd); 5796bc1e9cdSJohn Baldwin fdrop(fp, td); 5806bc1e9cdSJohn Baldwin return (error); 5816bc1e9cdSJohn Baldwin } 5826bc1e9cdSJohn Baldwin KASSERT(ks != NULL, ("ksem_create w/o a ksem")); 5836bc1e9cdSJohn Baldwin 5846bc1e9cdSJohn Baldwin finit(fp, FREAD | FWRITE, DTYPE_SEM, ks, &ksem_ops); 5856bc1e9cdSJohn Baldwin 5866bc1e9cdSJohn Baldwin fdrop(fp, td); 5876bc1e9cdSJohn Baldwin 5886bc1e9cdSJohn Baldwin return (0); 5896bc1e9cdSJohn Baldwin } 5906bc1e9cdSJohn Baldwin 5916bc1e9cdSJohn Baldwin static int 5927008be5bSPawel Jakub Dawidek ksem_get(struct thread *td, semid_t id, cap_rights_t *rightsp, 5937008be5bSPawel Jakub Dawidek struct file **fpp) 5946bc1e9cdSJohn Baldwin { 5956bc1e9cdSJohn Baldwin struct ksem *ks; 5966bc1e9cdSJohn Baldwin struct file *fp; 5976bc1e9cdSJohn Baldwin int error; 5986bc1e9cdSJohn Baldwin 5997008be5bSPawel Jakub Dawidek error = fget(td, id, rightsp, &fp); 6006bc1e9cdSJohn Baldwin if (error) 6016bc1e9cdSJohn Baldwin return (EINVAL); 6026bc1e9cdSJohn Baldwin if (fp->f_type != DTYPE_SEM) { 6036bc1e9cdSJohn Baldwin fdrop(fp, td); 6046bc1e9cdSJohn Baldwin return (EINVAL); 6056bc1e9cdSJohn Baldwin } 6066bc1e9cdSJohn Baldwin ks = fp->f_data; 6076bc1e9cdSJohn Baldwin if (ks->ks_flags & KS_DEAD) { 6086bc1e9cdSJohn Baldwin fdrop(fp, td); 6096bc1e9cdSJohn Baldwin return (EINVAL); 6106bc1e9cdSJohn Baldwin } 6116bc1e9cdSJohn Baldwin *fpp = fp; 6126bc1e9cdSJohn Baldwin return (0); 6136bc1e9cdSJohn Baldwin } 6146bc1e9cdSJohn Baldwin 6156bc1e9cdSJohn Baldwin /* System calls. */ 616efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 617efaa6588SAlfred Perlstein struct ksem_init_args { 618efaa6588SAlfred Perlstein unsigned int value; 619efaa6588SAlfred Perlstein semid_t *idp; 620efaa6588SAlfred Perlstein }; 621efaa6588SAlfred Perlstein #endif 622efaa6588SAlfred Perlstein int 6238451d0ddSKip Macy sys_ksem_init(struct thread *td, struct ksem_init_args *uap) 624efaa6588SAlfred Perlstein { 625efaa6588SAlfred Perlstein 6266bc1e9cdSJohn Baldwin return (ksem_create(td, NULL, uap->idp, S_IRWXU | S_IRWXG, uap->value, 6270e5d5bc2SKonstantin Belousov 0, 0)); 628efaa6588SAlfred Perlstein } 629efaa6588SAlfred Perlstein 630efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 631efaa6588SAlfred Perlstein struct ksem_open_args { 632efaa6588SAlfred Perlstein char *name; 633efaa6588SAlfred Perlstein int oflag; 634efaa6588SAlfred Perlstein mode_t mode; 635efaa6588SAlfred Perlstein unsigned int value; 636efaa6588SAlfred Perlstein semid_t *idp; 637efaa6588SAlfred Perlstein }; 638efaa6588SAlfred Perlstein #endif 639efaa6588SAlfred Perlstein int 6408451d0ddSKip Macy sys_ksem_open(struct thread *td, struct ksem_open_args *uap) 641efaa6588SAlfred Perlstein { 642efaa6588SAlfred Perlstein 643b2966a5aSBruce M Simpson DP((">>> ksem_open start, pid=%d\n", (int)td->td_proc->p_pid)); 644b2966a5aSBruce M Simpson 6456bc1e9cdSJohn Baldwin if ((uap->oflag & ~(O_CREAT | O_EXCL)) != 0) 646b3890a1cSAlfred Perlstein return (EINVAL); 6476bc1e9cdSJohn Baldwin return (ksem_create(td, uap->name, uap->idp, uap->mode, uap->value, 6480e5d5bc2SKonstantin Belousov uap->oflag, 0)); 649efaa6588SAlfred Perlstein } 650efaa6588SAlfred Perlstein 651efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 652efaa6588SAlfred Perlstein struct ksem_unlink_args { 653efaa6588SAlfred Perlstein char *name; 654efaa6588SAlfred Perlstein }; 655efaa6588SAlfred Perlstein #endif 656efaa6588SAlfred Perlstein int 6578451d0ddSKip Macy sys_ksem_unlink(struct thread *td, struct ksem_unlink_args *uap) 658efaa6588SAlfred Perlstein { 6596bc1e9cdSJohn Baldwin char *path; 660cc7b259aSJamie Gritton const char *pr_path; 661cc7b259aSJamie Gritton size_t pr_pathlen; 6626bc1e9cdSJohn Baldwin Fnv32_t fnv; 663efaa6588SAlfred Perlstein int error; 664efaa6588SAlfred Perlstein 6656bc1e9cdSJohn Baldwin path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 666cc7b259aSJamie Gritton pr_path = td->td_ucred->cr_prison->pr_path; 667cc7b259aSJamie Gritton pr_pathlen = strcmp(pr_path, "/") == 0 ? 0 668cc7b259aSJamie Gritton : strlcpy(path, pr_path, MAXPATHLEN); 669cc7b259aSJamie Gritton error = copyinstr(uap->name, path + pr_pathlen, MAXPATHLEN - pr_pathlen, 670cc7b259aSJamie Gritton NULL); 67152648411SRobert Watson if (error) { 6726bc1e9cdSJohn Baldwin free(path, M_TEMP); 67352648411SRobert Watson return (error); 67452648411SRobert Watson } 6756bc1e9cdSJohn Baldwin 67615bcf785SRobert Watson AUDIT_ARG_UPATH1_CANON(path); 6776bc1e9cdSJohn Baldwin fnv = fnv_32_str(path, FNV1_32_INIT); 6786bc1e9cdSJohn Baldwin sx_xlock(&ksem_dict_lock); 6796bc1e9cdSJohn Baldwin error = ksem_remove(path, fnv, td->td_ucred); 6806bc1e9cdSJohn Baldwin sx_xunlock(&ksem_dict_lock); 6816bc1e9cdSJohn Baldwin free(path, M_TEMP); 6826bc1e9cdSJohn Baldwin 683efaa6588SAlfred Perlstein return (error); 684efaa6588SAlfred Perlstein } 685efaa6588SAlfred Perlstein 686efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 687efaa6588SAlfred Perlstein struct ksem_close_args { 688efaa6588SAlfred Perlstein semid_t id; 689efaa6588SAlfred Perlstein }; 690efaa6588SAlfred Perlstein #endif 691efaa6588SAlfred Perlstein int 6928451d0ddSKip Macy sys_ksem_close(struct thread *td, struct ksem_close_args *uap) 693efaa6588SAlfred Perlstein { 694efaa6588SAlfred Perlstein struct ksem *ks; 6956bc1e9cdSJohn Baldwin struct file *fp; 696efaa6588SAlfred Perlstein int error; 697efaa6588SAlfred Perlstein 698a9d2f8d8SRobert Watson /* No capability rights required to close a semaphore. */ 69915bcf785SRobert Watson AUDIT_ARG_FD(uap->id); 700cbd92ce6SMatt Macy error = ksem_get(td, uap->id, &cap_no_rights, &fp); 7016bc1e9cdSJohn Baldwin if (error) 7026bc1e9cdSJohn Baldwin return (error); 7036bc1e9cdSJohn Baldwin ks = fp->f_data; 7046bc1e9cdSJohn Baldwin if (ks->ks_flags & KS_ANONYMOUS) { 7056bc1e9cdSJohn Baldwin fdrop(fp, td); 7066bc1e9cdSJohn Baldwin return (EINVAL); 7076bc1e9cdSJohn Baldwin } 7086bc1e9cdSJohn Baldwin error = kern_close(td, uap->id); 7096bc1e9cdSJohn Baldwin fdrop(fp, td); 710b3890a1cSAlfred Perlstein return (error); 711efaa6588SAlfred Perlstein } 712efaa6588SAlfred Perlstein 713efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 714efaa6588SAlfred Perlstein struct ksem_post_args { 715efaa6588SAlfred Perlstein semid_t id; 716efaa6588SAlfred Perlstein }; 717efaa6588SAlfred Perlstein #endif 718efaa6588SAlfred Perlstein int 7198451d0ddSKip Macy sys_ksem_post(struct thread *td, struct ksem_post_args *uap) 720efaa6588SAlfred Perlstein { 7217008be5bSPawel Jakub Dawidek cap_rights_t rights; 7226bc1e9cdSJohn Baldwin struct file *fp; 723efaa6588SAlfred Perlstein struct ksem *ks; 724efaa6588SAlfred Perlstein int error; 725efaa6588SAlfred Perlstein 72615bcf785SRobert Watson AUDIT_ARG_FD(uap->id); 7277008be5bSPawel Jakub Dawidek error = ksem_get(td, uap->id, 7287008be5bSPawel Jakub Dawidek cap_rights_init(&rights, CAP_SEM_POST), &fp); 7296bc1e9cdSJohn Baldwin if (error) 7306bc1e9cdSJohn Baldwin return (error); 7316bc1e9cdSJohn Baldwin ks = fp->f_data; 7326bc1e9cdSJohn Baldwin 733efaa6588SAlfred Perlstein mtx_lock(&sem_lock); 73452648411SRobert Watson #ifdef MAC 7356bc1e9cdSJohn Baldwin error = mac_posixsem_check_post(td->td_ucred, fp->f_cred, ks); 73652648411SRobert Watson if (error) 73752648411SRobert Watson goto err; 73852648411SRobert Watson #endif 739efaa6588SAlfred Perlstein if (ks->ks_value == SEM_VALUE_MAX) { 740efaa6588SAlfred Perlstein error = EOVERFLOW; 741efaa6588SAlfred Perlstein goto err; 742efaa6588SAlfred Perlstein } 743efaa6588SAlfred Perlstein ++ks->ks_value; 744efaa6588SAlfred Perlstein if (ks->ks_waiters > 0) 745efaa6588SAlfred Perlstein cv_signal(&ks->ks_cv); 746efaa6588SAlfred Perlstein error = 0; 7476bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_ctime); 748efaa6588SAlfred Perlstein err: 749efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 7506bc1e9cdSJohn Baldwin fdrop(fp, td); 751efaa6588SAlfred Perlstein return (error); 752efaa6588SAlfred Perlstein } 753efaa6588SAlfred Perlstein 754efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 755efaa6588SAlfred Perlstein struct ksem_wait_args { 756efaa6588SAlfred Perlstein semid_t id; 757efaa6588SAlfred Perlstein }; 758efaa6588SAlfred Perlstein #endif 759efaa6588SAlfred Perlstein int 7608451d0ddSKip Macy sys_ksem_wait(struct thread *td, struct ksem_wait_args *uap) 761efaa6588SAlfred Perlstein { 762efaa6588SAlfred Perlstein 763aae94fbbSDaniel Eischen return (kern_sem_wait(td, uap->id, 0, NULL)); 764aae94fbbSDaniel Eischen } 765aae94fbbSDaniel Eischen 766aae94fbbSDaniel Eischen #ifndef _SYS_SYSPROTO_H_ 767aae94fbbSDaniel Eischen struct ksem_timedwait_args { 768aae94fbbSDaniel Eischen semid_t id; 769d60e86c8SStefan Farfeleder const struct timespec *abstime; 770aae94fbbSDaniel Eischen }; 771aae94fbbSDaniel Eischen #endif 772aae94fbbSDaniel Eischen int 7738451d0ddSKip Macy sys_ksem_timedwait(struct thread *td, struct ksem_timedwait_args *uap) 774aae94fbbSDaniel Eischen { 775aae94fbbSDaniel Eischen struct timespec abstime; 776aae94fbbSDaniel Eischen struct timespec *ts; 777aae94fbbSDaniel Eischen int error; 778aae94fbbSDaniel Eischen 7798e230e30SRobert Watson /* 7808e230e30SRobert Watson * We allow a null timespec (wait forever). 7818e230e30SRobert Watson */ 782aae94fbbSDaniel Eischen if (uap->abstime == NULL) 783aae94fbbSDaniel Eischen ts = NULL; 784aae94fbbSDaniel Eischen else { 785aae94fbbSDaniel Eischen error = copyin(uap->abstime, &abstime, sizeof(abstime)); 786aae94fbbSDaniel Eischen if (error != 0) 787aae94fbbSDaniel Eischen return (error); 788aae94fbbSDaniel Eischen if (abstime.tv_nsec >= 1000000000 || abstime.tv_nsec < 0) 789aae94fbbSDaniel Eischen return (EINVAL); 790aae94fbbSDaniel Eischen ts = &abstime; 791aae94fbbSDaniel Eischen } 792aae94fbbSDaniel Eischen return (kern_sem_wait(td, uap->id, 0, ts)); 793efaa6588SAlfred Perlstein } 794efaa6588SAlfred Perlstein 795efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 796efaa6588SAlfred Perlstein struct ksem_trywait_args { 797efaa6588SAlfred Perlstein semid_t id; 798efaa6588SAlfred Perlstein }; 799efaa6588SAlfred Perlstein #endif 800efaa6588SAlfred Perlstein int 8018451d0ddSKip Macy sys_ksem_trywait(struct thread *td, struct ksem_trywait_args *uap) 802efaa6588SAlfred Perlstein { 803efaa6588SAlfred Perlstein 804aae94fbbSDaniel Eischen return (kern_sem_wait(td, uap->id, 1, NULL)); 805efaa6588SAlfred Perlstein } 806efaa6588SAlfred Perlstein 807c3053131SPoul-Henning Kamp static int 808c1250af6SRobert Watson kern_sem_wait(struct thread *td, semid_t id, int tryflag, 809c1250af6SRobert Watson struct timespec *abstime) 810efaa6588SAlfred Perlstein { 811aae94fbbSDaniel Eischen struct timespec ts1, ts2; 812aae94fbbSDaniel Eischen struct timeval tv; 8137008be5bSPawel Jakub Dawidek cap_rights_t rights; 8146bc1e9cdSJohn Baldwin struct file *fp; 815efaa6588SAlfred Perlstein struct ksem *ks; 816efaa6588SAlfred Perlstein int error; 817efaa6588SAlfred Perlstein 818b2966a5aSBruce M Simpson DP((">>> kern_sem_wait entered! pid=%d\n", (int)td->td_proc->p_pid)); 81915bcf785SRobert Watson AUDIT_ARG_FD(id); 8207008be5bSPawel Jakub Dawidek error = ksem_get(td, id, cap_rights_init(&rights, CAP_SEM_WAIT), &fp); 8216bc1e9cdSJohn Baldwin if (error) 8226bc1e9cdSJohn Baldwin return (error); 8236bc1e9cdSJohn Baldwin ks = fp->f_data; 824efaa6588SAlfred Perlstein mtx_lock(&sem_lock); 825b2966a5aSBruce M Simpson DP((">>> kern_sem_wait critical section entered! pid=%d\n", 826b2966a5aSBruce M Simpson (int)td->td_proc->p_pid)); 82752648411SRobert Watson #ifdef MAC 8286bc1e9cdSJohn Baldwin error = mac_posixsem_check_wait(td->td_ucred, fp->f_cred, ks); 82952648411SRobert Watson if (error) { 83052648411SRobert Watson DP(("kern_sem_wait mac failed\n")); 83152648411SRobert Watson goto err; 83252648411SRobert Watson } 83352648411SRobert Watson #endif 834c814aa3fSAlfred Perlstein DP(("kern_sem_wait value = %d, tryflag %d\n", ks->ks_value, tryflag)); 8356bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_atime); 83677d8bf9cSBruce M Simpson while (ks->ks_value == 0) { 837efaa6588SAlfred Perlstein ks->ks_waiters++; 838aae94fbbSDaniel Eischen if (tryflag != 0) 839aae94fbbSDaniel Eischen error = EAGAIN; 840aae94fbbSDaniel Eischen else if (abstime == NULL) 841aae94fbbSDaniel Eischen error = cv_wait_sig(&ks->ks_cv, &sem_lock); 842aae94fbbSDaniel Eischen else { 843aae94fbbSDaniel Eischen for (;;) { 844aae94fbbSDaniel Eischen ts1 = *abstime; 845aae94fbbSDaniel Eischen getnanotime(&ts2); 846aae94fbbSDaniel Eischen timespecsub(&ts1, &ts2); 847aae94fbbSDaniel Eischen TIMESPEC_TO_TIMEVAL(&tv, &ts1); 848aae94fbbSDaniel Eischen if (tv.tv_sec < 0) { 849aae94fbbSDaniel Eischen error = ETIMEDOUT; 850aae94fbbSDaniel Eischen break; 851aae94fbbSDaniel Eischen } 852aae94fbbSDaniel Eischen error = cv_timedwait_sig(&ks->ks_cv, 853aae94fbbSDaniel Eischen &sem_lock, tvtohz(&tv)); 854aae94fbbSDaniel Eischen if (error != EWOULDBLOCK) 855aae94fbbSDaniel Eischen break; 856aae94fbbSDaniel Eischen } 857aae94fbbSDaniel Eischen } 858efaa6588SAlfred Perlstein ks->ks_waiters--; 859efaa6588SAlfred Perlstein if (error) 860efaa6588SAlfred Perlstein goto err; 861efaa6588SAlfred Perlstein } 862efaa6588SAlfred Perlstein ks->ks_value--; 863b2966a5aSBruce M Simpson DP(("kern_sem_wait value post-decrement = %d\n", ks->ks_value)); 864efaa6588SAlfred Perlstein error = 0; 865efaa6588SAlfred Perlstein err: 866efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 8676bc1e9cdSJohn Baldwin fdrop(fp, td); 868b2966a5aSBruce M Simpson DP(("<<< kern_sem_wait leaving, pid=%d, error = %d\n", 869b2966a5aSBruce M Simpson (int)td->td_proc->p_pid, error)); 870efaa6588SAlfred Perlstein return (error); 871efaa6588SAlfred Perlstein } 872efaa6588SAlfred Perlstein 873efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 874efaa6588SAlfred Perlstein struct ksem_getvalue_args { 875efaa6588SAlfred Perlstein semid_t id; 876efaa6588SAlfred Perlstein int *val; 877efaa6588SAlfred Perlstein }; 878efaa6588SAlfred Perlstein #endif 879efaa6588SAlfred Perlstein int 8808451d0ddSKip Macy sys_ksem_getvalue(struct thread *td, struct ksem_getvalue_args *uap) 881efaa6588SAlfred Perlstein { 8827008be5bSPawel Jakub Dawidek cap_rights_t rights; 8836bc1e9cdSJohn Baldwin struct file *fp; 884efaa6588SAlfred Perlstein struct ksem *ks; 885efaa6588SAlfred Perlstein int error, val; 886efaa6588SAlfred Perlstein 88715bcf785SRobert Watson AUDIT_ARG_FD(uap->id); 8887008be5bSPawel Jakub Dawidek error = ksem_get(td, uap->id, 8897008be5bSPawel Jakub Dawidek cap_rights_init(&rights, CAP_SEM_GETVALUE), &fp); 8906bc1e9cdSJohn Baldwin if (error) 8916bc1e9cdSJohn Baldwin return (error); 8926bc1e9cdSJohn Baldwin ks = fp->f_data; 8936bc1e9cdSJohn Baldwin 894efaa6588SAlfred Perlstein mtx_lock(&sem_lock); 89552648411SRobert Watson #ifdef MAC 8966bc1e9cdSJohn Baldwin error = mac_posixsem_check_getvalue(td->td_ucred, fp->f_cred, ks); 89752648411SRobert Watson if (error) { 89852648411SRobert Watson mtx_unlock(&sem_lock); 8996bc1e9cdSJohn Baldwin fdrop(fp, td); 90052648411SRobert Watson return (error); 90152648411SRobert Watson } 90252648411SRobert Watson #endif 903efaa6588SAlfred Perlstein val = ks->ks_value; 9046bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_atime); 905efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 9066bc1e9cdSJohn Baldwin fdrop(fp, td); 907efaa6588SAlfred Perlstein error = copyout(&val, uap->val, sizeof(val)); 908efaa6588SAlfred Perlstein return (error); 909efaa6588SAlfred Perlstein } 910efaa6588SAlfred Perlstein 911efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 912efaa6588SAlfred Perlstein struct ksem_destroy_args { 913efaa6588SAlfred Perlstein semid_t id; 914efaa6588SAlfred Perlstein }; 915efaa6588SAlfred Perlstein #endif 916efaa6588SAlfred Perlstein int 9178451d0ddSKip Macy sys_ksem_destroy(struct thread *td, struct ksem_destroy_args *uap) 918efaa6588SAlfred Perlstein { 9196bc1e9cdSJohn Baldwin struct file *fp; 920efaa6588SAlfred Perlstein struct ksem *ks; 921efaa6588SAlfred Perlstein int error; 922efaa6588SAlfred Perlstein 923a9d2f8d8SRobert Watson /* No capability rights required to close a semaphore. */ 92415bcf785SRobert Watson AUDIT_ARG_FD(uap->id); 925cbd92ce6SMatt Macy error = ksem_get(td, uap->id, &cap_no_rights, &fp); 9266bc1e9cdSJohn Baldwin if (error) 9276bc1e9cdSJohn Baldwin return (error); 9286bc1e9cdSJohn Baldwin ks = fp->f_data; 9296bc1e9cdSJohn Baldwin if (!(ks->ks_flags & KS_ANONYMOUS)) { 9306bc1e9cdSJohn Baldwin fdrop(fp, td); 9316bc1e9cdSJohn Baldwin return (EINVAL); 932efaa6588SAlfred Perlstein } 9336bc1e9cdSJohn Baldwin mtx_lock(&sem_lock); 934efaa6588SAlfred Perlstein if (ks->ks_waiters != 0) { 9356bc1e9cdSJohn Baldwin mtx_unlock(&sem_lock); 936efaa6588SAlfred Perlstein error = EBUSY; 937efaa6588SAlfred Perlstein goto err; 938efaa6588SAlfred Perlstein } 9396bc1e9cdSJohn Baldwin ks->ks_flags |= KS_DEAD; 940efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 9416bc1e9cdSJohn Baldwin 9426bc1e9cdSJohn Baldwin error = kern_close(td, uap->id); 9436bc1e9cdSJohn Baldwin err: 9446bc1e9cdSJohn Baldwin fdrop(fp, td); 945efaa6588SAlfred Perlstein return (error); 946efaa6588SAlfred Perlstein } 947efaa6588SAlfred Perlstein 9480e5d5bc2SKonstantin Belousov static struct syscall_helper_data ksem_syscalls[] = { 9490e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_init), 9500e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_open), 9510e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_unlink), 9520e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_close), 9530e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_post), 9540e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_wait), 9550e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_timedwait), 9560e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_trywait), 9570e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_getvalue), 9580e5d5bc2SKonstantin Belousov SYSCALL_INIT_HELPER(ksem_destroy), 9590e5d5bc2SKonstantin Belousov SYSCALL_INIT_LAST 9600e5d5bc2SKonstantin Belousov }; 9616bc1e9cdSJohn Baldwin 9620e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32 9630e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32.h> 9640e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_proto.h> 9650e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_signal.h> 9660e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_syscall.h> 9670e5d5bc2SKonstantin Belousov #include <compat/freebsd32/freebsd32_util.h> 9686bc1e9cdSJohn Baldwin 9690e5d5bc2SKonstantin Belousov int 9700e5d5bc2SKonstantin Belousov freebsd32_ksem_init(struct thread *td, struct freebsd32_ksem_init_args *uap) 9710e5d5bc2SKonstantin Belousov { 9726bc1e9cdSJohn Baldwin 9730e5d5bc2SKonstantin Belousov return (ksem_create(td, NULL, uap->idp, S_IRWXU | S_IRWXG, uap->value, 9740e5d5bc2SKonstantin Belousov 0, 1)); 9750e5d5bc2SKonstantin Belousov } 9760e5d5bc2SKonstantin Belousov 9770e5d5bc2SKonstantin Belousov int 9780e5d5bc2SKonstantin Belousov freebsd32_ksem_open(struct thread *td, struct freebsd32_ksem_open_args *uap) 9790e5d5bc2SKonstantin Belousov { 9800e5d5bc2SKonstantin Belousov 9810e5d5bc2SKonstantin Belousov if ((uap->oflag & ~(O_CREAT | O_EXCL)) != 0) 9820e5d5bc2SKonstantin Belousov return (EINVAL); 9830e5d5bc2SKonstantin Belousov return (ksem_create(td, uap->name, uap->idp, uap->mode, uap->value, 9840e5d5bc2SKonstantin Belousov uap->oflag, 1)); 9850e5d5bc2SKonstantin Belousov } 9860e5d5bc2SKonstantin Belousov 9870e5d5bc2SKonstantin Belousov int 9880e5d5bc2SKonstantin Belousov freebsd32_ksem_timedwait(struct thread *td, 9890e5d5bc2SKonstantin Belousov struct freebsd32_ksem_timedwait_args *uap) 9900e5d5bc2SKonstantin Belousov { 9910e5d5bc2SKonstantin Belousov struct timespec32 abstime32; 9920e5d5bc2SKonstantin Belousov struct timespec *ts, abstime; 9930e5d5bc2SKonstantin Belousov int error; 9940e5d5bc2SKonstantin Belousov 9950e5d5bc2SKonstantin Belousov /* 9960e5d5bc2SKonstantin Belousov * We allow a null timespec (wait forever). 9970e5d5bc2SKonstantin Belousov */ 9980e5d5bc2SKonstantin Belousov if (uap->abstime == NULL) 9990e5d5bc2SKonstantin Belousov ts = NULL; 10000e5d5bc2SKonstantin Belousov else { 10010e5d5bc2SKonstantin Belousov error = copyin(uap->abstime, &abstime32, sizeof(abstime32)); 10020e5d5bc2SKonstantin Belousov if (error != 0) 10030e5d5bc2SKonstantin Belousov return (error); 10040e5d5bc2SKonstantin Belousov CP(abstime32, abstime, tv_sec); 10050e5d5bc2SKonstantin Belousov CP(abstime32, abstime, tv_nsec); 10060e5d5bc2SKonstantin Belousov if (abstime.tv_nsec >= 1000000000 || abstime.tv_nsec < 0) 10070e5d5bc2SKonstantin Belousov return (EINVAL); 10080e5d5bc2SKonstantin Belousov ts = &abstime; 10090e5d5bc2SKonstantin Belousov } 10100e5d5bc2SKonstantin Belousov return (kern_sem_wait(td, uap->id, 0, ts)); 10110e5d5bc2SKonstantin Belousov } 10120e5d5bc2SKonstantin Belousov 10130e5d5bc2SKonstantin Belousov static struct syscall_helper_data ksem32_syscalls[] = { 10140e5d5bc2SKonstantin Belousov SYSCALL32_INIT_HELPER(freebsd32_ksem_init), 10150e5d5bc2SKonstantin Belousov SYSCALL32_INIT_HELPER(freebsd32_ksem_open), 10168451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_unlink), 10178451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_close), 10188451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_post), 10198451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_wait), 10200e5d5bc2SKonstantin Belousov SYSCALL32_INIT_HELPER(freebsd32_ksem_timedwait), 10218451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_trywait), 10228451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_getvalue), 10238451d0ddSKip Macy SYSCALL32_INIT_HELPER_COMPAT(ksem_destroy), 10240e5d5bc2SKonstantin Belousov SYSCALL_INIT_LAST 10250e5d5bc2SKonstantin Belousov }; 10260e5d5bc2SKonstantin Belousov #endif 10276bc1e9cdSJohn Baldwin 1028590f242cSRobert Watson static int 10296bc1e9cdSJohn Baldwin ksem_module_init(void) 1030590f242cSRobert Watson { 10316bc1e9cdSJohn Baldwin int error; 1032590f242cSRobert Watson 10336bc1e9cdSJohn Baldwin mtx_init(&sem_lock, "sem", NULL, MTX_DEF); 10346bc1e9cdSJohn Baldwin mtx_init(&ksem_count_lock, "ksem count", NULL, MTX_DEF); 10356bc1e9cdSJohn Baldwin sx_init(&ksem_dict_lock, "ksem dictionary"); 10366bc1e9cdSJohn Baldwin ksem_dictionary = hashinit(1024, M_KSEM, &ksem_hash); 10372e7758a8SJohn Baldwin p31b_setcfg(CTL_P1003_1B_SEMAPHORES, 200112L); 10386bc1e9cdSJohn Baldwin p31b_setcfg(CTL_P1003_1B_SEM_NSEMS_MAX, SEM_MAX); 10396bc1e9cdSJohn Baldwin p31b_setcfg(CTL_P1003_1B_SEM_VALUE_MAX, SEM_VALUE_MAX); 1040590f242cSRobert Watson 1041e015b1abSMateusz Guzik error = syscall_helper_register(ksem_syscalls, SY_THR_STATIC_KLD); 10420e5d5bc2SKonstantin Belousov if (error) 10430e5d5bc2SKonstantin Belousov return (error); 10440e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32 1045e015b1abSMateusz Guzik error = syscall32_helper_register(ksem32_syscalls, SY_THR_STATIC_KLD); 10460e5d5bc2SKonstantin Belousov if (error) 10470e5d5bc2SKonstantin Belousov return (error); 10480e5d5bc2SKonstantin Belousov #endif 10496bc1e9cdSJohn Baldwin return (0); 1050590f242cSRobert Watson } 1051590f242cSRobert Watson 1052c3053131SPoul-Henning Kamp static void 10536bc1e9cdSJohn Baldwin ksem_module_destroy(void) 1054993182e5SAlexander Leidinger { 1055993182e5SAlexander Leidinger 10560e5d5bc2SKonstantin Belousov #ifdef COMPAT_FREEBSD32 10570e5d5bc2SKonstantin Belousov syscall32_helper_unregister(ksem32_syscalls); 10580e5d5bc2SKonstantin Belousov #endif 10590e5d5bc2SKonstantin Belousov syscall_helper_unregister(ksem_syscalls); 1060efaa6588SAlfred Perlstein 10612e7758a8SJohn Baldwin p31b_setcfg(CTL_P1003_1B_SEMAPHORES, 0); 10626bc1e9cdSJohn Baldwin hashdestroy(ksem_dictionary, M_KSEM, ksem_hash); 10636bc1e9cdSJohn Baldwin sx_destroy(&ksem_dict_lock); 10646bc1e9cdSJohn Baldwin mtx_destroy(&ksem_count_lock); 10656bc1e9cdSJohn Baldwin mtx_destroy(&sem_lock); 106632863754SKonstantin Belousov p31b_unsetcfg(CTL_P1003_1B_SEM_VALUE_MAX); 106732863754SKonstantin Belousov p31b_unsetcfg(CTL_P1003_1B_SEM_NSEMS_MAX); 1068efaa6588SAlfred Perlstein } 1069efaa6588SAlfred Perlstein 1070efaa6588SAlfred Perlstein static int 1071efaa6588SAlfred Perlstein sem_modload(struct module *module, int cmd, void *arg) 1072efaa6588SAlfred Perlstein { 1073efaa6588SAlfred Perlstein int error = 0; 1074efaa6588SAlfred Perlstein 1075efaa6588SAlfred Perlstein switch (cmd) { 1076efaa6588SAlfred Perlstein case MOD_LOAD: 10776bc1e9cdSJohn Baldwin error = ksem_module_init(); 10786bc1e9cdSJohn Baldwin if (error) 10796bc1e9cdSJohn Baldwin ksem_module_destroy(); 1080efaa6588SAlfred Perlstein break; 10818e230e30SRobert Watson 1082efaa6588SAlfred Perlstein case MOD_UNLOAD: 10836bc1e9cdSJohn Baldwin mtx_lock(&ksem_count_lock); 1084efaa6588SAlfred Perlstein if (nsems != 0) { 1085efaa6588SAlfred Perlstein error = EOPNOTSUPP; 10866bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 1087efaa6588SAlfred Perlstein break; 1088efaa6588SAlfred Perlstein } 10896bc1e9cdSJohn Baldwin ksem_dead = 1; 10906bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 10916bc1e9cdSJohn Baldwin ksem_module_destroy(); 1092efaa6588SAlfred Perlstein break; 10938e230e30SRobert Watson 1094efaa6588SAlfred Perlstein case MOD_SHUTDOWN: 1095efaa6588SAlfred Perlstein break; 1096efaa6588SAlfred Perlstein default: 1097efaa6588SAlfred Perlstein error = EINVAL; 1098efaa6588SAlfred Perlstein break; 1099efaa6588SAlfred Perlstein } 1100efaa6588SAlfred Perlstein return (error); 1101efaa6588SAlfred Perlstein } 1102efaa6588SAlfred Perlstein 1103efaa6588SAlfred Perlstein static moduledata_t sem_mod = { 1104efaa6588SAlfred Perlstein "sem", 1105efaa6588SAlfred Perlstein &sem_modload, 1106efaa6588SAlfred Perlstein NULL 1107efaa6588SAlfred Perlstein }; 1108efaa6588SAlfred Perlstein 1109efaa6588SAlfred Perlstein DECLARE_MODULE(sem, sem_mod, SI_SUB_SYSV_SEM, SI_ORDER_FIRST); 1110efaa6588SAlfred Perlstein MODULE_VERSION(sem, 1); 1111