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 3752648411SRobert Watson #include "opt_mac.h" 38efaa6588SAlfred Perlstein #include "opt_posix.h" 39efaa6588SAlfred Perlstein 40efaa6588SAlfred Perlstein #include <sys/param.h> 416bc1e9cdSJohn Baldwin #include <sys/condvar.h> 426bc1e9cdSJohn Baldwin #include <sys/fcntl.h> 436bc1e9cdSJohn Baldwin #include <sys/file.h> 446bc1e9cdSJohn Baldwin #include <sys/filedesc.h> 456bc1e9cdSJohn Baldwin #include <sys/fnv_hash.h> 46efaa6588SAlfred Perlstein #include <sys/kernel.h> 476aeb05d7STom Rhodes #include <sys/ksem.h> 486bc1e9cdSJohn Baldwin #include <sys/lock.h> 496bc1e9cdSJohn Baldwin #include <sys/malloc.h> 506bc1e9cdSJohn Baldwin #include <sys/module.h> 516bc1e9cdSJohn Baldwin #include <sys/mutex.h> 52acd3428bSRobert Watson #include <sys/priv.h> 53efaa6588SAlfred Perlstein #include <sys/proc.h> 546aeb05d7STom Rhodes #include <sys/posix4.h> 556aeb05d7STom Rhodes #include <sys/semaphore.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 696bc1e9cdSJohn Baldwin /* 706bc1e9cdSJohn Baldwin * TODO 716bc1e9cdSJohn Baldwin * 726bc1e9cdSJohn Baldwin * - Resource limits? 736bc1e9cdSJohn Baldwin * - Update fstat(1) 746bc1e9cdSJohn Baldwin * - Replace global sem_lock with mtx_pool locks? 756bc1e9cdSJohn Baldwin * - Add a MAC check_create() hook for creating new named semaphores. 766bc1e9cdSJohn Baldwin */ 77efaa6588SAlfred Perlstein 78efaa6588SAlfred Perlstein #ifndef SEM_MAX 79efaa6588SAlfred Perlstein #define SEM_MAX 30 80efaa6588SAlfred Perlstein #endif 81efaa6588SAlfred Perlstein 82c814aa3fSAlfred Perlstein #ifdef SEM_DEBUG 83c814aa3fSAlfred Perlstein #define DP(x) printf x 84c814aa3fSAlfred Perlstein #else 85c814aa3fSAlfred Perlstein #define DP(x) 86c814aa3fSAlfred Perlstein #endif 87c814aa3fSAlfred Perlstein 886bc1e9cdSJohn Baldwin struct ksem_mapping { 896bc1e9cdSJohn Baldwin char *km_path; 906bc1e9cdSJohn Baldwin Fnv32_t km_fnv; 916bc1e9cdSJohn Baldwin struct ksem *km_ksem; 926bc1e9cdSJohn Baldwin LIST_ENTRY(ksem_mapping) km_link; 936bc1e9cdSJohn Baldwin }; 946bc1e9cdSJohn Baldwin 956bc1e9cdSJohn Baldwin static MALLOC_DEFINE(M_KSEM, "ksem", "semaphore file descriptor"); 966bc1e9cdSJohn Baldwin static LIST_HEAD(, ksem_mapping) *ksem_dictionary; 976bc1e9cdSJohn Baldwin static struct sx ksem_dict_lock; 986bc1e9cdSJohn Baldwin static struct mtx ksem_count_lock; 996bc1e9cdSJohn Baldwin static struct mtx sem_lock; 1006bc1e9cdSJohn Baldwin static u_long ksem_hash; 1016bc1e9cdSJohn Baldwin static int ksem_dead; 1026bc1e9cdSJohn Baldwin 1036bc1e9cdSJohn Baldwin #define KSEM_HASH(fnv) (&ksem_dictionary[(fnv) & ksem_hash]) 1046bc1e9cdSJohn Baldwin 1056bc1e9cdSJohn Baldwin static int nsems = 0; 1066bc1e9cdSJohn Baldwin SYSCTL_DECL(_p1003_1b); 1076bc1e9cdSJohn Baldwin SYSCTL_INT(_p1003_1b, OID_AUTO, nsems, CTLFLAG_RD, &nsems, 0, 1086bc1e9cdSJohn Baldwin "Number of active kernel POSIX semaphores"); 1096bc1e9cdSJohn Baldwin 1106bc1e9cdSJohn Baldwin static int kern_sem_wait(struct thread *td, semid_t id, int tryflag, 1116bc1e9cdSJohn Baldwin struct timespec *abstime); 1126bc1e9cdSJohn Baldwin static int ksem_access(struct ksem *ks, struct ucred *ucred); 1136bc1e9cdSJohn Baldwin static struct ksem *ksem_alloc(struct ucred *ucred, mode_t mode, 1146bc1e9cdSJohn Baldwin unsigned int value); 1156bc1e9cdSJohn Baldwin static int ksem_create(struct thread *td, const char *path, 1166bc1e9cdSJohn Baldwin semid_t *semidp, mode_t mode, unsigned int value, 1176bc1e9cdSJohn Baldwin int flags); 1186bc1e9cdSJohn Baldwin static void ksem_drop(struct ksem *ks); 1196bc1e9cdSJohn Baldwin static int ksem_get(struct thread *td, semid_t id, struct file **fpp); 1206bc1e9cdSJohn Baldwin static struct ksem *ksem_hold(struct ksem *ks); 1216bc1e9cdSJohn Baldwin static void ksem_insert(char *path, Fnv32_t fnv, struct ksem *ks); 1226bc1e9cdSJohn Baldwin static struct ksem *ksem_lookup(char *path, Fnv32_t fnv); 1236bc1e9cdSJohn Baldwin static void ksem_module_destroy(void); 1246bc1e9cdSJohn Baldwin static int ksem_module_init(void); 1256bc1e9cdSJohn Baldwin static int ksem_remove(char *path, Fnv32_t fnv, struct ucred *ucred); 1266bc1e9cdSJohn Baldwin static int sem_modload(struct module *module, int cmd, void *arg); 1276bc1e9cdSJohn Baldwin 1286bc1e9cdSJohn Baldwin static fo_rdwr_t ksem_read; 1296bc1e9cdSJohn Baldwin static fo_rdwr_t ksem_write; 1306bc1e9cdSJohn Baldwin static fo_truncate_t ksem_truncate; 1316bc1e9cdSJohn Baldwin static fo_ioctl_t ksem_ioctl; 1326bc1e9cdSJohn Baldwin static fo_poll_t ksem_poll; 1336bc1e9cdSJohn Baldwin static fo_kqfilter_t ksem_kqfilter; 1346bc1e9cdSJohn Baldwin static fo_stat_t ksem_stat; 1356bc1e9cdSJohn Baldwin static fo_close_t ksem_closef; 1366bc1e9cdSJohn Baldwin 1376bc1e9cdSJohn Baldwin /* File descriptor operations. */ 1386bc1e9cdSJohn Baldwin static struct fileops ksem_ops = { 1396bc1e9cdSJohn Baldwin .fo_read = ksem_read, 1406bc1e9cdSJohn Baldwin .fo_write = ksem_write, 1416bc1e9cdSJohn Baldwin .fo_truncate = ksem_truncate, 1426bc1e9cdSJohn Baldwin .fo_ioctl = ksem_ioctl, 1436bc1e9cdSJohn Baldwin .fo_poll = ksem_poll, 1446bc1e9cdSJohn Baldwin .fo_kqfilter = ksem_kqfilter, 1456bc1e9cdSJohn Baldwin .fo_stat = ksem_stat, 1466bc1e9cdSJohn Baldwin .fo_close = ksem_closef, 1476bc1e9cdSJohn Baldwin .fo_flags = DFLAG_PASSABLE 1486bc1e9cdSJohn Baldwin }; 1496bc1e9cdSJohn Baldwin 1506bc1e9cdSJohn Baldwin FEATURE(posix_sem, "POSIX semaphores"); 1516bc1e9cdSJohn Baldwin 1526bc1e9cdSJohn Baldwin static int 1536bc1e9cdSJohn Baldwin ksem_read(struct file *fp, struct uio *uio, struct ucred *active_cred, 1546bc1e9cdSJohn Baldwin int flags, struct thread *td) 155efaa6588SAlfred Perlstein { 156efaa6588SAlfred Perlstein 1576bc1e9cdSJohn Baldwin return (EOPNOTSUPP); 158efaa6588SAlfred Perlstein } 159efaa6588SAlfred Perlstein 160c3053131SPoul-Henning Kamp static int 1616bc1e9cdSJohn Baldwin ksem_write(struct file *fp, struct uio *uio, struct ucred *active_cred, 1626bc1e9cdSJohn Baldwin int flags, struct thread *td) 163efaa6588SAlfred Perlstein { 1646bc1e9cdSJohn Baldwin 1656bc1e9cdSJohn Baldwin return (EOPNOTSUPP); 1666bc1e9cdSJohn Baldwin } 1676bc1e9cdSJohn Baldwin 1686bc1e9cdSJohn Baldwin static int 1696bc1e9cdSJohn Baldwin ksem_truncate(struct file *fp, off_t length, struct ucred *active_cred, 1706bc1e9cdSJohn Baldwin struct thread *td) 1716bc1e9cdSJohn Baldwin { 1726bc1e9cdSJohn Baldwin 1736bc1e9cdSJohn Baldwin return (EINVAL); 1746bc1e9cdSJohn Baldwin } 1756bc1e9cdSJohn Baldwin 1766bc1e9cdSJohn Baldwin static int 1776bc1e9cdSJohn Baldwin ksem_ioctl(struct file *fp, u_long com, void *data, 1786bc1e9cdSJohn Baldwin struct ucred *active_cred, struct thread *td) 1796bc1e9cdSJohn Baldwin { 1806bc1e9cdSJohn Baldwin 1816bc1e9cdSJohn Baldwin return (EOPNOTSUPP); 1826bc1e9cdSJohn Baldwin } 1836bc1e9cdSJohn Baldwin 1846bc1e9cdSJohn Baldwin static int 1856bc1e9cdSJohn Baldwin ksem_poll(struct file *fp, int events, struct ucred *active_cred, 1866bc1e9cdSJohn Baldwin struct thread *td) 1876bc1e9cdSJohn Baldwin { 1886bc1e9cdSJohn Baldwin 1896bc1e9cdSJohn Baldwin return (EOPNOTSUPP); 1906bc1e9cdSJohn Baldwin } 1916bc1e9cdSJohn Baldwin 1926bc1e9cdSJohn Baldwin static int 1936bc1e9cdSJohn Baldwin ksem_kqfilter(struct file *fp, struct knote *kn) 1946bc1e9cdSJohn Baldwin { 1956bc1e9cdSJohn Baldwin 1966bc1e9cdSJohn Baldwin return (EOPNOTSUPP); 1976bc1e9cdSJohn Baldwin } 1986bc1e9cdSJohn Baldwin 1996bc1e9cdSJohn Baldwin static int 2006bc1e9cdSJohn Baldwin ksem_stat(struct file *fp, struct stat *sb, struct ucred *active_cred, 2016bc1e9cdSJohn Baldwin struct thread *td) 2026bc1e9cdSJohn Baldwin { 2036bc1e9cdSJohn Baldwin struct ksem *ks; 2046bc1e9cdSJohn Baldwin #ifdef MAC 2056bc1e9cdSJohn Baldwin int error; 2066bc1e9cdSJohn Baldwin #endif 2076bc1e9cdSJohn Baldwin 2086bc1e9cdSJohn Baldwin ks = fp->f_data; 2096bc1e9cdSJohn Baldwin 2106bc1e9cdSJohn Baldwin #ifdef MAC 2116bc1e9cdSJohn Baldwin error = mac_posixsem_check_stat(active_cred, fp->f_cred, ks); 2126bc1e9cdSJohn Baldwin if (error) 2136bc1e9cdSJohn Baldwin return (error); 2146bc1e9cdSJohn Baldwin #endif 2156bc1e9cdSJohn Baldwin 2166bc1e9cdSJohn Baldwin /* 2176bc1e9cdSJohn Baldwin * Attempt to return sanish values for fstat() on a semaphore 2186bc1e9cdSJohn Baldwin * file descriptor. 2196bc1e9cdSJohn Baldwin */ 2206bc1e9cdSJohn Baldwin bzero(sb, sizeof(*sb)); 2216bc1e9cdSJohn Baldwin sb->st_mode = S_IFREG | ks->ks_mode; /* XXX */ 2226bc1e9cdSJohn Baldwin 2236bc1e9cdSJohn Baldwin sb->st_atimespec = ks->ks_atime; 2246bc1e9cdSJohn Baldwin sb->st_ctimespec = ks->ks_ctime; 2256bc1e9cdSJohn Baldwin sb->st_mtimespec = ks->ks_mtime; 2266bc1e9cdSJohn Baldwin sb->st_birthtimespec = ks->ks_birthtime; 2276bc1e9cdSJohn Baldwin sb->st_uid = ks->ks_uid; 2286bc1e9cdSJohn Baldwin sb->st_gid = ks->ks_gid; 2296bc1e9cdSJohn Baldwin 2306bc1e9cdSJohn Baldwin return (0); 2316bc1e9cdSJohn Baldwin } 2326bc1e9cdSJohn Baldwin 2336bc1e9cdSJohn Baldwin static int 2346bc1e9cdSJohn Baldwin ksem_closef(struct file *fp, struct thread *td) 2356bc1e9cdSJohn Baldwin { 2366bc1e9cdSJohn Baldwin struct ksem *ks; 2376bc1e9cdSJohn Baldwin 2386bc1e9cdSJohn Baldwin ks = fp->f_data; 2396bc1e9cdSJohn Baldwin fp->f_data = NULL; 2406bc1e9cdSJohn Baldwin ksem_drop(ks); 2416bc1e9cdSJohn Baldwin 2426bc1e9cdSJohn Baldwin return (0); 2436bc1e9cdSJohn Baldwin } 2446bc1e9cdSJohn Baldwin 2456bc1e9cdSJohn Baldwin /* 2466bc1e9cdSJohn Baldwin * ksem object management including creation and reference counting 2476bc1e9cdSJohn Baldwin * routines. 2486bc1e9cdSJohn Baldwin */ 2496bc1e9cdSJohn Baldwin static struct ksem * 2506bc1e9cdSJohn Baldwin ksem_alloc(struct ucred *ucred, mode_t mode, unsigned int value) 2516bc1e9cdSJohn Baldwin { 2526bc1e9cdSJohn Baldwin struct ksem *ks; 2536bc1e9cdSJohn Baldwin 2546bc1e9cdSJohn Baldwin mtx_lock(&ksem_count_lock); 2556bc1e9cdSJohn Baldwin if (nsems == p31b_getcfg(CTL_P1003_1B_SEM_NSEMS_MAX) || ksem_dead) { 2566bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 2576bc1e9cdSJohn Baldwin return (NULL); 2586bc1e9cdSJohn Baldwin } 2596bc1e9cdSJohn Baldwin nsems++; 2606bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 2616bc1e9cdSJohn Baldwin ks = malloc(sizeof(*ks), M_KSEM, M_WAITOK | M_ZERO); 2626bc1e9cdSJohn Baldwin ks->ks_uid = ucred->cr_uid; 2636bc1e9cdSJohn Baldwin ks->ks_gid = ucred->cr_gid; 2646bc1e9cdSJohn Baldwin ks->ks_mode = mode; 2656bc1e9cdSJohn Baldwin ks->ks_value = value; 2666bc1e9cdSJohn Baldwin cv_init(&ks->ks_cv, "ksem"); 2676bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_birthtime); 2686bc1e9cdSJohn Baldwin ks->ks_atime = ks->ks_mtime = ks->ks_ctime = ks->ks_birthtime; 2696bc1e9cdSJohn Baldwin refcount_init(&ks->ks_ref, 1); 2706bc1e9cdSJohn Baldwin #ifdef MAC 2716bc1e9cdSJohn Baldwin mac_posixsem_init(ks); 2726bc1e9cdSJohn Baldwin mac_posixsem_create(ucred, ks); 2736bc1e9cdSJohn Baldwin #endif 2746bc1e9cdSJohn Baldwin 2756bc1e9cdSJohn Baldwin return (ks); 2766bc1e9cdSJohn Baldwin } 2776bc1e9cdSJohn Baldwin 2786bc1e9cdSJohn Baldwin static struct ksem * 2796bc1e9cdSJohn Baldwin ksem_hold(struct ksem *ks) 2806bc1e9cdSJohn Baldwin { 2816bc1e9cdSJohn Baldwin 2826bc1e9cdSJohn Baldwin refcount_acquire(&ks->ks_ref); 2836bc1e9cdSJohn Baldwin return (ks); 2846bc1e9cdSJohn Baldwin } 2856bc1e9cdSJohn Baldwin 2866bc1e9cdSJohn Baldwin static void 2876bc1e9cdSJohn Baldwin ksem_drop(struct ksem *ks) 2886bc1e9cdSJohn Baldwin { 2896bc1e9cdSJohn Baldwin 2906bc1e9cdSJohn Baldwin if (refcount_release(&ks->ks_ref)) { 2916bc1e9cdSJohn Baldwin #ifdef MAC 2926bc1e9cdSJohn Baldwin mac_posixsem_destroy(ks); 2936bc1e9cdSJohn Baldwin #endif 2946bc1e9cdSJohn Baldwin cv_destroy(&ks->ks_cv); 2956bc1e9cdSJohn Baldwin free(ks, M_KSEM); 2966bc1e9cdSJohn Baldwin mtx_lock(&ksem_count_lock); 2976bc1e9cdSJohn Baldwin nsems--; 2986bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 2996bc1e9cdSJohn Baldwin } 3006bc1e9cdSJohn Baldwin } 3016bc1e9cdSJohn Baldwin 3026bc1e9cdSJohn Baldwin /* 3036bc1e9cdSJohn Baldwin * Determine if the credentials have sufficient permissions for read 3046bc1e9cdSJohn Baldwin * and write access. 3056bc1e9cdSJohn Baldwin */ 3066bc1e9cdSJohn Baldwin static int 3076bc1e9cdSJohn Baldwin ksem_access(struct ksem *ks, struct ucred *ucred) 3086bc1e9cdSJohn Baldwin { 309efaa6588SAlfred Perlstein int error; 310efaa6588SAlfred Perlstein 3116bc1e9cdSJohn Baldwin error = vaccess(VREG, ks->ks_mode, ks->ks_uid, ks->ks_gid, 3126bc1e9cdSJohn Baldwin VREAD | VWRITE, ucred, NULL); 3136bc1e9cdSJohn Baldwin if (error) 3146bc1e9cdSJohn Baldwin error = priv_check_cred(ucred, PRIV_SEM_WRITE, 0); 315efaa6588SAlfred Perlstein return (error); 316efaa6588SAlfred Perlstein } 317efaa6588SAlfred Perlstein 3186bc1e9cdSJohn Baldwin /* 3196bc1e9cdSJohn Baldwin * Dictionary management. We maintain an in-kernel dictionary to map 3206bc1e9cdSJohn Baldwin * paths to semaphore objects. We use the FNV hash on the path to 3216bc1e9cdSJohn Baldwin * store the mappings in a hash table. 3226bc1e9cdSJohn Baldwin */ 3236bc1e9cdSJohn Baldwin static struct ksem * 3246bc1e9cdSJohn Baldwin ksem_lookup(char *path, Fnv32_t fnv) 3256bc1e9cdSJohn Baldwin { 3266bc1e9cdSJohn Baldwin struct ksem_mapping *map; 3276bc1e9cdSJohn Baldwin 3286bc1e9cdSJohn Baldwin LIST_FOREACH(map, KSEM_HASH(fnv), km_link) { 3296bc1e9cdSJohn Baldwin if (map->km_fnv != fnv) 3306bc1e9cdSJohn Baldwin continue; 3316bc1e9cdSJohn Baldwin if (strcmp(map->km_path, path) == 0) 3326bc1e9cdSJohn Baldwin return (map->km_ksem); 3336bc1e9cdSJohn Baldwin } 3346bc1e9cdSJohn Baldwin 3356bc1e9cdSJohn Baldwin return (NULL); 3366bc1e9cdSJohn Baldwin } 3376bc1e9cdSJohn Baldwin 3386bc1e9cdSJohn Baldwin static void 3396bc1e9cdSJohn Baldwin ksem_insert(char *path, Fnv32_t fnv, struct ksem *ks) 3406bc1e9cdSJohn Baldwin { 3416bc1e9cdSJohn Baldwin struct ksem_mapping *map; 3426bc1e9cdSJohn Baldwin 3436bc1e9cdSJohn Baldwin map = malloc(sizeof(struct ksem_mapping), M_KSEM, M_WAITOK); 3446bc1e9cdSJohn Baldwin map->km_path = path; 3456bc1e9cdSJohn Baldwin map->km_fnv = fnv; 3466bc1e9cdSJohn Baldwin map->km_ksem = ksem_hold(ks); 3476bc1e9cdSJohn Baldwin LIST_INSERT_HEAD(KSEM_HASH(fnv), map, km_link); 3486bc1e9cdSJohn Baldwin } 3496bc1e9cdSJohn Baldwin 3506bc1e9cdSJohn Baldwin static int 3516bc1e9cdSJohn Baldwin ksem_remove(char *path, Fnv32_t fnv, struct ucred *ucred) 3526bc1e9cdSJohn Baldwin { 3536bc1e9cdSJohn Baldwin struct ksem_mapping *map; 3546bc1e9cdSJohn Baldwin int error; 3556bc1e9cdSJohn Baldwin 3566bc1e9cdSJohn Baldwin LIST_FOREACH(map, KSEM_HASH(fnv), km_link) { 3576bc1e9cdSJohn Baldwin if (map->km_fnv != fnv) 3586bc1e9cdSJohn Baldwin continue; 3596bc1e9cdSJohn Baldwin if (strcmp(map->km_path, path) == 0) { 3606bc1e9cdSJohn Baldwin #ifdef MAC 3616bc1e9cdSJohn Baldwin error = mac_posixsem_check_unlink(ucred, map->km_ksem); 3626bc1e9cdSJohn Baldwin if (error) 3636bc1e9cdSJohn Baldwin return (error); 3646bc1e9cdSJohn Baldwin #endif 3656bc1e9cdSJohn Baldwin error = ksem_access(map->km_ksem, ucred); 3666bc1e9cdSJohn Baldwin if (error) 3676bc1e9cdSJohn Baldwin return (error); 3686bc1e9cdSJohn Baldwin LIST_REMOVE(map, km_link); 3696bc1e9cdSJohn Baldwin ksem_drop(map->km_ksem); 3706bc1e9cdSJohn Baldwin free(map->km_path, M_KSEM); 3716bc1e9cdSJohn Baldwin free(map, M_KSEM); 3726bc1e9cdSJohn Baldwin return (0); 3736bc1e9cdSJohn Baldwin } 3746bc1e9cdSJohn Baldwin } 3756bc1e9cdSJohn Baldwin 3766bc1e9cdSJohn Baldwin return (ENOENT); 3776bc1e9cdSJohn Baldwin } 3786bc1e9cdSJohn Baldwin 3796bc1e9cdSJohn Baldwin /* Other helper routines. */ 3806bc1e9cdSJohn Baldwin static int 3816bc1e9cdSJohn Baldwin ksem_create(struct thread *td, const char *name, semid_t *semidp, mode_t mode, 3826bc1e9cdSJohn Baldwin unsigned int value, int flags) 3836bc1e9cdSJohn Baldwin { 3846bc1e9cdSJohn Baldwin struct filedesc *fdp; 3856bc1e9cdSJohn Baldwin struct ksem *ks; 3866bc1e9cdSJohn Baldwin struct file *fp; 3876bc1e9cdSJohn Baldwin char *path; 3886bc1e9cdSJohn Baldwin semid_t semid; 3896bc1e9cdSJohn Baldwin Fnv32_t fnv; 3906bc1e9cdSJohn Baldwin int error, fd; 3916bc1e9cdSJohn Baldwin 3926bc1e9cdSJohn Baldwin if (value > SEM_VALUE_MAX) 3936bc1e9cdSJohn Baldwin return (EINVAL); 3946bc1e9cdSJohn Baldwin 3956bc1e9cdSJohn Baldwin fdp = td->td_proc->p_fd; 3966bc1e9cdSJohn Baldwin mode = (mode & ~fdp->fd_cmask) & ACCESSPERMS; 3976bc1e9cdSJohn Baldwin error = falloc(td, &fp, &fd); 3986bc1e9cdSJohn Baldwin if (error) { 3996bc1e9cdSJohn Baldwin if (name == NULL) 4006bc1e9cdSJohn Baldwin error = ENOSPC; 4016bc1e9cdSJohn Baldwin return (error); 4026bc1e9cdSJohn Baldwin } 4036bc1e9cdSJohn Baldwin 4046bc1e9cdSJohn Baldwin /* 4056bc1e9cdSJohn Baldwin * Go ahead and copyout the file descriptor now. This is a bit 4066bc1e9cdSJohn Baldwin * premature, but it is a lot easier to handle errors as opposed 4076bc1e9cdSJohn Baldwin * to later when we've possibly created a new semaphore, etc. 4086bc1e9cdSJohn Baldwin */ 4096bc1e9cdSJohn Baldwin semid = fd; 4106bc1e9cdSJohn Baldwin error = copyout(&semid, semidp, sizeof(semid)); 4116bc1e9cdSJohn Baldwin if (error) { 4126bc1e9cdSJohn Baldwin fdclose(fdp, fp, fd, td); 4136bc1e9cdSJohn Baldwin fdrop(fp, td); 4146bc1e9cdSJohn Baldwin return (error); 4156bc1e9cdSJohn Baldwin } 4166bc1e9cdSJohn Baldwin 4176bc1e9cdSJohn Baldwin if (name == NULL) { 4186bc1e9cdSJohn Baldwin /* Create an anonymous semaphore. */ 4196bc1e9cdSJohn Baldwin ks = ksem_alloc(td->td_ucred, mode, value); 4206bc1e9cdSJohn Baldwin if (ks == NULL) 4216bc1e9cdSJohn Baldwin error = ENOSPC; 4226bc1e9cdSJohn Baldwin else 4236bc1e9cdSJohn Baldwin ks->ks_flags |= KS_ANONYMOUS; 4246bc1e9cdSJohn Baldwin } else { 4256bc1e9cdSJohn Baldwin path = malloc(MAXPATHLEN, M_KSEM, M_WAITOK); 4266bc1e9cdSJohn Baldwin error = copyinstr(name, path, MAXPATHLEN, NULL); 4276bc1e9cdSJohn Baldwin 4286bc1e9cdSJohn Baldwin /* Require paths to start with a '/' character. */ 4296bc1e9cdSJohn Baldwin if (error == 0 && path[0] != '/') 4306bc1e9cdSJohn Baldwin error = EINVAL; 4316bc1e9cdSJohn Baldwin if (error) { 4326bc1e9cdSJohn Baldwin fdclose(fdp, fp, fd, td); 4336bc1e9cdSJohn Baldwin fdrop(fp, td); 4346bc1e9cdSJohn Baldwin free(path, M_KSEM); 4356bc1e9cdSJohn Baldwin return (error); 4366bc1e9cdSJohn Baldwin } 4376bc1e9cdSJohn Baldwin 4386bc1e9cdSJohn Baldwin fnv = fnv_32_str(path, FNV1_32_INIT); 4396bc1e9cdSJohn Baldwin sx_xlock(&ksem_dict_lock); 4406bc1e9cdSJohn Baldwin ks = ksem_lookup(path, fnv); 4416bc1e9cdSJohn Baldwin if (ks == NULL) { 4426bc1e9cdSJohn Baldwin /* Object does not exist, create it if requested. */ 4436bc1e9cdSJohn Baldwin if (flags & O_CREAT) { 4446bc1e9cdSJohn Baldwin ks = ksem_alloc(td->td_ucred, mode, value); 4456bc1e9cdSJohn Baldwin if (ks == NULL) 4466bc1e9cdSJohn Baldwin error = ENFILE; 4476bc1e9cdSJohn Baldwin else { 4486bc1e9cdSJohn Baldwin ksem_insert(path, fnv, ks); 4496bc1e9cdSJohn Baldwin path = NULL; 4506bc1e9cdSJohn Baldwin } 4516bc1e9cdSJohn Baldwin } else 4526bc1e9cdSJohn Baldwin error = ENOENT; 4536bc1e9cdSJohn Baldwin } else { 4546bc1e9cdSJohn Baldwin /* 4556bc1e9cdSJohn Baldwin * Object already exists, obtain a new 4566bc1e9cdSJohn Baldwin * reference if requested and permitted. 4576bc1e9cdSJohn Baldwin */ 4586bc1e9cdSJohn Baldwin if ((flags & (O_CREAT | O_EXCL)) == 4596bc1e9cdSJohn Baldwin (O_CREAT | O_EXCL)) 4606bc1e9cdSJohn Baldwin error = EEXIST; 4616bc1e9cdSJohn Baldwin else { 4626bc1e9cdSJohn Baldwin #ifdef MAC 4636bc1e9cdSJohn Baldwin error = mac_posixsem_check_open(td->td_ucred, 4646bc1e9cdSJohn Baldwin ks); 4656bc1e9cdSJohn Baldwin if (error == 0) 4666bc1e9cdSJohn Baldwin #endif 4676bc1e9cdSJohn Baldwin error = ksem_access(ks, td->td_ucred); 4686bc1e9cdSJohn Baldwin } 4696bc1e9cdSJohn Baldwin if (error == 0) 4706bc1e9cdSJohn Baldwin ksem_hold(ks); 4716bc1e9cdSJohn Baldwin #ifdef INVARIANTS 4726bc1e9cdSJohn Baldwin else 4736bc1e9cdSJohn Baldwin ks = NULL; 4746bc1e9cdSJohn Baldwin #endif 4756bc1e9cdSJohn Baldwin } 4766bc1e9cdSJohn Baldwin sx_xunlock(&ksem_dict_lock); 4776bc1e9cdSJohn Baldwin if (path) 4786bc1e9cdSJohn Baldwin free(path, M_KSEM); 4796bc1e9cdSJohn Baldwin } 4806bc1e9cdSJohn Baldwin 4816bc1e9cdSJohn Baldwin if (error) { 4826bc1e9cdSJohn Baldwin KASSERT(ks == NULL, ("ksem_create error with a ksem")); 4836bc1e9cdSJohn Baldwin fdclose(fdp, fp, fd, td); 4846bc1e9cdSJohn Baldwin fdrop(fp, td); 4856bc1e9cdSJohn Baldwin return (error); 4866bc1e9cdSJohn Baldwin } 4876bc1e9cdSJohn Baldwin KASSERT(ks != NULL, ("ksem_create w/o a ksem")); 4886bc1e9cdSJohn Baldwin 4896bc1e9cdSJohn Baldwin finit(fp, FREAD | FWRITE, DTYPE_SEM, ks, &ksem_ops); 4906bc1e9cdSJohn Baldwin 4916bc1e9cdSJohn Baldwin FILEDESC_XLOCK(fdp); 4926bc1e9cdSJohn Baldwin if (fdp->fd_ofiles[fd] == fp) 4936bc1e9cdSJohn Baldwin fdp->fd_ofileflags[fd] |= UF_EXCLOSE; 4946bc1e9cdSJohn Baldwin FILEDESC_XUNLOCK(fdp); 4956bc1e9cdSJohn Baldwin fdrop(fp, td); 4966bc1e9cdSJohn Baldwin 4976bc1e9cdSJohn Baldwin return (0); 4986bc1e9cdSJohn Baldwin } 4996bc1e9cdSJohn Baldwin 5006bc1e9cdSJohn Baldwin static int 5016bc1e9cdSJohn Baldwin ksem_get(struct thread *td, semid_t id, struct file **fpp) 5026bc1e9cdSJohn Baldwin { 5036bc1e9cdSJohn Baldwin struct ksem *ks; 5046bc1e9cdSJohn Baldwin struct file *fp; 5056bc1e9cdSJohn Baldwin int error; 5066bc1e9cdSJohn Baldwin 5076bc1e9cdSJohn Baldwin error = fget(td, id, &fp); 5086bc1e9cdSJohn Baldwin if (error) 5096bc1e9cdSJohn Baldwin return (EINVAL); 5106bc1e9cdSJohn Baldwin if (fp->f_type != DTYPE_SEM) { 5116bc1e9cdSJohn Baldwin fdrop(fp, td); 5126bc1e9cdSJohn Baldwin return (EINVAL); 5136bc1e9cdSJohn Baldwin } 5146bc1e9cdSJohn Baldwin ks = fp->f_data; 5156bc1e9cdSJohn Baldwin if (ks->ks_flags & KS_DEAD) { 5166bc1e9cdSJohn Baldwin fdrop(fp, td); 5176bc1e9cdSJohn Baldwin return (EINVAL); 5186bc1e9cdSJohn Baldwin } 5196bc1e9cdSJohn Baldwin *fpp = fp; 5206bc1e9cdSJohn Baldwin return (0); 5216bc1e9cdSJohn Baldwin } 5226bc1e9cdSJohn Baldwin 5236bc1e9cdSJohn Baldwin /* System calls. */ 524efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 525efaa6588SAlfred Perlstein struct ksem_init_args { 526efaa6588SAlfred Perlstein unsigned int value; 527efaa6588SAlfred Perlstein semid_t *idp; 528efaa6588SAlfred Perlstein }; 529efaa6588SAlfred Perlstein #endif 530efaa6588SAlfred Perlstein int 531c1250af6SRobert Watson ksem_init(struct thread *td, struct ksem_init_args *uap) 532efaa6588SAlfred Perlstein { 533efaa6588SAlfred Perlstein 5346bc1e9cdSJohn Baldwin return (ksem_create(td, NULL, uap->idp, S_IRWXU | S_IRWXG, uap->value, 5356bc1e9cdSJohn Baldwin 0)); 536efaa6588SAlfred Perlstein } 537efaa6588SAlfred Perlstein 538efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 539efaa6588SAlfred Perlstein struct ksem_open_args { 540efaa6588SAlfred Perlstein char *name; 541efaa6588SAlfred Perlstein int oflag; 542efaa6588SAlfred Perlstein mode_t mode; 543efaa6588SAlfred Perlstein unsigned int value; 544efaa6588SAlfred Perlstein semid_t *idp; 545efaa6588SAlfred Perlstein }; 546efaa6588SAlfred Perlstein #endif 547efaa6588SAlfred Perlstein int 548c1250af6SRobert Watson ksem_open(struct thread *td, struct ksem_open_args *uap) 549efaa6588SAlfred Perlstein { 550efaa6588SAlfred Perlstein 551b2966a5aSBruce M Simpson DP((">>> ksem_open start, pid=%d\n", (int)td->td_proc->p_pid)); 552b2966a5aSBruce M Simpson 5536bc1e9cdSJohn Baldwin if ((uap->oflag & ~(O_CREAT | O_EXCL)) != 0) 554b3890a1cSAlfred Perlstein return (EINVAL); 5556bc1e9cdSJohn Baldwin return (ksem_create(td, uap->name, uap->idp, uap->mode, uap->value, 5566bc1e9cdSJohn Baldwin uap->oflag)); 557efaa6588SAlfred Perlstein } 558efaa6588SAlfred Perlstein 559efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 560efaa6588SAlfred Perlstein struct ksem_unlink_args { 561efaa6588SAlfred Perlstein char *name; 562efaa6588SAlfred Perlstein }; 563efaa6588SAlfred Perlstein #endif 564efaa6588SAlfred Perlstein int 565c1250af6SRobert Watson ksem_unlink(struct thread *td, struct ksem_unlink_args *uap) 566efaa6588SAlfred Perlstein { 5676bc1e9cdSJohn Baldwin char *path; 5686bc1e9cdSJohn Baldwin Fnv32_t fnv; 569efaa6588SAlfred Perlstein int error; 570efaa6588SAlfred Perlstein 5716bc1e9cdSJohn Baldwin path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 5726bc1e9cdSJohn Baldwin error = copyinstr(uap->name, path, MAXPATHLEN, NULL); 57352648411SRobert Watson if (error) { 5746bc1e9cdSJohn Baldwin free(path, M_TEMP); 57552648411SRobert Watson return (error); 57652648411SRobert Watson } 5776bc1e9cdSJohn Baldwin 5786bc1e9cdSJohn Baldwin fnv = fnv_32_str(path, FNV1_32_INIT); 5796bc1e9cdSJohn Baldwin sx_xlock(&ksem_dict_lock); 5806bc1e9cdSJohn Baldwin error = ksem_remove(path, fnv, td->td_ucred); 5816bc1e9cdSJohn Baldwin sx_xunlock(&ksem_dict_lock); 5826bc1e9cdSJohn Baldwin free(path, M_TEMP); 5836bc1e9cdSJohn Baldwin 584efaa6588SAlfred Perlstein return (error); 585efaa6588SAlfred Perlstein } 586efaa6588SAlfred Perlstein 587efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 588efaa6588SAlfred Perlstein struct ksem_close_args { 589efaa6588SAlfred Perlstein semid_t id; 590efaa6588SAlfred Perlstein }; 591efaa6588SAlfred Perlstein #endif 592efaa6588SAlfred Perlstein int 593efaa6588SAlfred Perlstein ksem_close(struct thread *td, struct ksem_close_args *uap) 594efaa6588SAlfred Perlstein { 595efaa6588SAlfred Perlstein struct ksem *ks; 5966bc1e9cdSJohn Baldwin struct file *fp; 597efaa6588SAlfred Perlstein int error; 598efaa6588SAlfred Perlstein 5996bc1e9cdSJohn Baldwin error = ksem_get(td, uap->id, &fp); 6006bc1e9cdSJohn Baldwin if (error) 6016bc1e9cdSJohn Baldwin return (error); 6026bc1e9cdSJohn Baldwin ks = fp->f_data; 6036bc1e9cdSJohn Baldwin if (ks->ks_flags & KS_ANONYMOUS) { 6046bc1e9cdSJohn Baldwin fdrop(fp, td); 6056bc1e9cdSJohn Baldwin return (EINVAL); 6066bc1e9cdSJohn Baldwin } 6076bc1e9cdSJohn Baldwin error = kern_close(td, uap->id); 6086bc1e9cdSJohn Baldwin fdrop(fp, td); 609b3890a1cSAlfred Perlstein return (error); 610efaa6588SAlfred Perlstein } 611efaa6588SAlfred Perlstein 612efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 613efaa6588SAlfred Perlstein struct ksem_post_args { 614efaa6588SAlfred Perlstein semid_t id; 615efaa6588SAlfred Perlstein }; 616efaa6588SAlfred Perlstein #endif 617efaa6588SAlfred Perlstein int 618c1250af6SRobert Watson ksem_post(struct thread *td, struct ksem_post_args *uap) 619efaa6588SAlfred Perlstein { 6206bc1e9cdSJohn Baldwin struct file *fp; 621efaa6588SAlfred Perlstein struct ksem *ks; 622efaa6588SAlfred Perlstein int error; 623efaa6588SAlfred Perlstein 6246bc1e9cdSJohn Baldwin error = ksem_get(td, uap->id, &fp); 6256bc1e9cdSJohn Baldwin if (error) 6266bc1e9cdSJohn Baldwin return (error); 6276bc1e9cdSJohn Baldwin ks = fp->f_data; 6286bc1e9cdSJohn Baldwin 629efaa6588SAlfred Perlstein mtx_lock(&sem_lock); 63052648411SRobert Watson #ifdef MAC 6316bc1e9cdSJohn Baldwin error = mac_posixsem_check_post(td->td_ucred, fp->f_cred, ks); 63252648411SRobert Watson if (error) 63352648411SRobert Watson goto err; 63452648411SRobert Watson #endif 635efaa6588SAlfred Perlstein if (ks->ks_value == SEM_VALUE_MAX) { 636efaa6588SAlfred Perlstein error = EOVERFLOW; 637efaa6588SAlfred Perlstein goto err; 638efaa6588SAlfred Perlstein } 639efaa6588SAlfred Perlstein ++ks->ks_value; 640efaa6588SAlfred Perlstein if (ks->ks_waiters > 0) 641efaa6588SAlfred Perlstein cv_signal(&ks->ks_cv); 642efaa6588SAlfred Perlstein error = 0; 6436bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_ctime); 644efaa6588SAlfred Perlstein err: 645efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 6466bc1e9cdSJohn Baldwin fdrop(fp, td); 647efaa6588SAlfred Perlstein return (error); 648efaa6588SAlfred Perlstein } 649efaa6588SAlfred Perlstein 650efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 651efaa6588SAlfred Perlstein struct ksem_wait_args { 652efaa6588SAlfred Perlstein semid_t id; 653efaa6588SAlfred Perlstein }; 654efaa6588SAlfred Perlstein #endif 655efaa6588SAlfred Perlstein int 656c1250af6SRobert Watson ksem_wait(struct thread *td, struct ksem_wait_args *uap) 657efaa6588SAlfred Perlstein { 658efaa6588SAlfred Perlstein 659aae94fbbSDaniel Eischen return (kern_sem_wait(td, uap->id, 0, NULL)); 660aae94fbbSDaniel Eischen } 661aae94fbbSDaniel Eischen 662aae94fbbSDaniel Eischen #ifndef _SYS_SYSPROTO_H_ 663aae94fbbSDaniel Eischen struct ksem_timedwait_args { 664aae94fbbSDaniel Eischen semid_t id; 665d60e86c8SStefan Farfeleder const struct timespec *abstime; 666aae94fbbSDaniel Eischen }; 667aae94fbbSDaniel Eischen #endif 668aae94fbbSDaniel Eischen int 669c1250af6SRobert Watson ksem_timedwait(struct thread *td, struct ksem_timedwait_args *uap) 670aae94fbbSDaniel Eischen { 671aae94fbbSDaniel Eischen struct timespec abstime; 672aae94fbbSDaniel Eischen struct timespec *ts; 673aae94fbbSDaniel Eischen int error; 674aae94fbbSDaniel Eischen 6758e230e30SRobert Watson /* 6768e230e30SRobert Watson * We allow a null timespec (wait forever). 6778e230e30SRobert Watson */ 678aae94fbbSDaniel Eischen if (uap->abstime == NULL) 679aae94fbbSDaniel Eischen ts = NULL; 680aae94fbbSDaniel Eischen else { 681aae94fbbSDaniel Eischen error = copyin(uap->abstime, &abstime, sizeof(abstime)); 682aae94fbbSDaniel Eischen if (error != 0) 683aae94fbbSDaniel Eischen return (error); 684aae94fbbSDaniel Eischen if (abstime.tv_nsec >= 1000000000 || abstime.tv_nsec < 0) 685aae94fbbSDaniel Eischen return (EINVAL); 686aae94fbbSDaniel Eischen ts = &abstime; 687aae94fbbSDaniel Eischen } 688aae94fbbSDaniel Eischen return (kern_sem_wait(td, uap->id, 0, ts)); 689efaa6588SAlfred Perlstein } 690efaa6588SAlfred Perlstein 691efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 692efaa6588SAlfred Perlstein struct ksem_trywait_args { 693efaa6588SAlfred Perlstein semid_t id; 694efaa6588SAlfred Perlstein }; 695efaa6588SAlfred Perlstein #endif 696efaa6588SAlfred Perlstein int 697c1250af6SRobert Watson ksem_trywait(struct thread *td, struct ksem_trywait_args *uap) 698efaa6588SAlfred Perlstein { 699efaa6588SAlfred Perlstein 700aae94fbbSDaniel Eischen return (kern_sem_wait(td, uap->id, 1, NULL)); 701efaa6588SAlfred Perlstein } 702efaa6588SAlfred Perlstein 703c3053131SPoul-Henning Kamp static int 704c1250af6SRobert Watson kern_sem_wait(struct thread *td, semid_t id, int tryflag, 705c1250af6SRobert Watson struct timespec *abstime) 706efaa6588SAlfred Perlstein { 707aae94fbbSDaniel Eischen struct timespec ts1, ts2; 708aae94fbbSDaniel Eischen struct timeval tv; 7096bc1e9cdSJohn Baldwin struct file *fp; 710efaa6588SAlfred Perlstein struct ksem *ks; 711efaa6588SAlfred Perlstein int error; 712efaa6588SAlfred Perlstein 713b2966a5aSBruce M Simpson DP((">>> kern_sem_wait entered! pid=%d\n", (int)td->td_proc->p_pid)); 7146bc1e9cdSJohn Baldwin error = ksem_get(td, id, &fp); 7156bc1e9cdSJohn Baldwin if (error) 7166bc1e9cdSJohn Baldwin return (error); 7176bc1e9cdSJohn Baldwin ks = fp->f_data; 718efaa6588SAlfred Perlstein mtx_lock(&sem_lock); 719b2966a5aSBruce M Simpson DP((">>> kern_sem_wait critical section entered! pid=%d\n", 720b2966a5aSBruce M Simpson (int)td->td_proc->p_pid)); 72152648411SRobert Watson #ifdef MAC 7226bc1e9cdSJohn Baldwin error = mac_posixsem_check_wait(td->td_ucred, fp->f_cred, ks); 72352648411SRobert Watson if (error) { 72452648411SRobert Watson DP(("kern_sem_wait mac failed\n")); 72552648411SRobert Watson goto err; 72652648411SRobert Watson } 72752648411SRobert Watson #endif 728c814aa3fSAlfred Perlstein DP(("kern_sem_wait value = %d, tryflag %d\n", ks->ks_value, tryflag)); 7296bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_atime); 73077d8bf9cSBruce M Simpson while (ks->ks_value == 0) { 731efaa6588SAlfred Perlstein ks->ks_waiters++; 732aae94fbbSDaniel Eischen if (tryflag != 0) 733aae94fbbSDaniel Eischen error = EAGAIN; 734aae94fbbSDaniel Eischen else if (abstime == NULL) 735aae94fbbSDaniel Eischen error = cv_wait_sig(&ks->ks_cv, &sem_lock); 736aae94fbbSDaniel Eischen else { 737aae94fbbSDaniel Eischen for (;;) { 738aae94fbbSDaniel Eischen ts1 = *abstime; 739aae94fbbSDaniel Eischen getnanotime(&ts2); 740aae94fbbSDaniel Eischen timespecsub(&ts1, &ts2); 741aae94fbbSDaniel Eischen TIMESPEC_TO_TIMEVAL(&tv, &ts1); 742aae94fbbSDaniel Eischen if (tv.tv_sec < 0) { 743aae94fbbSDaniel Eischen error = ETIMEDOUT; 744aae94fbbSDaniel Eischen break; 745aae94fbbSDaniel Eischen } 746aae94fbbSDaniel Eischen error = cv_timedwait_sig(&ks->ks_cv, 747aae94fbbSDaniel Eischen &sem_lock, tvtohz(&tv)); 748aae94fbbSDaniel Eischen if (error != EWOULDBLOCK) 749aae94fbbSDaniel Eischen break; 750aae94fbbSDaniel Eischen } 751aae94fbbSDaniel Eischen } 752efaa6588SAlfred Perlstein ks->ks_waiters--; 753efaa6588SAlfred Perlstein if (error) 754efaa6588SAlfred Perlstein goto err; 755efaa6588SAlfred Perlstein } 756efaa6588SAlfred Perlstein ks->ks_value--; 757b2966a5aSBruce M Simpson DP(("kern_sem_wait value post-decrement = %d\n", ks->ks_value)); 758efaa6588SAlfred Perlstein error = 0; 759efaa6588SAlfred Perlstein err: 760efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 7616bc1e9cdSJohn Baldwin fdrop(fp, td); 762b2966a5aSBruce M Simpson DP(("<<< kern_sem_wait leaving, pid=%d, error = %d\n", 763b2966a5aSBruce M Simpson (int)td->td_proc->p_pid, error)); 764efaa6588SAlfred Perlstein return (error); 765efaa6588SAlfred Perlstein } 766efaa6588SAlfred Perlstein 767efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 768efaa6588SAlfred Perlstein struct ksem_getvalue_args { 769efaa6588SAlfred Perlstein semid_t id; 770efaa6588SAlfred Perlstein int *val; 771efaa6588SAlfred Perlstein }; 772efaa6588SAlfred Perlstein #endif 773efaa6588SAlfred Perlstein int 774c1250af6SRobert Watson ksem_getvalue(struct thread *td, struct ksem_getvalue_args *uap) 775efaa6588SAlfred Perlstein { 7766bc1e9cdSJohn Baldwin struct file *fp; 777efaa6588SAlfred Perlstein struct ksem *ks; 778efaa6588SAlfred Perlstein int error, val; 779efaa6588SAlfred Perlstein 7806bc1e9cdSJohn Baldwin error = ksem_get(td, uap->id, &fp); 7816bc1e9cdSJohn Baldwin if (error) 7826bc1e9cdSJohn Baldwin return (error); 7836bc1e9cdSJohn Baldwin ks = fp->f_data; 7846bc1e9cdSJohn Baldwin 785efaa6588SAlfred Perlstein mtx_lock(&sem_lock); 78652648411SRobert Watson #ifdef MAC 7876bc1e9cdSJohn Baldwin error = mac_posixsem_check_getvalue(td->td_ucred, fp->f_cred, ks); 78852648411SRobert Watson if (error) { 78952648411SRobert Watson mtx_unlock(&sem_lock); 7906bc1e9cdSJohn Baldwin fdrop(fp, td); 79152648411SRobert Watson return (error); 79252648411SRobert Watson } 79352648411SRobert Watson #endif 794efaa6588SAlfred Perlstein val = ks->ks_value; 7956bc1e9cdSJohn Baldwin vfs_timestamp(&ks->ks_atime); 796efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 7976bc1e9cdSJohn Baldwin fdrop(fp, td); 798efaa6588SAlfred Perlstein error = copyout(&val, uap->val, sizeof(val)); 799efaa6588SAlfred Perlstein return (error); 800efaa6588SAlfred Perlstein } 801efaa6588SAlfred Perlstein 802efaa6588SAlfred Perlstein #ifndef _SYS_SYSPROTO_H_ 803efaa6588SAlfred Perlstein struct ksem_destroy_args { 804efaa6588SAlfred Perlstein semid_t id; 805efaa6588SAlfred Perlstein }; 806efaa6588SAlfred Perlstein #endif 807efaa6588SAlfred Perlstein int 808c1250af6SRobert Watson ksem_destroy(struct thread *td, struct ksem_destroy_args *uap) 809efaa6588SAlfred Perlstein { 8106bc1e9cdSJohn Baldwin struct file *fp; 811efaa6588SAlfred Perlstein struct ksem *ks; 812efaa6588SAlfred Perlstein int error; 813efaa6588SAlfred Perlstein 8146bc1e9cdSJohn Baldwin error = ksem_get(td, uap->id, &fp); 8156bc1e9cdSJohn Baldwin if (error) 8166bc1e9cdSJohn Baldwin return (error); 8176bc1e9cdSJohn Baldwin ks = fp->f_data; 8186bc1e9cdSJohn Baldwin if (!(ks->ks_flags & KS_ANONYMOUS)) { 8196bc1e9cdSJohn Baldwin fdrop(fp, td); 8206bc1e9cdSJohn Baldwin return (EINVAL); 821efaa6588SAlfred Perlstein } 8226bc1e9cdSJohn Baldwin mtx_lock(&sem_lock); 823efaa6588SAlfred Perlstein if (ks->ks_waiters != 0) { 8246bc1e9cdSJohn Baldwin mtx_unlock(&sem_lock); 825efaa6588SAlfred Perlstein error = EBUSY; 826efaa6588SAlfred Perlstein goto err; 827efaa6588SAlfred Perlstein } 8286bc1e9cdSJohn Baldwin ks->ks_flags |= KS_DEAD; 829efaa6588SAlfred Perlstein mtx_unlock(&sem_lock); 8306bc1e9cdSJohn Baldwin 8316bc1e9cdSJohn Baldwin error = kern_close(td, uap->id); 8326bc1e9cdSJohn Baldwin err: 8336bc1e9cdSJohn Baldwin fdrop(fp, td); 834efaa6588SAlfred Perlstein return (error); 835efaa6588SAlfred Perlstein } 836efaa6588SAlfred Perlstein 8376bc1e9cdSJohn Baldwin #define SYSCALL_DATA(syscallname) \ 8386bc1e9cdSJohn Baldwin static int syscallname##_syscall = SYS_##syscallname; \ 8396bc1e9cdSJohn Baldwin static int syscallname##_registered; \ 8406bc1e9cdSJohn Baldwin static struct sysent syscallname##_old_sysent; \ 8416bc1e9cdSJohn Baldwin MAKE_SYSENT(syscallname); 8426bc1e9cdSJohn Baldwin 8436bc1e9cdSJohn Baldwin #define SYSCALL_REGISTER(syscallname) do { \ 8446bc1e9cdSJohn Baldwin error = syscall_register(& syscallname##_syscall, \ 8456bc1e9cdSJohn Baldwin & syscallname##_sysent, & syscallname##_old_sysent); \ 8466bc1e9cdSJohn Baldwin if (error) \ 8476bc1e9cdSJohn Baldwin return (error); \ 8486bc1e9cdSJohn Baldwin syscallname##_registered = 1; \ 8496bc1e9cdSJohn Baldwin } while(0) 8506bc1e9cdSJohn Baldwin 8516bc1e9cdSJohn Baldwin #define SYSCALL_DEREGISTER(syscallname) do { \ 8526bc1e9cdSJohn Baldwin if (syscallname##_registered) { \ 8536bc1e9cdSJohn Baldwin syscallname##_registered = 0; \ 8546bc1e9cdSJohn Baldwin syscall_deregister(& syscallname##_syscall, \ 8556bc1e9cdSJohn Baldwin & syscallname##_old_sysent); \ 8566bc1e9cdSJohn Baldwin } \ 8576bc1e9cdSJohn Baldwin } while(0) 8586bc1e9cdSJohn Baldwin 8596bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_init); 8606bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_open); 8616bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_unlink); 8626bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_close); 8636bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_post); 8646bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_wait); 8656bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_timedwait); 8666bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_trywait); 8676bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_getvalue); 8686bc1e9cdSJohn Baldwin SYSCALL_DATA(ksem_destroy); 8696bc1e9cdSJohn Baldwin 870590f242cSRobert Watson static int 8716bc1e9cdSJohn Baldwin ksem_module_init(void) 872590f242cSRobert Watson { 8736bc1e9cdSJohn Baldwin int error; 874590f242cSRobert Watson 8756bc1e9cdSJohn Baldwin mtx_init(&sem_lock, "sem", NULL, MTX_DEF); 8766bc1e9cdSJohn Baldwin mtx_init(&ksem_count_lock, "ksem count", NULL, MTX_DEF); 8776bc1e9cdSJohn Baldwin sx_init(&ksem_dict_lock, "ksem dictionary"); 8786bc1e9cdSJohn Baldwin ksem_dictionary = hashinit(1024, M_KSEM, &ksem_hash); 8796bc1e9cdSJohn Baldwin p31b_setcfg(CTL_P1003_1B_SEM_NSEMS_MAX, SEM_MAX); 8806bc1e9cdSJohn Baldwin p31b_setcfg(CTL_P1003_1B_SEM_VALUE_MAX, SEM_VALUE_MAX); 881590f242cSRobert Watson 8826bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_init); 8836bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_open); 8846bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_unlink); 8856bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_close); 8866bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_post); 8876bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_wait); 8886bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_timedwait); 8896bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_trywait); 8906bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_getvalue); 8916bc1e9cdSJohn Baldwin SYSCALL_REGISTER(ksem_destroy); 8926bc1e9cdSJohn Baldwin return (0); 893590f242cSRobert Watson } 894590f242cSRobert Watson 895c3053131SPoul-Henning Kamp static void 8966bc1e9cdSJohn Baldwin ksem_module_destroy(void) 897993182e5SAlexander Leidinger { 898993182e5SAlexander Leidinger 8996bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_init); 9006bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_open); 9016bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_unlink); 9026bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_close); 9036bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_post); 9046bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_wait); 9056bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_timedwait); 9066bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_trywait); 9076bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_getvalue); 9086bc1e9cdSJohn Baldwin SYSCALL_DEREGISTER(ksem_destroy); 909efaa6588SAlfred Perlstein 9106bc1e9cdSJohn Baldwin hashdestroy(ksem_dictionary, M_KSEM, ksem_hash); 9116bc1e9cdSJohn Baldwin sx_destroy(&ksem_dict_lock); 9126bc1e9cdSJohn Baldwin mtx_destroy(&ksem_count_lock); 9136bc1e9cdSJohn Baldwin mtx_destroy(&sem_lock); 914efaa6588SAlfred Perlstein } 915efaa6588SAlfred Perlstein 916efaa6588SAlfred Perlstein static int 917efaa6588SAlfred Perlstein sem_modload(struct module *module, int cmd, void *arg) 918efaa6588SAlfred Perlstein { 919efaa6588SAlfred Perlstein int error = 0; 920efaa6588SAlfred Perlstein 921efaa6588SAlfred Perlstein switch (cmd) { 922efaa6588SAlfred Perlstein case MOD_LOAD: 9236bc1e9cdSJohn Baldwin error = ksem_module_init(); 9246bc1e9cdSJohn Baldwin if (error) 9256bc1e9cdSJohn Baldwin ksem_module_destroy(); 926efaa6588SAlfred Perlstein break; 9278e230e30SRobert Watson 928efaa6588SAlfred Perlstein case MOD_UNLOAD: 9296bc1e9cdSJohn Baldwin mtx_lock(&ksem_count_lock); 930efaa6588SAlfred Perlstein if (nsems != 0) { 931efaa6588SAlfred Perlstein error = EOPNOTSUPP; 9326bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 933efaa6588SAlfred Perlstein break; 934efaa6588SAlfred Perlstein } 9356bc1e9cdSJohn Baldwin ksem_dead = 1; 9366bc1e9cdSJohn Baldwin mtx_unlock(&ksem_count_lock); 9376bc1e9cdSJohn Baldwin ksem_module_destroy(); 938efaa6588SAlfred Perlstein break; 9398e230e30SRobert Watson 940efaa6588SAlfred Perlstein case MOD_SHUTDOWN: 941efaa6588SAlfred Perlstein break; 942efaa6588SAlfred Perlstein default: 943efaa6588SAlfred Perlstein error = EINVAL; 944efaa6588SAlfred Perlstein break; 945efaa6588SAlfred Perlstein } 946efaa6588SAlfred Perlstein return (error); 947efaa6588SAlfred Perlstein } 948efaa6588SAlfred Perlstein 949efaa6588SAlfred Perlstein static moduledata_t sem_mod = { 950efaa6588SAlfred Perlstein "sem", 951efaa6588SAlfred Perlstein &sem_modload, 952efaa6588SAlfred Perlstein NULL 953efaa6588SAlfred Perlstein }; 954efaa6588SAlfred Perlstein 955efaa6588SAlfred Perlstein DECLARE_MODULE(sem, sem_mod, SI_SUB_SYSV_SEM, SI_ORDER_FIRST); 956efaa6588SAlfred Perlstein MODULE_VERSION(sem, 1); 957