X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/c0fea4742e91338fffdcf79f86a7c1d5e2b97eb1..0b4c1975fb5e4eccf1012a35081f7e7799b81046:/bsd/kern/posix_sem.c?ds=inline diff --git a/bsd/kern/posix_sem.c b/bsd/kern/posix_sem.c index 2b91c34bc..a2cd627f1 100644 --- a/bsd/kern/posix_sem.c +++ b/bsd/kern/posix_sem.c @@ -1,23 +1,29 @@ /* - * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2007 Apple Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * Copyright (c) 1990, 1996-1998 Apple Computer, Inc. @@ -34,6 +40,12 @@ * Created for MacOSX * */ +/* + * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce + * support for mandatory and extensible security protections. This notice + * is included in support of clause 2.2 (b) of the Apple Public License, + * Version 2.0. + */ #include #include @@ -54,7 +66,12 @@ #include #include -#include +#if CONFIG_MACF +#include +#include +#endif + +#include #include #include @@ -66,9 +83,6 @@ #include #include -#if KTRACE -#include -#endif #define f_flag f_fglob->fg_flag #define f_type f_fglob->fg_type @@ -87,7 +101,8 @@ struct pseminfo { gid_t psem_gid; char psem_name[PSEMNAMLEN + 1]; /* segment name */ semaphore_t psem_semobject; - struct proc * sem_proc; + proc_t sem_proc; + struct label * psem_label; }; #define PSEMINFO_NULL (struct pseminfo *)0 @@ -120,7 +135,7 @@ struct psemstats { struct psemname { char *psem_nameptr; /* pointer to looked up name */ long psem_namelen; /* length of looked up component */ - u_long psem_hash; /* hash value of looked up name */ + u_int32_t psem_hash; /* hash value of looked up name */ }; struct psemnode { @@ -140,9 +155,9 @@ u_long psemhash; /* size of hash table - 1 */ long psemnument; /* number of cache entries allocated */ long posix_sem_max = 10000; /* tunable for max POSIX semaphores */ /* 10000 limits to ~1M of memory */ -SYSCTL_NODE(_kern, KERN_POSIX, posix, CTLFLAG_RW, 0, "Posix"); -SYSCTL_NODE(_kern_posix, OID_AUTO, sem, CTLFLAG_RW, 0, "Semaphores"); -SYSCTL_INT (_kern_posix_sem, OID_AUTO, max, CTLFLAG_RW, &posix_sem_max, 0, "max"); +SYSCTL_NODE(_kern, KERN_POSIX, posix, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Posix"); +SYSCTL_NODE(_kern_posix, OID_AUTO, sem, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "Semaphores"); +SYSCTL_LONG (_kern_posix_sem, OID_AUTO, max, CTLFLAG_RW, &posix_sem_max, "max"); struct psemstats psemstats; /* cache effectiveness statistics */ @@ -152,18 +167,18 @@ static int psem_cache_search(struct pseminfo **, static int psem_delete(struct pseminfo * pinfo); static int psem_read (struct fileproc *fp, struct uio *uio, - kauth_cred_t cred, int flags, struct proc *p); + int flags, vfs_context_t ctx); static int psem_write (struct fileproc *fp, struct uio *uio, - kauth_cred_t cred, int flags, struct proc *p); + int flags, vfs_context_t ctx); static int psem_ioctl (struct fileproc *fp, u_long com, - caddr_t data, struct proc *p); -static int psem_select (struct fileproc *fp, int which, void *wql, struct proc *p); -static int psem_closefile (struct fileglob *fp, struct proc *p); + caddr_t data, vfs_context_t ctx); +static int psem_select (struct fileproc *fp, int which, void *wql, vfs_context_t ctx); +static int psem_closefile (struct fileglob *fp, vfs_context_t ctx); -static int psem_kqfilter (struct fileproc *fp, struct knote *kn, struct proc *p); +static int psem_kqfilter (struct fileproc *fp, struct knote *kn, vfs_context_t ctx); struct fileops psemops = - { psem_read, psem_write, psem_ioctl, psem_select, psem_closefile, psem_kqfilter, 0 }; + { psem_read, psem_write, psem_ioctl, psem_select, psem_closefile, psem_kqfilter, NULL }; static lck_grp_t *psx_sem_subsys_lck_grp; @@ -200,10 +215,8 @@ psem_lock_init( void ) */ static int -psem_cache_search(psemp, pnp, pcache) - struct pseminfo **psemp; - struct psemname *pnp; - struct psemcache **pcache; +psem_cache_search(struct pseminfo **psemp, struct psemname *pnp, + struct psemcache **pcache) { struct psemcache *pcp, *nnp; struct psemhashhead *pcpp; @@ -254,7 +267,7 @@ psem_cache_add(struct pseminfo *psemp, struct psemname *pnp, struct psemcache *p struct psemcache *dpcp; #if DIAGNOSTIC - if (pnp->psem_namelen > NCHNAMLEN) + if (pnp->psem_namelen > PSEMNAMLEN) panic("cache_enter: name too long"); #endif @@ -295,7 +308,7 @@ psem_cache_add(struct pseminfo *psemp, struct psemname *pnp, struct psemcache *p void psem_cache_init(void) { - psemhashtbl = hashinit(desiredvnodes, M_SHM, &psemhash); + psemhashtbl = hashinit(posix_sem_max / 2, M_SHM, &psemhash); } static void @@ -308,7 +321,7 @@ psem_cache_delete(struct psemcache *pcp) panic("namecache purge le_next"); #endif /* DIAGNOSTIC */ LIST_REMOVE(pcp, psem_hash); - pcp->psem_hash.le_prev = 0; + pcp->psem_hash.le_prev = NULL; psemnument--; } @@ -335,16 +348,17 @@ psem_cache_purge(void) #endif /* NOT_USED */ int -sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) +sem_open(proc_t p, struct sem_open_args *uap, user_addr_t *retval) { - struct fileproc *fp; size_t i; - struct fileproc *nfp; int indx, error; struct psemname nd; struct pseminfo *pinfo; - struct psemcache *pcp; - char * pnbuf; + struct fileproc *fp = NULL; + char *pnbuf = NULL; + struct pseminfo *new_pinfo = PSEMINFO_NULL; + struct psemnode *new_pnode = PSEMNODE_NULL; + struct psemcache *pcache = PSEMCACHE_NULL; char * nameptr; char * cp; size_t pathlen, plen; @@ -352,20 +366,24 @@ sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) int cmode = uap->mode; int value = uap->value; int incache = 0; - struct psemnode * pnode = PSEMNODE_NULL; - struct psemcache * pcache = PSEMCACHE_NULL; - kern_return_t kret = KERN_SUCCESS; - int pinfo_alloc = 0; - + struct psemcache *pcp = PSEMCACHE_NULL; + kern_return_t kret = KERN_INVALID_ADDRESS; /* default fail */ + AUDIT_ARG(fflags, uap->oflag); AUDIT_ARG(mode, uap->mode); - AUDIT_ARG(value, uap->value); + AUDIT_ARG(value32, uap->value); pinfo = PSEMINFO_NULL; + /* + * Preallocate everything we might need up front to avoid taking + * and dropping the lock, opening us up to race conditions. + */ MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK); - if (pnbuf == NULL) - return(ENOSPC); + if (pnbuf == NULL) { + error = ENOSPC; + goto bad; + } pathlen = MAXPATHLEN; error = copyinstr(uap->name, pnbuf, MAXPATHLEN, &pathlen); @@ -396,39 +414,92 @@ sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) nameptr = pnbuf; nd.psem_nameptr = nameptr; nd.psem_namelen = plen; - nd. psem_hash =0; + nd.psem_hash = 0; for (cp = nameptr, i=1; *cp != 0 && i <= plen; i++, cp++) { nd.psem_hash += (unsigned char)*cp * i; } -#if KTRACE - if (KTRPOINT(p, KTR_NAMEI)) - ktrnamei(p->p_tracep, nameptr); + /* + * attempt to allocate a new fp; if unsuccessful, the fp will be + * left unmodified (NULL). + */ + error = falloc(p, &fp, &indx, vfs_context_current()); + if (error) + goto bad; + + /* + * We allocate a new entry if we are less than the maximum + * allowed and the one at the front of the LRU list is in use. + * Otherwise we use the one at the front of the LRU list. + */ + MALLOC(pcp, struct psemcache *, sizeof(struct psemcache), M_SHM, M_WAITOK|M_ZERO); + if (pcp == PSEMCACHE_NULL) { + error = ENOMEM; + goto bad; + } + + MALLOC(new_pinfo, struct pseminfo *, sizeof(struct pseminfo), M_SHM, M_WAITOK|M_ZERO); + if (new_pinfo == NULL) { + error = ENOSPC; + goto bad; + } +#if CONFIG_MACF + mac_posixsem_label_init(new_pinfo); #endif + + /* + * Provisionally create the semaphore in the new_pinfo; we have to do + * this here to prevent locking later. We use the value of kret to + * signal success or failure, which is why we set its default value + * to KERN_INVALID_ADDRESS, above. + */ + fmode = FFLAGS(uap->oflag); + + if((fmode & O_CREAT)) { + + if((value < 0) || (value > SEM_VALUE_MAX)) { + error = EINVAL; + goto bad; + } + + kret = semaphore_create(kernel_task, &new_pinfo->psem_semobject, SYNC_POLICY_FIFO, value); + + if (kret != KERN_SUCCESS) { + switch (kret) { + case KERN_RESOURCE_SHORTAGE: + error = ENOMEM; + break; + case KERN_PROTECTION_FAILURE: + error = EACCES; + break; + default: + error = EINVAL; + } + goto bad; + } + } + + MALLOC(new_pnode, struct psemnode *, sizeof(struct psemnode), M_SHM, M_WAITOK|M_ZERO); + if (new_pnode == NULL) { + error = ENOSPC; + goto bad; + } + PSEM_SUBSYS_LOCK(); error = psem_cache_search(&pinfo, &nd, &pcache); if (error == ENOENT) { - PSEM_SUBSYS_UNLOCK(); error = EINVAL; - goto bad; + goto bad_locked; } if (!error) { incache = 0; } else incache = 1; - fmode = FFLAGS(uap->oflag); - - PSEM_SUBSYS_UNLOCK(); - error = falloc(p, &nfp, &indx); - if (error) - goto bad; - PSEM_SUBSYS_LOCK(); - fp = nfp; cmode &= ALLPERMS; if (((fmode & (O_CREAT | O_EXCL))==(O_CREAT | O_EXCL)) && incache) { @@ -439,9 +510,8 @@ sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) #endif AUDIT_ARG(posix_ipc_perm, pinfo->psem_uid, pinfo->psem_gid, pinfo->psem_mode); - PSEM_SUBSYS_UNLOCK(); error = EEXIST; - goto bad1; + goto bad_locked; } if (((fmode & (O_CREAT | O_EXCL))== O_CREAT) && incache) { /* As per POSIX, O_CREAT has no effect */ @@ -449,20 +519,8 @@ sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) } if ( (fmode & O_CREAT) ) { - if((value < 0) && (value > SEM_VALUE_MAX)) { - PSEM_SUBSYS_UNLOCK(); - error = EINVAL; - goto bad1; - } - PSEM_SUBSYS_UNLOCK(); - MALLOC(pinfo, struct pseminfo *, sizeof(struct pseminfo), M_SHM, M_WAITOK|M_ZERO); - if (pinfo == NULL) { - error = ENOSPC; - goto bad1; - } - PSEM_SUBSYS_LOCK(); - - pinfo_alloc = 1; + /* create a new one (commit the allocation) */ + pinfo = new_pinfo; pinfo->psem_flags = PSEM_DEFINED | PSEM_INCREATE; pinfo->psem_usecount = 1; pinfo->psem_mode = cmode; @@ -470,72 +528,75 @@ sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) pinfo->psem_gid = kauth_cred_get()->cr_gid; bcopy(pnbuf, &pinfo->psem_name[0], PSEMNAMLEN); pinfo->psem_name[PSEMNAMLEN]= 0; - PSEM_SUBSYS_UNLOCK(); - kret = semaphore_create(kernel_task, &pinfo->psem_semobject, - SYNC_POLICY_FIFO, value); - if(kret != KERN_SUCCESS) - goto bad3; - PSEM_SUBSYS_LOCK(); pinfo->psem_flags &= ~PSEM_DEFINED; pinfo->psem_flags |= PSEM_ALLOCATED; pinfo->sem_proc = p; + +#if CONFIG_MACF + error = mac_posixsem_check_create(kauth_cred_get(), nameptr); + if (error) { + goto bad_locked; + } + mac_posixsem_label_associate(kauth_cred_get(), pinfo, nameptr); +#endif } else { /* semaphore should exist as it is without O_CREAT */ if (!incache) { - PSEM_SUBSYS_UNLOCK(); error = ENOENT; - goto bad1; + goto bad_locked; } if( pinfo->psem_flags & PSEM_INDELETE) { - PSEM_SUBSYS_UNLOCK(); error = ENOENT; - goto bad1; + goto bad_locked; } AUDIT_ARG(posix_ipc_perm, pinfo->psem_uid, pinfo->psem_gid, pinfo->psem_mode); +#if CONFIG_MACF + error = mac_posixsem_check_open(kauth_cred_get(), pinfo); + if (error) { + goto bad_locked; + } +#endif if ( (error = psem_access(pinfo, fmode, kauth_cred_get())) ) { - PSEM_SUBSYS_UNLOCK(); - goto bad1; + goto bad_locked; } } - PSEM_SUBSYS_UNLOCK(); - MALLOC(pnode, struct psemnode *, sizeof(struct psemnode), M_SHM, M_WAITOK|M_ZERO); - if (pnode == NULL) { - error = ENOSPC; - goto bad1; - } - if (!incache) { - /* - * We allocate a new entry if we are less than the maximum - * allowed and the one at the front of the LRU list is in use. - * Otherwise we use the one at the front of the LRU list. - */ - MALLOC(pcp, struct psemcache *, sizeof(struct psemcache), M_SHM, M_WAITOK|M_ZERO); - if (pcp == NULL) { - error = ENOMEM; - goto bad2; - } - } - PSEM_SUBSYS_LOCK(); if (!incache) { + /* if successful, this will consume the pcp */ if ( (error = psem_cache_add(pinfo, &nd, pcp)) ) { - PSEM_SUBSYS_UNLOCK(); - FREE(pcp, M_SHM); - goto bad2; + goto bad_locked; } } pinfo->psem_flags &= ~PSEM_INCREATE; pinfo->psem_usecount++; - pnode->pinfo = pinfo; + new_pnode->pinfo = pinfo; PSEM_SUBSYS_UNLOCK(); + /* + * if incache, we did not use the new pcp or the new pcp or the + * new . and we must free them. + */ + if (incache) { + FREE(pcp, M_SHM); + pcp = PSEMCACHE_NULL; + if (new_pinfo != PSEMINFO_NULL) { + /* return value ignored - we can't _not_ do this */ + (void)semaphore_destroy(kernel_task, new_pinfo->psem_semobject); +#if CONFIG_MACF + mac_posixsem_label_destroy(new_pinfo); +#endif + FREE(new_pinfo, M_SHM); + new_pinfo = PSEMINFO_NULL; + } + } + proc_fdlock(p); fp->f_flag = fmode & FMASK; fp->f_type = DTYPE_PSXSEM; fp->f_ops = &psemops; - fp->f_data = (caddr_t)pnode; - *fdflags(p, indx) &= ~UF_RESERVED; + fp->f_data = (caddr_t)new_pnode; + procfdtbl_releasefd(p, indx, NULL); fp_drop(p, indx, fp, 1); proc_fdunlock(p); @@ -543,24 +604,36 @@ sem_open(struct proc *p, struct sem_open_args *uap, user_addr_t *retval) FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI); return (0); -bad3: - switch (kret) { - case KERN_RESOURCE_SHORTAGE: - error = ENOMEM; - case KERN_PROTECTION_FAILURE: - error = EACCES; - default: - error = EINVAL; - } - goto bad1; -bad2: - FREE(pnode, M_SHM); -bad1: - if (pinfo_alloc) - FREE(pinfo, M_SHM); - fp_free(p, indx, nfp); +bad_locked: + PSEM_SUBSYS_UNLOCK(); bad: - FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI); + if (pcp != PSEMCACHE_NULL) + FREE(pcp, M_SHM); + + if (new_pnode != PSEMNODE_NULL) + FREE(new_pnode, M_SHM); + + if (fp != NULL) + fp_free(p, indx, fp); + + if (new_pinfo != PSEMINFO_NULL) { + /* + * kret signals whether or not we successfully created a + * Mach semaphore for this semaphore; if so, we need to + * destroy it here. + */ + if (kret == KERN_SUCCESS) { + /* return value ignored - we can't _not_ do this */ + (void)semaphore_destroy(kernel_task, new_pinfo->psem_semobject); + } +#if CONFIG_MACF + mac_posixsem_label_destroy(new_pinfo); +#endif + FREE(new_pinfo, M_SHM); + } + + if (pnbuf != NULL) + FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI); return (error); } @@ -606,7 +679,7 @@ psem_access(struct pseminfo *pinfo, int mode, kauth_cred_t cred) } int -sem_unlink(__unused struct proc *p, struct sem_unlink_args *uap, __unused register_t *retval) +sem_unlink(__unused proc_t p, struct sem_unlink_args *uap, __unused int32_t *retval) { size_t i; int error=0; @@ -676,6 +749,13 @@ sem_unlink(__unused struct proc *p, struct sem_unlink_args *uap, __unused regist goto bad; } else incache = 1; +#if CONFIG_MACF + error = mac_posixsem_check_unlink(kauth_cred_get(), pinfo, nameptr); + if (error) { + PSEM_SUBSYS_UNLOCK(); + goto bad; + } +#endif if ( (error = psem_access(pinfo, pinfo->psem_mode, kauth_cred_get())) ) { PSEM_SUBSYS_UNLOCK(); goto bad; @@ -683,7 +763,8 @@ sem_unlink(__unused struct proc *p, struct sem_unlink_args *uap, __unused regist if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))==0) { PSEM_SUBSYS_UNLOCK(); - return (EINVAL); + error = EINVAL; + goto bad; } if ( (pinfo->psem_flags & PSEM_INDELETE) ) { @@ -714,9 +795,9 @@ bad: } int -sem_close(struct proc *p, struct sem_close_args *uap, __unused register_t *retval) +sem_close(proc_t p, struct sem_close_args *uap, __unused int32_t *retval) { - int fd = CAST_DOWN(int,uap->sem); + int fd = CAST_DOWN_EXPLICIT(int,uap->sem); struct fileproc *fp; int error = 0; @@ -728,6 +809,7 @@ sem_close(struct proc *p, struct sem_close_args *uap, __unused register_t *retva proc_fdunlock(p); return(error); } + fileproc_drain(p, fp); fdrelse(p, fd); error = closef_locked(fp, fp->f_fglob, p); FREE_ZONE(fp, sizeof *fp, M_FILEPROC); @@ -736,9 +818,16 @@ sem_close(struct proc *p, struct sem_close_args *uap, __unused register_t *retva } int -sem_wait(struct proc *p, struct sem_wait_args *uap, __unused register_t *retval) +sem_wait(proc_t p, struct sem_wait_args *uap, int32_t *retval) +{ + __pthread_testcancel(1); + return(sem_wait_nocancel(p, (struct sem_wait_nocancel_args *)uap, retval)); +} + +int +sem_wait_nocancel(proc_t p, struct sem_wait_nocancel_args *uap, __unused int32_t *retval) { - int fd = CAST_DOWN(int,uap->sem); + int fd = CAST_DOWN_EXPLICIT(int,uap->sem); struct fileproc *fp; struct pseminfo * pinfo; struct psemnode * pnode ; @@ -764,7 +853,13 @@ sem_wait(struct proc *p, struct sem_wait_args *uap, __unused register_t *retval) error = EINVAL; goto out; } - +#if CONFIG_MACF + error = mac_posixsem_check_wait(kauth_cred_get(), pinfo); + if (error) { + PSEM_SUBSYS_UNLOCK(); + goto out; + } +#endif PSEM_SUBSYS_UNLOCK(); kret = semaphore_wait(pinfo->psem_semobject); switch (kret) { @@ -790,9 +885,9 @@ out: } int -sem_trywait(struct proc *p, struct sem_trywait_args *uap, __unused register_t *retval) +sem_trywait(proc_t p, struct sem_trywait_args *uap, __unused int32_t *retval) { - int fd = CAST_DOWN(int,uap->sem); + int fd = CAST_DOWN_EXPLICIT(int,uap->sem); struct fileproc *fp; struct pseminfo * pinfo; struct psemnode * pnode ; @@ -819,7 +914,13 @@ sem_trywait(struct proc *p, struct sem_trywait_args *uap, __unused register_t *r error = EINVAL; goto out; } - +#if CONFIG_MACF + error = mac_posixsem_check_wait(kauth_cred_get(), pinfo); + if (error) { + PSEM_SUBSYS_UNLOCK(); + goto out; + } +#endif PSEM_SUBSYS_UNLOCK(); wait_time.tv_sec = 0; wait_time.tv_nsec = 0; @@ -849,9 +950,9 @@ out: } int -sem_post(struct proc *p, struct sem_post_args *uap, __unused register_t *retval) +sem_post(proc_t p, struct sem_post_args *uap, __unused int32_t *retval) { - int fd = CAST_DOWN(int,uap->sem); + int fd = CAST_DOWN_EXPLICIT(int,uap->sem); struct fileproc *fp; struct pseminfo * pinfo; struct psemnode * pnode ; @@ -877,7 +978,13 @@ sem_post(struct proc *p, struct sem_post_args *uap, __unused register_t *retval) error = EINVAL; goto out; } - +#if CONFIG_MACF + error = mac_posixsem_check_post(kauth_cred_get(), pinfo); + if (error) { + PSEM_SUBSYS_UNLOCK(); + goto out; + } +#endif PSEM_SUBSYS_UNLOCK(); kret = semaphore_signal(pinfo->psem_semobject); switch (kret) { @@ -902,29 +1009,28 @@ out: } int -sem_init(__unused struct proc *p, __unused struct sem_init_args *uap, __unused register_t *retval) +sem_init(__unused proc_t p, __unused struct sem_init_args *uap, __unused int32_t *retval) { return(ENOSYS); } int -sem_destroy(__unused struct proc *p, __unused struct sem_destroy_args *uap, __unused register_t *retval) +sem_destroy(__unused proc_t p, __unused struct sem_destroy_args *uap, __unused int32_t *retval) { return(ENOSYS); } int -sem_getvalue(__unused struct proc *p, __unused struct sem_getvalue_args *uap, __unused register_t *retval) +sem_getvalue(__unused proc_t p, __unused struct sem_getvalue_args *uap, __unused int32_t *retval) { return(ENOSYS); } static int -psem_close(struct psemnode *pnode, __unused int flags, - __unused kauth_cred_t cred, __unused struct proc *p) +psem_close(struct psemnode *pnode, __unused int flags) { int error=0; - register struct pseminfo *pinfo; + struct pseminfo *pinfo; PSEM_SUBSYS_LOCK(); if ((pinfo = pnode->pinfo) == PSEMINFO_NULL){ @@ -957,15 +1063,15 @@ psem_close(struct psemnode *pnode, __unused int flags, } static int -psem_closefile(fg, p) - struct fileglob *fg; - struct proc *p; +psem_closefile(struct fileglob *fg, __unused vfs_context_t ctx) { int error; - /* Not locked as psem_close is called only from here and is locked properly */ - error = psem_close(((struct psemnode *)fg->fg_data), fg->fg_flag, - fg->fg_cred, p); + /* + * Not locked as psem_close is called only from here and is locked + * properly + */ + error = psem_close(((struct psemnode *)fg->fg_data), fg->fg_flag); return(error); } @@ -976,6 +1082,9 @@ psem_delete(struct pseminfo * pinfo) kern_return_t kret; kret = semaphore_destroy(kernel_task, pinfo->psem_semobject); +#if CONFIG_MACF + mac_posixsem_label_destroy(pinfo); +#endif switch (kret) { case KERN_INVALID_ADDRESS: @@ -993,37 +1102,35 @@ psem_delete(struct pseminfo * pinfo) static int psem_read(__unused struct fileproc *fp, __unused struct uio *uio, - __unused kauth_cred_t cred, __unused int flags, - __unused struct proc *p) + __unused int flags, __unused vfs_context_t ctx) { return(ENOTSUP); } static int psem_write(__unused struct fileproc *fp, __unused struct uio *uio, - __unused kauth_cred_t cred, __unused int flags, - __unused struct proc *p) + __unused int flags, __unused vfs_context_t ctx) { return(ENOTSUP); } static int psem_ioctl(__unused struct fileproc *fp, __unused u_long com, - __unused caddr_t data, __unused struct proc *p) + __unused caddr_t data, __unused vfs_context_t ctx) { return(ENOTSUP); } static int psem_select(__unused struct fileproc *fp, __unused int which, - __unused void *wql, __unused struct proc *p) + __unused void *wql, __unused vfs_context_t ctx) { return(ENOTSUP); } static int psem_kqfilter(__unused struct fileproc *fp, __unused struct knote *kn, - __unused struct proc *p) + __unused vfs_context_t ctx) { return (ENOTSUP); } @@ -1031,8 +1138,8 @@ psem_kqfilter(__unused struct fileproc *fp, __unused struct knote *kn, int fill_pseminfo(struct psemnode *pnode, struct psem_info * info) { - register struct pseminfo *pinfo; - struct stat *sb; + struct pseminfo *pinfo; + struct vinfo_stat *sb; PSEM_SUBSYS_LOCK(); if ((pinfo = pnode->pinfo) == PSEMINFO_NULL){ @@ -1048,15 +1155,35 @@ fill_pseminfo(struct psemnode *pnode, struct psem_info * info) #endif sb = &info->psem_stat; - bzero(sb, sizeof(struct stat)); + bzero(sb, sizeof(struct vinfo_stat)); - sb->st_mode = pinfo->psem_mode; - sb->st_uid = pinfo->psem_uid; - sb->st_gid = pinfo->psem_gid; - sb->st_size = pinfo->psem_usecount; + sb->vst_mode = pinfo->psem_mode; + sb->vst_uid = pinfo->psem_uid; + sb->vst_gid = pinfo->psem_gid; + sb->vst_size = pinfo->psem_usecount; bcopy(&pinfo->psem_name[0], &info->psem_name[0], PSEMNAMLEN+1); PSEM_SUBSYS_UNLOCK(); return(0); } +#if CONFIG_MACF +void +psem_label_associate(struct fileproc *fp, struct vnode *vp, vfs_context_t ctx) +{ + struct psemnode *pnode; + struct pseminfo *psem; + + PSEM_SUBSYS_LOCK(); + pnode = (struct psemnode *)fp->f_fglob->fg_data; + if (pnode != NULL) { + psem = pnode->pinfo; + if (psem != NULL) + mac_posixsem_vnode_label_associate( + vfs_context_ucred(ctx), psem, psem->psem_label, + vp, vp->v_label); + } + PSEM_SUBSYS_UNLOCK(); +} +#endif +