bsd/kern/posix_sem.c

   1 /*
   2  * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  *      Copyright (c) 1990, 1996-1998 Apple Computer, Inc.
  30  *      All Rights Reserved.
  31  */
  32 /*
  33  * posix_sem.c : Support for POSIX semaphore APIs
  34  *
  35  *      File:   posix_sem.c
  36  *      Author: Ananthakrishna Ramesh
  37  *
  38  * HISTORY
  39  * 2-Sep-1999   A.Ramesh
  40  *      Created for MacOSX
  41  *
  42  */
  43 /*
  44  * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
  45  * support for mandatory and extensible security protections.  This notice
  46  * is included in support of clause 2.2 (b) of the Apple Public License,
  47  * Version 2.0.
  48  */
  49
  50 #include <sys/cdefs.h>
  51 #include <sys/param.h>
  52 #include <sys/systm.h>
  53 #include <sys/kernel.h>
  54 #include <sys/file_internal.h>
  55 #include <sys/filedesc.h>
  56 #include <sys/stat.h>
  57 #include <sys/proc_internal.h>
  58 #include <sys/kauth.h>
  59 #include <sys/mount.h>
  60 #include <sys/namei.h>
  61 #include <sys/vnode.h>
  62 #include <sys/ioctl.h>
  63 #include <sys/tty.h>
  64 #include <sys/malloc.h>
  65 #include <sys/semaphore.h>
  66 #include <sys/sysproto.h>
  67 #include <sys/proc_info.h>
  68
  69 #if CONFIG_MACF
  70 #include <sys/vnode_internal.h>
  71 #include <security/mac_framework.h>
  72 #endif
  73
  74 #include <security/audit/audit.h>
  75
  76 #include <mach/mach_types.h>
  77 #include <mach/vm_prot.h>
  78 #include <mach/semaphore.h>
  79 #include <mach/sync_policy.h>
  80 #include <mach/task.h>
  81 #include <kern/kern_types.h>
  82 #include <kern/task.h>
  83 #include <kern/clock.h>
  84 #include <mach/kern_return.h>
  85
  86
  87 #define f_flag f_fglob->fg_flag
  88 #define f_type f_fglob->fg_ops->fo_type
  89 #define f_msgcount f_fglob->fg_msgcount
  90 #define f_cred f_fglob->fg_cred
  91 #define f_ops f_fglob->fg_ops
  92 #define f_offset f_fglob->fg_offset
  93 #define f_data f_fglob->fg_data
  94 #define PSEMNAMLEN      31      /* maximum name segment length we bother with */
  95
  96 struct pseminfo {
  97         unsigned int    psem_flags;
  98         unsigned int    psem_usecount;
  99         mode_t          psem_mode;
 100         uid_t           psem_uid;
 101         gid_t           psem_gid;
 102         char            psem_name[PSEMNAMLEN + 1];      /* segment name */
 103         semaphore_t     psem_semobject;
 104         struct label *  psem_label;
 105         pid_t           psem_creator_pid;
 106         uint64_t        psem_creator_uniqueid;
 107 };
 108 #define PSEMINFO_NULL (struct pseminfo *)0
 109
 110 #define PSEM_NONE       1
 111 #define PSEM_DEFINED    2
 112 #define PSEM_ALLOCATED  4
 113 #define PSEM_MAPPED     8
 114 #define PSEM_INUSE      0x10
 115 #define PSEM_REMOVED    0x20
 116 #define PSEM_INCREATE   0x40
 117 #define PSEM_INDELETE   0x80
 118
 119 struct  psemcache {
 120         LIST_ENTRY(psemcache) psem_hash;        /* hash chain */
 121         struct  pseminfo *pseminfo;             /* vnode the name refers to */
 122         int     psem_nlen;              /* length of name */
 123         char    psem_name[PSEMNAMLEN + 1];      /* segment name */
 124 };
 125 #define PSEMCACHE_NULL (struct psemcache *)0
 126
 127 #define PSEMCACHE_NOTFOUND (0)
 128 #define PSEMCACHE_FOUND    (-1)
 129 #define PSEMCACHE_NEGATIVE (ENOENT)
 130
 131 struct  psemstats {
 132         long    goodhits;               /* hits that we can really use */
 133         long    neghits;                /* negative hits that we can use */
 134         long    badhits;                /* hits we must drop */
 135         long    falsehits;              /* hits with id mismatch */
 136         long    miss;           /* misses */
 137         long    longnames;              /* long names that ignore cache */
 138 };
 139
 140 struct psemname {
 141         char    *psem_nameptr;  /* pointer to looked up name */
 142         long    psem_namelen;   /* length of looked up component */
 143         u_int32_t       psem_hash;      /* hash value of looked up name */
 144 };
 145
 146 struct psemnode {
 147         struct pseminfo *pinfo;
 148 #if DIAGNOSTIC
 149         unsigned int readcnt;
 150         unsigned int writecnt;
 151 #endif
 152 };
 153 #define PSEMNODE_NULL (struct psemnode *)0
 154
 155
 156 #define PSEMHASH(pnp) \
 157         (&psemhashtbl[(pnp)->psem_hash & psemhash])
 158 LIST_HEAD(psemhashhead, psemcache) * psemhashtbl;        /* Hash Table */
 159 u_long  psemhash;                               /* size of hash table - 1 */
 160 long    psemnument;                     /* number of cache entries allocated */
 161 long    posix_sem_max = 10000;          /* tunable for max POSIX semaphores */
 162                                         /* 10000 limits to ~1M of memory */
 163 SYSCTL_NODE(_kern, KERN_POSIX, posix, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "Posix");
 164 SYSCTL_NODE(_kern_posix, OID_AUTO, sem, CTLFLAG_RW | CTLFLAG_LOCKED, 0, "Semaphores");
 165 SYSCTL_LONG(_kern_posix_sem, OID_AUTO, max, CTLFLAG_RW | CTLFLAG_LOCKED, &posix_sem_max, "max");
 166
 167 struct psemstats psemstats;             /* cache effectiveness statistics */
 168
 169 static int psem_access(struct pseminfo *pinfo, int mode, kauth_cred_t cred);
 170 static int psem_cache_search(struct pseminfo **,
 171     struct psemname *, struct psemcache **);
 172 static int psem_delete(struct pseminfo * pinfo);
 173
 174 static int psem_closefile(struct fileglob *fp, vfs_context_t ctx);
 175 static int psem_unlink_internal(struct pseminfo *pinfo, struct psemcache *pcache);
 176
 177 static const struct fileops psemops = {
 178         .fo_type     = DTYPE_PSXSEM,
 179         .fo_read     = fo_no_read,
 180         .fo_write    = fo_no_write,
 181         .fo_ioctl    = fo_no_ioctl,
 182         .fo_select   = fo_no_select,
 183         .fo_close    = psem_closefile,
 184         .fo_drain    = fo_no_drain,
 185         .fo_kqfilter = fo_no_kqfilter,
 186 };
 187
 188 static lck_grp_t       *psx_sem_subsys_lck_grp;
 189 static lck_grp_attr_t  *psx_sem_subsys_lck_grp_attr;
 190 static lck_attr_t      *psx_sem_subsys_lck_attr;
 191 static lck_mtx_t        psx_sem_subsys_mutex;
 192
 193 #define PSEM_SUBSYS_LOCK() lck_mtx_lock(& psx_sem_subsys_mutex)
 194 #define PSEM_SUBSYS_UNLOCK() lck_mtx_unlock(& psx_sem_subsys_mutex)
 195 #define PSEM_SUBSYS_ASSERT_HELD() LCK_MTX_ASSERT(&psx_sem_subsys_mutex, LCK_MTX_ASSERT_OWNED)
 196
 197
 198 static int psem_cache_add(struct pseminfo *psemp, struct psemname *pnp, struct psemcache *pcp);
 199 static void psem_cache_delete(struct psemcache *pcp);
 200 int psem_cache_purge_all(proc_t);
 201
 202
 203 /* Initialize the mutex governing access to the posix sem subsystem */
 204 __private_extern__ void
 205 psem_lock_init( void )
 206 {
 207         psx_sem_subsys_lck_grp_attr = lck_grp_attr_alloc_init();
 208
 209         psx_sem_subsys_lck_grp = lck_grp_alloc_init("posix shared memory", psx_sem_subsys_lck_grp_attr);
 210
 211         psx_sem_subsys_lck_attr = lck_attr_alloc_init();
 212         lck_mtx_init(&psx_sem_subsys_mutex, psx_sem_subsys_lck_grp, psx_sem_subsys_lck_attr);
 213 }
 214
 215 /*
 216  * Lookup an entry in the cache
 217  *
 218  *
 219  * status of -1 is returned if matches
 220  * If the lookup determines that the name does not exist
 221  * (negative cacheing), a status of ENOENT is returned. If the lookup
 222  * fails, a status of zero is returned.
 223  */
 224
 225 static int
 226 psem_cache_search(struct pseminfo **psemp, struct psemname *pnp,
 227     struct psemcache **pcache)
 228 {
 229         struct psemcache *pcp, *nnp;
 230         struct psemhashhead *pcpp;
 231
 232         if (pnp->psem_namelen > PSEMNAMLEN) {
 233                 psemstats.longnames++;
 234                 return PSEMCACHE_NOTFOUND;
 235         }
 236
 237         pcpp = PSEMHASH(pnp);
 238         for (pcp = pcpp->lh_first; pcp != 0; pcp = nnp) {
 239                 nnp = pcp->psem_hash.le_next;
 240                 if (pcp->psem_nlen == pnp->psem_namelen &&
 241                     !bcmp(pcp->psem_name, pnp->psem_nameptr, (u_int)pcp->psem_nlen)) {
 242                         break;
 243                 }
 244         }
 245
 246         if (pcp == 0) {
 247                 psemstats.miss++;
 248                 return PSEMCACHE_NOTFOUND;
 249         }
 250
 251         /* We found a "positive" match, return the vnode */
 252         if (pcp->pseminfo) {
 253                 psemstats.goodhits++;
 254                 /* TOUCH(ncp); */
 255                 *psemp = pcp->pseminfo;
 256                 *pcache = pcp;
 257                 return PSEMCACHE_FOUND;
 258         }
 259
 260         /*
 261          * We found a "negative" match, ENOENT notifies client of this match.
 262          * The nc_vpid field records whether this is a whiteout.
 263          */
 264         psemstats.neghits++;
 265         return PSEMCACHE_NEGATIVE;
 266 }
 267
 268 /*
 269  * Add an entry to the cache.
 270  */
 271 static int
 272 psem_cache_add(struct pseminfo *psemp, struct psemname *pnp, struct psemcache *pcp)
 273 {
 274         struct psemhashhead *pcpp;
 275         struct pseminfo *dpinfo;
 276         struct psemcache *dpcp;
 277
 278 #if DIAGNOSTIC
 279         if (pnp->psem_namelen > PSEMNAMLEN) {
 280                 panic("cache_enter: name too long");
 281         }
 282 #endif
 283
 284
 285         /*  if the entry has already been added by some one else return */
 286         if (psem_cache_search(&dpinfo, pnp, &dpcp) == PSEMCACHE_FOUND) {
 287                 return EEXIST;
 288         }
 289         if (psemnument >= posix_sem_max) {
 290                 return ENOSPC;
 291         }
 292         psemnument++;
 293         /*
 294          * Fill in cache info, if vp is NULL this is a "negative" cache entry.
 295          * For negative entries, we have to record whether it is a whiteout.
 296          * the whiteout flag is stored in the nc_vpid field which is
 297          * otherwise unused.
 298          */
 299         pcp->pseminfo = psemp;
 300         pcp->psem_nlen = pnp->psem_namelen;
 301         bcopy(pnp->psem_nameptr, pcp->psem_name, (unsigned)pcp->psem_nlen);
 302         pcpp = PSEMHASH(pnp);
 303 #if DIAGNOSTIC
 304         {
 305                 struct psemcache *p;
 306
 307                 for (p = pcpp->lh_first; p != 0; p = p->psem_hash.le_next) {
 308                         if (p == pcp) {
 309                                 panic("psem:cache_enter duplicate");
 310                         }
 311                 }
 312         }
 313 #endif
 314         LIST_INSERT_HEAD(pcpp, pcp, psem_hash);
 315         return 0;
 316 }
 317
 318 /*
 319  * Name cache initialization, from vfs_init() when we are booting
 320  */
 321 void
 322 psem_cache_init(void)
 323 {
 324         psemhashtbl = hashinit(posix_sem_max / 2, M_SHM, &psemhash);
 325 }
 326
 327 static void
 328 psem_cache_delete(struct psemcache *pcp)
 329 {
 330 #if DIAGNOSTIC
 331         if (pcp->psem_hash.le_prev == 0) {
 332                 panic("psem namecache purge le_prev");
 333         }
 334         if (pcp->psem_hash.le_next == pcp) {
 335                 panic("namecache purge le_next");
 336         }
 337 #endif /* DIAGNOSTIC */
 338         LIST_REMOVE(pcp, psem_hash);
 339         pcp->psem_hash.le_prev = NULL;
 340         psemnument--;
 341 }
 342
 343 /*
 344  * Remove all cached psem entries. Open semaphores (with a positive refcount)
 345  * will continue to exist, but their cache entries tying them to a particular
 346  * name/path will be removed making all future lookups on the name fail.
 347  */
 348 int
 349 psem_cache_purge_all(__unused proc_t p)
 350 {
 351         struct psemcache *pcp, *tmppcp;
 352         struct psemhashhead *pcpp;
 353         int error = 0;
 354
 355         if (kauth_cred_issuser(kauth_cred_get()) == 0) {
 356                 return EPERM;
 357         }
 358
 359         PSEM_SUBSYS_LOCK();
 360         for (pcpp = &psemhashtbl[psemhash]; pcpp >= psemhashtbl; pcpp--) {
 361                 LIST_FOREACH_SAFE(pcp, pcpp, psem_hash, tmppcp) {
 362                         assert(pcp->psem_nlen);
 363                         /*
 364                          * unconditionally unlink the cache entry
 365                          */
 366                         error = psem_unlink_internal(pcp->pseminfo, pcp);
 367                         if (error) {
 368                                 goto out;
 369                         }
 370                 }
 371         }
 372         assert(psemnument == 0);
 373
 374 out:
 375         PSEM_SUBSYS_UNLOCK();
 376
 377         if (error) {
 378                 printf("%s: Error %d removing all semaphores: %ld remain!\n",
 379                     __func__, error, psemnument);
 380         }
 381         return error;
 382 }
 383
 384 int
 385 sem_open(proc_t p, struct sem_open_args *uap, user_addr_t *retval)
 386 {
 387         size_t i;
 388         int indx, error;
 389         struct psemname nd;
 390         struct pseminfo *pinfo;
 391         struct fileproc *fp = NULL;
 392         char *pnbuf = NULL;
 393         struct pseminfo *new_pinfo = PSEMINFO_NULL;
 394         struct psemnode *new_pnode = PSEMNODE_NULL;
 395         struct psemcache *pcache = PSEMCACHE_NULL;
 396         char * nameptr;
 397         char * cp;
 398         size_t pathlen, plen;
 399         int fmode;
 400         int cmode = uap->mode;
 401         int value = uap->value;
 402         int incache = 0;
 403         struct psemcache *pcp = PSEMCACHE_NULL;
 404         kern_return_t kret = KERN_INVALID_ADDRESS;      /* default fail */
 405
 406         AUDIT_ARG(fflags, uap->oflag);
 407         AUDIT_ARG(mode, uap->mode);
 408         AUDIT_ARG(value32, uap->value);
 409
 410         pinfo = PSEMINFO_NULL;
 411
 412         /*
 413          * Preallocate everything we might need up front to avoid taking
 414          * and dropping the lock, opening us up to race conditions.
 415          */
 416         MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK | M_ZERO);
 417         if (pnbuf == NULL) {
 418                 error = ENOSPC;
 419                 goto bad;
 420         }
 421
 422         pathlen = MAXPATHLEN;
 423         error = copyinstr(uap->name, pnbuf, MAXPATHLEN, &pathlen);
 424         if (error) {
 425                 goto bad;
 426         }
 427         AUDIT_ARG(text, pnbuf);
 428         if ((pathlen > PSEMNAMLEN)) {
 429                 error = ENAMETOOLONG;
 430                 goto bad;
 431         }
 432
 433 #ifdef PSXSEM_NAME_RESTRICT
 434         nameptr = pnbuf;
 435         if (*nameptr == '/') {
 436                 while (*(nameptr++) == '/') {
 437                         plen--;
 438                         error = EINVAL;
 439                         goto bad;
 440                 }
 441         } else {
 442                 error = EINVAL;
 443                 goto bad;
 444         }
 445 #endif /* PSXSEM_NAME_RESTRICT */
 446
 447         plen = pathlen;
 448         nameptr = pnbuf;
 449         nd.psem_nameptr = nameptr;
 450         nd.psem_namelen = plen;
 451         nd.psem_hash = 0;
 452
 453         for (cp = nameptr, i = 1; *cp != 0 && i <= plen; i++, cp++) {
 454                 nd.psem_hash += (unsigned char)*cp * i;
 455         }
 456
 457         /*
 458          * attempt to allocate a new fp; if unsuccessful, the fp will be
 459          * left unmodified (NULL).
 460          */
 461         error = falloc(p, &fp, &indx, vfs_context_current());
 462         if (error) {
 463                 goto bad;
 464         }
 465
 466         /*
 467          * We allocate a new entry if we are less than the maximum
 468          * allowed and the one at the front of the LRU list is in use.
 469          * Otherwise we use the one at the front of the LRU list.
 470          */
 471         MALLOC(pcp, struct psemcache *, sizeof(struct psemcache), M_SHM, M_WAITOK | M_ZERO);
 472         if (pcp == PSEMCACHE_NULL) {
 473                 error = ENOMEM;
 474                 goto bad;
 475         }
 476
 477         MALLOC(new_pinfo, struct pseminfo *, sizeof(struct pseminfo), M_SHM, M_WAITOK | M_ZERO);
 478         if (new_pinfo == NULL) {
 479                 error = ENOSPC;
 480                 goto bad;
 481         }
 482 #if CONFIG_MACF
 483         mac_posixsem_label_init(new_pinfo);
 484 #endif
 485
 486         /*
 487          * Provisionally create the semaphore in the new_pinfo; we have to do
 488          * this here to prevent locking later.  We use the value of kret to
 489          * signal success or failure, which is why we set its default value
 490          * to KERN_INVALID_ADDRESS, above.
 491          */
 492
 493         fmode = FFLAGS(uap->oflag);
 494
 495         if ((fmode & O_CREAT)) {
 496                 if ((value < 0) || (value > SEM_VALUE_MAX)) {
 497                         error = EINVAL;
 498                         goto bad;
 499                 }
 500
 501                 kret = semaphore_create(kernel_task, &new_pinfo->psem_semobject, SYNC_POLICY_FIFO, value);
 502
 503                 if (kret != KERN_SUCCESS) {
 504                         switch (kret) {
 505                         case KERN_RESOURCE_SHORTAGE:
 506                                 error = ENOMEM;
 507                                 break;
 508                         case KERN_PROTECTION_FAILURE:
 509                                 error = EACCES;
 510                                 break;
 511                         default:
 512                                 error = EINVAL;
 513                         }
 514                         goto bad;
 515                 }
 516         }
 517
 518         MALLOC(new_pnode, struct psemnode *, sizeof(struct psemnode), M_SHM, M_WAITOK | M_ZERO);
 519         if (new_pnode == NULL) {
 520                 error = ENOSPC;
 521                 goto bad;
 522         }
 523
 524         PSEM_SUBSYS_LOCK();
 525         error = psem_cache_search(&pinfo, &nd, &pcache);
 526
 527         if (error == PSEMCACHE_NEGATIVE) {
 528                 error = EINVAL;
 529                 goto bad_locked;
 530         }
 531
 532         if (error == PSEMCACHE_FOUND) {
 533                 incache = 1;
 534         } else {
 535                 incache = 0;
 536         }
 537
 538         cmode &=  ALLPERMS;
 539
 540         if (((fmode & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) && incache) {
 541                 /* sem exists and opened O_EXCL */
 542 #if notyet
 543                 if (pinfo->psem_flags & PSEM_INDELETE) {
 544                 }
 545 #endif
 546                 AUDIT_ARG(posix_ipc_perm, pinfo->psem_uid,
 547                     pinfo->psem_gid, pinfo->psem_mode);
 548                 error = EEXIST;
 549                 goto bad_locked;
 550         }
 551         if (((fmode & (O_CREAT | O_EXCL)) == O_CREAT) && incache) {
 552                 /* As per POSIX, O_CREAT has no effect */
 553                 fmode &= ~O_CREAT;
 554         }
 555
 556         if ((fmode & O_CREAT)) {
 557                 /* create a new one (commit the allocation) */
 558                 pinfo = new_pinfo;
 559                 pinfo->psem_flags = PSEM_DEFINED | PSEM_INCREATE;
 560                 pinfo->psem_usecount = 1;
 561                 pinfo->psem_mode = cmode;
 562                 pinfo->psem_uid = kauth_getuid();
 563                 pinfo->psem_gid = kauth_getgid();
 564                 bcopy(pnbuf, &pinfo->psem_name[0], PSEMNAMLEN);
 565                 pinfo->psem_name[PSEMNAMLEN] = 0;
 566                 pinfo->psem_flags &= ~PSEM_DEFINED;
 567                 pinfo->psem_flags |= PSEM_ALLOCATED;
 568                 pinfo->psem_creator_pid = p->p_pid;
 569                 pinfo->psem_creator_uniqueid = p->p_uniqueid;
 570
 571 #if CONFIG_MACF
 572                 error = mac_posixsem_check_create(kauth_cred_get(), nameptr);
 573                 if (error) {
 574                         goto bad_locked;
 575                 }
 576                 mac_posixsem_label_associate(kauth_cred_get(), pinfo, nameptr);
 577 #endif
 578         } else {
 579                 /* semaphore should exist as it is without  O_CREAT */
 580                 if (!incache) {
 581                         error = ENOENT;
 582                         goto bad_locked;
 583                 }
 584                 if (pinfo->psem_flags & PSEM_INDELETE) {
 585                         error = ENOENT;
 586                         goto bad_locked;
 587                 }
 588                 AUDIT_ARG(posix_ipc_perm, pinfo->psem_uid,
 589                     pinfo->psem_gid, pinfo->psem_mode);
 590 #if CONFIG_MACF
 591                 error = mac_posixsem_check_open(kauth_cred_get(), pinfo);
 592                 if (error) {
 593                         goto bad_locked;
 594                 }
 595 #endif
 596                 if ((error = psem_access(pinfo, fmode, kauth_cred_get()))) {
 597                         goto bad_locked;
 598                 }
 599         }
 600
 601         if (!incache) {
 602                 /* if successful, this will consume the pcp */
 603                 if ((error = psem_cache_add(pinfo, &nd, pcp))) {
 604                         goto bad_locked;
 605                 }
 606         }
 607         pinfo->psem_flags &= ~PSEM_INCREATE;
 608         pinfo->psem_usecount++;
 609         new_pnode->pinfo = pinfo;
 610         PSEM_SUBSYS_UNLOCK();
 611
 612         /*
 613          * if incache, we did not use the new pcp or the new pcp or the
 614          * new . and we must free them.
 615          */
 616         if (incache) {
 617                 FREE(pcp, M_SHM);
 618                 pcp = PSEMCACHE_NULL;
 619                 if (new_pinfo != PSEMINFO_NULL) {
 620                         /* return value ignored - we can't _not_ do this */
 621                         (void)semaphore_destroy(kernel_task, new_pinfo->psem_semobject);
 622 #if CONFIG_MACF
 623                         mac_posixsem_label_destroy(new_pinfo);
 624 #endif
 625                         FREE(new_pinfo, M_SHM);
 626                         new_pinfo = PSEMINFO_NULL;
 627                 }
 628         }
 629
 630         proc_fdlock(p);
 631         fp->f_flag = fmode & FMASK;
 632         fp->f_ops = &psemops;
 633         fp->f_data = (caddr_t)new_pnode;
 634         procfdtbl_releasefd(p, indx, NULL);
 635         fp_drop(p, indx, fp, 1);
 636         proc_fdunlock(p);
 637
 638         *retval = CAST_USER_ADDR_T(indx);
 639         FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI);
 640         return 0;
 641
 642 bad_locked:
 643         PSEM_SUBSYS_UNLOCK();
 644 bad:
 645         if (pcp != PSEMCACHE_NULL) {
 646                 FREE(pcp, M_SHM);
 647         }
 648
 649         if (new_pnode != PSEMNODE_NULL) {
 650                 FREE(new_pnode, M_SHM);
 651         }
 652
 653         if (fp != NULL) {
 654                 fp_free(p, indx, fp);
 655         }
 656
 657         if (new_pinfo != PSEMINFO_NULL) {
 658                 /*
 659                  * kret signals whether or not we successfully created a
 660                  * Mach semaphore for this semaphore; if so, we need to
 661                  * destroy it here.
 662                  */
 663                 if (kret == KERN_SUCCESS) {
 664                         /* return value ignored - we can't _not_ do this */
 665                         (void)semaphore_destroy(kernel_task, new_pinfo->psem_semobject);
 666                 }
 667 #if CONFIG_MACF
 668                 mac_posixsem_label_destroy(new_pinfo);
 669 #endif
 670                 FREE(new_pinfo, M_SHM);
 671         }
 672
 673         if (pnbuf != NULL) {
 674                 FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI);
 675         }
 676         return error;
 677 }
 678
 679 /*
 680  * XXX This code is repeated in several places
 681  */
 682 static int
 683 psem_access(struct pseminfo *pinfo, int mode, kauth_cred_t cred)
 684 {
 685         int mode_req = ((mode & FREAD) ? S_IRUSR : 0) |
 686             ((mode & FWRITE) ? S_IWUSR : 0);
 687
 688         /* Otherwise, user id 0 always gets access. */
 689         if (!suser(cred, NULL)) {
 690                 return 0;
 691         }
 692
 693         return posix_cred_access(cred, pinfo->psem_uid, pinfo->psem_gid, pinfo->psem_mode, mode_req);
 694 }
 695
 696 static int
 697 psem_unlink_internal(struct pseminfo *pinfo, struct psemcache *pcache)
 698 {
 699         PSEM_SUBSYS_ASSERT_HELD();
 700
 701         if (!pinfo || !pcache) {
 702                 return EINVAL;
 703         }
 704
 705         if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED)) == 0) {
 706                 return EINVAL;
 707         }
 708
 709         if (pinfo->psem_flags & PSEM_INDELETE) {
 710                 return 0;
 711         }
 712
 713         AUDIT_ARG(posix_ipc_perm, pinfo->psem_uid, pinfo->psem_gid,
 714             pinfo->psem_mode);
 715
 716         pinfo->psem_flags |= PSEM_INDELETE;
 717         pinfo->psem_usecount--;
 718
 719         if (!pinfo->psem_usecount) {
 720                 psem_delete(pinfo);
 721                 FREE(pinfo, M_SHM);
 722         } else {
 723                 pinfo->psem_flags |= PSEM_REMOVED;
 724         }
 725
 726         psem_cache_delete(pcache);
 727         FREE(pcache, M_SHM);
 728         return 0;
 729 }
 730
 731
 732 int
 733 sem_unlink(__unused proc_t p, struct sem_unlink_args *uap, __unused int32_t *retval)
 734 {
 735         size_t i;
 736         int error = 0;
 737         struct psemname nd;
 738         struct pseminfo *pinfo;
 739         char * nameptr;
 740         char * cp;
 741         char * pnbuf;
 742         size_t pathlen;
 743         struct psemcache *pcache = PSEMCACHE_NULL;
 744
 745         pinfo = PSEMINFO_NULL;
 746
 747         MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
 748         if (pnbuf == NULL) {
 749                 return ENOSPC;         /* XXX non-standard */
 750         }
 751         pathlen = MAXPATHLEN;
 752         error = copyinstr(uap->name, pnbuf, MAXPATHLEN, &pathlen);
 753         if (error) {
 754                 goto bad;
 755         }
 756         AUDIT_ARG(text, pnbuf);
 757         if (pathlen > PSEMNAMLEN) {
 758                 error = ENAMETOOLONG;
 759                 goto bad;
 760         }
 761
 762         nameptr = pnbuf;
 763
 764 #ifdef PSXSEM_NAME_RESTRICT
 765         if (*nameptr == '/') {
 766                 while (*(nameptr++) == '/') {
 767                         pathlen--;
 768                         error = EINVAL;
 769                         goto bad;
 770                 }
 771         } else {
 772                 error = EINVAL;
 773                 goto bad;
 774         }
 775 #endif /* PSXSEM_NAME_RESTRICT */
 776
 777         nd.psem_nameptr = nameptr;
 778         nd.psem_namelen = pathlen;
 779         nd.psem_hash = 0;
 780
 781         for (cp = nameptr, i = 1; *cp != 0 && i <= pathlen; i++, cp++) {
 782                 nd.psem_hash += (unsigned char)*cp * i;
 783         }
 784
 785         PSEM_SUBSYS_LOCK();
 786         error = psem_cache_search(&pinfo, &nd, &pcache);
 787
 788         if (error != PSEMCACHE_FOUND) {
 789                 PSEM_SUBSYS_UNLOCK();
 790                 error = ENOENT;
 791                 goto bad;
 792         }
 793
 794 #if CONFIG_MACF
 795         error = mac_posixsem_check_unlink(kauth_cred_get(), pinfo, nameptr);
 796         if (error) {
 797                 PSEM_SUBSYS_UNLOCK();
 798                 goto bad;
 799         }
 800 #endif
 801         if ((error = psem_access(pinfo, pinfo->psem_mode, kauth_cred_get()))) {
 802                 PSEM_SUBSYS_UNLOCK();
 803                 goto bad;
 804         }
 805
 806         error = psem_unlink_internal(pinfo, pcache);
 807         PSEM_SUBSYS_UNLOCK();
 808
 809 bad:
 810         FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI);
 811         return error;
 812 }
 813
 814 int
 815 sem_close(proc_t p, struct sem_close_args *uap, __unused int32_t *retval)
 816 {
 817         int fd = CAST_DOWN_EXPLICIT(int, uap->sem);
 818         struct fileproc *fp;
 819         int error = 0;
 820
 821         AUDIT_ARG(fd, fd); /* XXX This seems wrong; uap->sem is a pointer */
 822
 823         proc_fdlock(p);
 824         error = fp_lookup(p, fd, &fp, 1);
 825         if (error) {
 826                 proc_fdunlock(p);
 827                 return error;
 828         }
 829         if (fp->f_type != DTYPE_PSXSEM) {
 830                 fp_drop(p, fd, fp, 1);
 831                 proc_fdunlock(p);
 832                 return EBADF;
 833         }
 834         procfdtbl_markclosefd(p, fd);
 835         /* release the ref returned from fp_lookup before calling drain */
 836         (void) os_ref_release_locked(&fp->f_iocount);
 837         fileproc_drain(p, fp);
 838         fdrelse(p, fd);
 839         error = closef_locked(fp, fp->f_fglob, p);
 840         fileproc_free(fp);
 841         proc_fdunlock(p);
 842         return error;
 843 }
 844
 845 int
 846 sem_wait(proc_t p, struct sem_wait_args *uap, int32_t *retval)
 847 {
 848         __pthread_testcancel(1);
 849         return sem_wait_nocancel(p, (struct sem_wait_nocancel_args *)uap, retval);
 850 }
 851
 852 int
 853 sem_wait_nocancel(proc_t p, struct sem_wait_nocancel_args *uap, __unused int32_t *retval)
 854 {
 855         int fd = CAST_DOWN_EXPLICIT(int, uap->sem);
 856         struct fileproc *fp;
 857         struct pseminfo * pinfo;
 858         struct psemnode * pnode;
 859         kern_return_t kret;
 860         int error;
 861
 862         error = fp_getfpsem(p, fd, &fp, &pnode);
 863         if (error) {
 864                 return error;
 865         }
 866         if (((pnode = (struct psemnode *)fp->f_data)) == PSEMNODE_NULL) {
 867                 error = EINVAL;
 868                 goto out;
 869         }
 870         PSEM_SUBSYS_LOCK();
 871         if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
 872                 PSEM_SUBSYS_UNLOCK();
 873                 error = EINVAL;
 874                 goto out;
 875         }
 876         if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))
 877             != PSEM_ALLOCATED) {
 878                 PSEM_SUBSYS_UNLOCK();
 879                 error = EINVAL;
 880                 goto out;
 881         }
 882 #if CONFIG_MACF
 883         error = mac_posixsem_check_wait(kauth_cred_get(), pinfo);
 884         if (error) {
 885                 PSEM_SUBSYS_UNLOCK();
 886                 goto out;
 887         }
 888 #endif
 889         PSEM_SUBSYS_UNLOCK();
 890         kret = semaphore_wait(pinfo->psem_semobject);
 891         switch (kret) {
 892         case KERN_INVALID_ADDRESS:
 893         case KERN_PROTECTION_FAILURE:
 894                 error = EACCES;
 895                 break;
 896         case KERN_ABORTED:
 897         case KERN_OPERATION_TIMED_OUT:
 898                 error = EINTR;
 899                 break;
 900         case KERN_SUCCESS:
 901                 error = 0;
 902                 break;
 903         default:
 904                 error = EINVAL;
 905                 break;
 906         }
 907 out:
 908         fp_drop(p, fd, fp, 0);
 909         return error;
 910 }
 911
 912 int
 913 sem_trywait(proc_t p, struct sem_trywait_args *uap, __unused int32_t *retval)
 914 {
 915         int fd = CAST_DOWN_EXPLICIT(int, uap->sem);
 916         struct fileproc *fp;
 917         struct pseminfo * pinfo;
 918         struct psemnode * pnode;
 919         kern_return_t kret;
 920         mach_timespec_t wait_time;
 921         int error;
 922
 923         error = fp_getfpsem(p, fd, &fp, &pnode);
 924         if (error) {
 925                 return error;
 926         }
 927         if (((pnode = (struct psemnode *)fp->f_data)) == PSEMNODE_NULL) {
 928                 error = EINVAL;
 929                 goto out;
 930         }
 931         PSEM_SUBSYS_LOCK();
 932         if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
 933                 PSEM_SUBSYS_UNLOCK();
 934                 error = EINVAL;
 935                 goto out;
 936         }
 937         if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))
 938             != PSEM_ALLOCATED) {
 939                 PSEM_SUBSYS_UNLOCK();
 940                 error = EINVAL;
 941                 goto out;
 942         }
 943 #if CONFIG_MACF
 944         error = mac_posixsem_check_wait(kauth_cred_get(), pinfo);
 945         if (error) {
 946                 PSEM_SUBSYS_UNLOCK();
 947                 goto out;
 948         }
 949 #endif
 950         PSEM_SUBSYS_UNLOCK();
 951         wait_time.tv_sec = 0;
 952         wait_time.tv_nsec = 0;
 953
 954         kret = semaphore_timedwait(pinfo->psem_semobject, MACH_TIMESPEC_ZERO);
 955         switch (kret) {
 956         case KERN_INVALID_ADDRESS:
 957         case KERN_PROTECTION_FAILURE:
 958                 error = EINVAL;
 959                 break;
 960         case KERN_ABORTED:
 961                 error = EINTR;
 962                 break;
 963         case KERN_OPERATION_TIMED_OUT:
 964                 error = EAGAIN;
 965                 break;
 966         case KERN_SUCCESS:
 967                 error = 0;
 968                 break;
 969         default:
 970                 error = EINVAL;
 971                 break;
 972         }
 973 out:
 974         fp_drop(p, fd, fp, 0);
 975         return error;
 976 }
 977
 978 int
 979 sem_post(proc_t p, struct sem_post_args *uap, __unused int32_t *retval)
 980 {
 981         int fd = CAST_DOWN_EXPLICIT(int, uap->sem);
 982         struct fileproc *fp;
 983         struct pseminfo * pinfo;
 984         struct psemnode * pnode;
 985         kern_return_t kret;
 986         int error;
 987
 988         error = fp_getfpsem(p, fd, &fp, &pnode);
 989         if (error) {
 990                 return error;
 991         }
 992         if (((pnode = (struct psemnode *)fp->f_data)) == PSEMNODE_NULL) {
 993                 error = EINVAL;
 994                 goto out;
 995         }
 996         PSEM_SUBSYS_LOCK();
 997         if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
 998                 PSEM_SUBSYS_UNLOCK();
 999                 error = EINVAL;
1000                 goto out;
1001         }
1002         if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))
1003             != PSEM_ALLOCATED) {
1004                 PSEM_SUBSYS_UNLOCK();
1005                 error = EINVAL;
1006                 goto out;
1007         }
1008 #if CONFIG_MACF
1009         error = mac_posixsem_check_post(kauth_cred_get(), pinfo);
1010         if (error) {
1011                 PSEM_SUBSYS_UNLOCK();
1012                 goto out;
1013         }
1014 #endif
1015         PSEM_SUBSYS_UNLOCK();
1016         kret = semaphore_signal(pinfo->psem_semobject);
1017         switch (kret) {
1018         case KERN_INVALID_ADDRESS:
1019         case KERN_PROTECTION_FAILURE:
1020                 error = EINVAL;
1021                 break;
1022         case KERN_ABORTED:
1023         case KERN_OPERATION_TIMED_OUT:
1024                 error = EINTR;
1025                 break;
1026         case KERN_SUCCESS:
1027                 error = 0;
1028                 break;
1029         default:
1030                 error = EINVAL;
1031                 break;
1032         }
1033 out:
1034         fp_drop(p, fd, fp, 0);
1035         return error;
1036 }
1037
1038 static int
1039 psem_close(struct psemnode *pnode, __unused int flags)
1040 {
1041         int error = 0;
1042         struct pseminfo *pinfo;
1043
1044         PSEM_SUBSYS_LOCK();
1045         if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
1046                 PSEM_SUBSYS_UNLOCK();
1047                 return EINVAL;
1048         }
1049
1050         if ((pinfo->psem_flags & PSEM_ALLOCATED) != PSEM_ALLOCATED) {
1051                 PSEM_SUBSYS_UNLOCK();
1052                 return EINVAL;
1053         }
1054 #if DIAGNOSTIC
1055         if (!pinfo->psem_usecount) {
1056                 kprintf("negative usecount in psem_close\n");
1057         }
1058 #endif /* DIAGNOSTIC */
1059         pinfo->psem_usecount--;
1060
1061         if ((pinfo->psem_flags & PSEM_REMOVED) && !pinfo->psem_usecount) {
1062                 PSEM_SUBSYS_UNLOCK();
1063                 /* lock dropped as only semaphore is destroyed here */
1064                 error = psem_delete(pinfo);
1065                 FREE(pinfo, M_SHM);
1066         } else {
1067                 PSEM_SUBSYS_UNLOCK();
1068         }
1069         /* subsystem lock is dropped when we get here */
1070         FREE(pnode, M_SHM);
1071         return error;
1072 }
1073
1074 static int
1075 psem_closefile(struct fileglob *fg, __unused vfs_context_t ctx)
1076 {
1077         int error;
1078
1079         /*
1080          * Not locked as psem_close is called only from here and is locked
1081          * properly
1082          */
1083         error =  psem_close(((struct psemnode *)fg->fg_data), fg->fg_flag);
1084
1085         return error;
1086 }
1087
1088 static int
1089 psem_delete(struct pseminfo * pinfo)
1090 {
1091         kern_return_t kret;
1092
1093         kret = semaphore_destroy(kernel_task, pinfo->psem_semobject);
1094 #if CONFIG_MACF
1095         mac_posixsem_label_destroy(pinfo);
1096 #endif
1097
1098         switch (kret) {
1099         case KERN_INVALID_ADDRESS:
1100         case KERN_PROTECTION_FAILURE:
1101                 return EINVAL;
1102         case KERN_ABORTED:
1103         case KERN_OPERATION_TIMED_OUT:
1104                 return EINTR;
1105         case KERN_SUCCESS:
1106                 return 0;
1107         default:
1108                 return EINVAL;
1109         }
1110 }
1111
1112 int
1113 fill_pseminfo(struct psemnode *pnode, struct psem_info * info)
1114 {
1115         struct pseminfo *pinfo;
1116         struct vinfo_stat  *sb;
1117
1118         PSEM_SUBSYS_LOCK();
1119         if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
1120                 PSEM_SUBSYS_UNLOCK();
1121                 return EINVAL;
1122         }
1123
1124 #if 0
1125         if ((pinfo->psem_flags & PSEM_ALLOCATED) != PSEM_ALLOCATED) {
1126                 PSEM_SUBSYS_UNLOCK();
1127                 return EINVAL;
1128         }
1129 #endif
1130
1131         sb = &info->psem_stat;
1132         bzero(sb, sizeof(struct vinfo_stat));
1133
1134         sb->vst_mode = pinfo->psem_mode;
1135         sb->vst_uid = pinfo->psem_uid;
1136         sb->vst_gid = pinfo->psem_gid;
1137         sb->vst_size = pinfo->psem_usecount;
1138         bcopy(&pinfo->psem_name[0], &info->psem_name[0], PSEMNAMLEN + 1);
1139
1140         PSEM_SUBSYS_UNLOCK();
1141         return 0;
1142 }
1143
1144 #if CONFIG_MACF
1145 void
1146 psem_label_associate(struct fileproc *fp, struct vnode *vp, vfs_context_t ctx)
1147 {
1148         struct psemnode *pnode;
1149         struct pseminfo *psem;
1150
1151         PSEM_SUBSYS_LOCK();
1152         pnode = (struct psemnode *)fp->f_fglob->fg_data;
1153         if (pnode != NULL) {
1154                 psem = pnode->pinfo;
1155                 if (psem != NULL) {
1156                         mac_posixsem_vnode_label_associate(
1157                                 vfs_context_ucred(ctx), psem, psem->psem_label,
1158                                 vp, vp->v_label);
1159                 }
1160         }
1161         PSEM_SUBSYS_UNLOCK();
1162 }
1163 #endif