]> git.saurik.com Git - apple/xnu.git/blob - bsd/kern/posix_sem.c
projects / apple / xnu.git / blob
? search:


9dc882363251acc510b282af4cfd551f7804d441
[apple/xnu.git] / 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_read (struct fileproc *fp, struct uio *uio,
175 int flags, vfs_context_t ctx);
176 static int psem_write (struct fileproc *fp, struct uio *uio,
177 int flags, vfs_context_t ctx);
178 static int psem_ioctl (struct fileproc *fp, u_long com,
179 caddr_t data, vfs_context_t ctx);
180 static int psem_select (struct fileproc *fp, int which, void *wql, vfs_context_t ctx);
181 static int psem_closefile (struct fileglob *fp, vfs_context_t ctx);
182 static int psem_unlink_internal(struct pseminfo *pinfo, struct psemcache *pcache);
183
184 static int psem_kqfilter (struct fileproc *fp, struct knote *kn,
185 struct kevent_internal_s *kev, vfs_context_t ctx);
186
187 static const struct fileops psemops = {
188 .fo_type = DTYPE_PSXSEM,
189 .fo_read = psem_read,
190 .fo_write = psem_write,
191 .fo_ioctl = psem_ioctl,
192 .fo_select = psem_select,
193 .fo_close = psem_closefile,
194 .fo_kqfilter = psem_kqfilter,
195 .fo_drain = NULL,
196 };
197
198 static lck_grp_t *psx_sem_subsys_lck_grp;
199 static lck_grp_attr_t *psx_sem_subsys_lck_grp_attr;
200 static lck_attr_t *psx_sem_subsys_lck_attr;
201 static lck_mtx_t psx_sem_subsys_mutex;
202
203 #define PSEM_SUBSYS_LOCK() lck_mtx_lock(& psx_sem_subsys_mutex)
204 #define PSEM_SUBSYS_UNLOCK() lck_mtx_unlock(& psx_sem_subsys_mutex)
205 #define PSEM_SUBSYS_ASSERT_HELD() LCK_MTX_ASSERT(&psx_sem_subsys_mutex, LCK_MTX_ASSERT_OWNED)
206
207
208 static int psem_cache_add(struct pseminfo *psemp, struct psemname *pnp, struct psemcache *pcp);
209 static void psem_cache_delete(struct psemcache *pcp);
210 int psem_cache_purge_all(proc_t);
211
212
213 /* Initialize the mutex governing access to the posix sem subsystem */
214 __private_extern__ void
215 psem_lock_init( void )
216 {
217
218 psx_sem_subsys_lck_grp_attr = lck_grp_attr_alloc_init();
219
220 psx_sem_subsys_lck_grp = lck_grp_alloc_init("posix shared memory", psx_sem_subsys_lck_grp_attr);
221
222 psx_sem_subsys_lck_attr = lck_attr_alloc_init();
223 lck_mtx_init(& psx_sem_subsys_mutex, psx_sem_subsys_lck_grp, psx_sem_subsys_lck_attr);
224 }
225
226 /*
227 * Lookup an entry in the cache
228 *
229 *
230 * status of -1 is returned if matches
231 * If the lookup determines that the name does not exist
232 * (negative cacheing), a status of ENOENT is returned. If the lookup
233 * fails, a status of zero is returned.
234 */
235
236 static int
237 psem_cache_search(struct pseminfo **psemp, struct psemname *pnp,
238 struct psemcache **pcache)
239 {
240 struct psemcache *pcp, *nnp;
241 struct psemhashhead *pcpp;
242
243 if (pnp->psem_namelen > PSEMNAMLEN) {
244 psemstats.longnames++;
245 return PSEMCACHE_NOTFOUND;
246 }
247
248 pcpp = PSEMHASH(pnp);
249 for (pcp = pcpp->lh_first; pcp != 0; pcp = nnp) {
250 nnp = pcp->psem_hash.le_next;
251 if (pcp->psem_nlen == pnp->psem_namelen &&
252 !bcmp(pcp->psem_name, pnp->psem_nameptr, (u_int)pcp-> psem_nlen))
253 break;
254 }
255
256 if (pcp == 0) {
257 psemstats.miss++;
258 return PSEMCACHE_NOTFOUND;
259 }
260
261 /* We found a "positive" match, return the vnode */
262 if (pcp->pseminfo) {
263 psemstats.goodhits++;
264 /* TOUCH(ncp); */
265 *psemp = pcp->pseminfo;
266 *pcache = pcp;
267 return PSEMCACHE_FOUND;
268 }
269
270 /*
271 * We found a "negative" match, ENOENT notifies client of this match.
272 * The nc_vpid field records whether this is a whiteout.
273 */
274 psemstats.neghits++;
275 return PSEMCACHE_NEGATIVE;
276 }
277
278 /*
279 * Add an entry to the cache.
280 */
281 static int
282 psem_cache_add(struct pseminfo *psemp, struct psemname *pnp, struct psemcache *pcp)
283 {
284 struct psemhashhead *pcpp;
285 struct pseminfo *dpinfo;
286 struct psemcache *dpcp;
287
288 #if DIAGNOSTIC
289 if (pnp->psem_namelen > PSEMNAMLEN)
290 panic("cache_enter: name too long");
291 #endif
292
293
294 /* if the entry has already been added by some one else return */
295 if (psem_cache_search(&dpinfo, pnp, &dpcp) == PSEMCACHE_FOUND) {
296 return EEXIST;
297 }
298 if (psemnument >= posix_sem_max)
299 return ENOSPC;
300 psemnument++;
301 /*
302 * Fill in cache info, if vp is NULL this is a "negative" cache entry.
303 * For negative entries, we have to record whether it is a whiteout.
304 * the whiteout flag is stored in the nc_vpid field which is
305 * otherwise unused.
306 */
307 pcp->pseminfo = psemp;
308 pcp->psem_nlen = pnp->psem_namelen;
309 bcopy(pnp->psem_nameptr, pcp->psem_name, (unsigned)pcp->psem_nlen);
310 pcpp = PSEMHASH(pnp);
311 #if DIAGNOSTIC
312 {
313 struct psemcache *p;
314
315 for (p = pcpp->lh_first; p != 0; p = p->psem_hash.le_next)
316 if (p == pcp)
317 panic("psem:cache_enter duplicate");
318 }
319 #endif
320 LIST_INSERT_HEAD(pcpp, pcp, psem_hash);
321 return 0;
322 }
323
324 /*
325 * Name cache initialization, from vfs_init() when we are booting
326 */
327 void
328 psem_cache_init(void)
329 {
330 psemhashtbl = hashinit(posix_sem_max / 2, M_SHM, &psemhash);
331 }
332
333 static void
334 psem_cache_delete(struct psemcache *pcp)
335 {
336 #if DIAGNOSTIC
337 if (pcp->psem_hash.le_prev == 0)
338 panic("psem namecache purge le_prev");
339 if (pcp->psem_hash.le_next == pcp)
340 panic("namecache purge le_next");
341 #endif /* DIAGNOSTIC */
342 LIST_REMOVE(pcp, psem_hash);
343 pcp->psem_hash.le_prev = NULL;
344 psemnument--;
345 }
346
347 /*
348 * Remove all cached psem entries. Open semaphores (with a positive refcount)
349 * will continue to exist, but their cache entries tying them to a particular
350 * name/path will be removed making all future lookups on the name fail.
351 */
352 int
353 psem_cache_purge_all(__unused proc_t p)
354 {
355 struct psemcache *pcp, *tmppcp;
356 struct psemhashhead *pcpp;
357 int error = 0;
358
359 if (kauth_cred_issuser(kauth_cred_get()) == 0)
360 return EPERM;
361
362 PSEM_SUBSYS_LOCK();
363 for (pcpp = &psemhashtbl[psemhash]; pcpp >= psemhashtbl; pcpp--) {
364 LIST_FOREACH_SAFE(pcp, pcpp, psem_hash, tmppcp) {
365 assert(pcp->psem_nlen);
366 /*
367 * unconditionally unlink the cache entry
368 */
369 error = psem_unlink_internal(pcp->pseminfo, pcp);
370 if (error)
371 goto out;
372 }
373 }
374 assert(psemnument == 0);
375
376 out:
377 PSEM_SUBSYS_UNLOCK();
378
379 if (error)
380 printf("%s: Error %d removing all semaphores: %ld remain!\n",
381 __func__, error, psemnument);
382 return error;
383 }
384
385 int
386 sem_open(proc_t p, struct sem_open_args *uap, user_addr_t *retval)
387 {
388 size_t i;
389 int indx, error;
390 struct psemname nd;
391 struct pseminfo *pinfo;
392 struct fileproc *fp = NULL;
393 char *pnbuf = NULL;
394 struct pseminfo *new_pinfo = PSEMINFO_NULL;
395 struct psemnode *new_pnode = PSEMNODE_NULL;
396 struct psemcache *pcache = PSEMCACHE_NULL;
397 char * nameptr;
398 char * cp;
399 size_t pathlen, plen;
400 int fmode ;
401 int cmode = uap->mode;
402 int value = uap->value;
403 int incache = 0;
404 struct psemcache *pcp = PSEMCACHE_NULL;
405 kern_return_t kret = KERN_INVALID_ADDRESS; /* default fail */
406
407 AUDIT_ARG(fflags, uap->oflag);
408 AUDIT_ARG(mode, uap->mode);
409 AUDIT_ARG(value32, uap->value);
410
411 pinfo = PSEMINFO_NULL;
412
413 /*
414 * Preallocate everything we might need up front to avoid taking
415 * and dropping the lock, opening us up to race conditions.
416 */
417 MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK | M_ZERO);
418 if (pnbuf == NULL) {
419 error = ENOSPC;
420 goto bad;
421 }
422
423 pathlen = MAXPATHLEN;
424 error = copyinstr(uap->name, pnbuf, MAXPATHLEN, &pathlen);
425 if (error) {
426 goto bad;
427 }
428 AUDIT_ARG(text, pnbuf);
429 if ( (pathlen > PSEMNAMLEN) ) {
430 error = ENAMETOOLONG;
431 goto bad;
432 }
433
434 #ifdef PSXSEM_NAME_RESTRICT
435 nameptr = pnbuf;
436 if (*nameptr == '/') {
437 while (*(nameptr++) == '/') {
438 plen--;
439 error = EINVAL;
440 goto bad;
441 }
442 } else {
443 error = EINVAL;
444 goto bad;
445 }
446 #endif /* PSXSEM_NAME_RESTRICT */
447
448 plen = pathlen;
449 nameptr = pnbuf;
450 nd.psem_nameptr = nameptr;
451 nd.psem_namelen = plen;
452 nd.psem_hash = 0;
453
454 for (cp = nameptr, i=1; *cp != 0 && i <= plen; i++, cp++) {
455 nd.psem_hash += (unsigned char)*cp * i;
456 }
457
458 /*
459 * attempt to allocate a new fp; if unsuccessful, the fp will be
460 * left unmodified (NULL).
461 */
462 error = falloc(p, &fp, &indx, vfs_context_current());
463 if (error)
464 goto bad;
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
497 if((value < 0) || (value > SEM_VALUE_MAX)) {
498 error = EINVAL;
499 goto bad;
500 }
501
502 kret = semaphore_create(kernel_task, &new_pinfo->psem_semobject, SYNC_POLICY_FIFO, value);
503
504 if (kret != KERN_SUCCESS) {
505 switch (kret) {
506 case KERN_RESOURCE_SHORTAGE:
507 error = ENOMEM;
508 break;
509 case KERN_PROTECTION_FAILURE:
510 error = EACCES;
511 break;
512 default:
513 error = EINVAL;
514 }
515 goto bad;
516 }
517 }
518
519 MALLOC(new_pnode, struct psemnode *, sizeof(struct psemnode), M_SHM, M_WAITOK|M_ZERO);
520 if (new_pnode == NULL) {
521 error = ENOSPC;
522 goto bad;
523 }
524
525 PSEM_SUBSYS_LOCK();
526 error = psem_cache_search(&pinfo, &nd, &pcache);
527
528 if (error == PSEMCACHE_NEGATIVE) {
529 error = EINVAL;
530 goto bad_locked;
531 }
532
533 if (error == PSEMCACHE_FOUND)
534 incache = 1;
535 else
536 incache = 0;
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 if (new_pnode != PSEMNODE_NULL)
649 FREE(new_pnode, M_SHM);
650
651 if (fp != NULL)
652 fp_free(p, indx, fp);
653
654 if (new_pinfo != PSEMINFO_NULL) {
655 /*
656 * kret signals whether or not we successfully created a
657 * Mach semaphore for this semaphore; if so, we need to
658 * destroy it here.
659 */
660 if (kret == KERN_SUCCESS) {
661 /* return value ignored - we can't _not_ do this */
662 (void)semaphore_destroy(kernel_task, new_pinfo->psem_semobject);
663 }
664 #if CONFIG_MACF
665 mac_posixsem_label_destroy(new_pinfo);
666 #endif
667 FREE(new_pinfo, M_SHM);
668 }
669
670 if (pnbuf != NULL)
671 FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI);
672 return (error);
673 }
674
675 /*
676 * XXX This code is repeated in several places
677 */
678 static int
679 psem_access(struct pseminfo *pinfo, int mode, kauth_cred_t cred)
680 {
681 int mode_req = ((mode & FREAD) ? S_IRUSR : 0) |
682 ((mode & FWRITE) ? S_IWUSR : 0);
683
684 /* Otherwise, user id 0 always gets access. */
685 if (!suser(cred, NULL))
686 return (0);
687
688 return(posix_cred_access(cred, pinfo->psem_uid, pinfo->psem_gid, pinfo->psem_mode, mode_req));
689 }
690
691 static int
692 psem_unlink_internal(struct pseminfo *pinfo, struct psemcache *pcache)
693 {
694 PSEM_SUBSYS_ASSERT_HELD();
695
696 if (!pinfo || !pcache)
697 return EINVAL;
698
699 if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED)) == 0)
700 return EINVAL;
701
702 if (pinfo->psem_flags & PSEM_INDELETE)
703 return 0;
704
705 AUDIT_ARG(posix_ipc_perm, pinfo->psem_uid, pinfo->psem_gid,
706 pinfo->psem_mode);
707
708 pinfo->psem_flags |= PSEM_INDELETE;
709 pinfo->psem_usecount--;
710
711 if (!pinfo->psem_usecount) {
712 psem_delete(pinfo);
713 FREE(pinfo,M_SHM);
714 } else {
715 pinfo->psem_flags |= PSEM_REMOVED;
716 }
717
718 psem_cache_delete(pcache);
719 FREE(pcache, M_SHM);
720 return 0;
721 }
722
723
724 int
725 sem_unlink(__unused proc_t p, struct sem_unlink_args *uap, __unused int32_t *retval)
726 {
727 size_t i;
728 int error=0;
729 struct psemname nd;
730 struct pseminfo *pinfo;
731 char * nameptr;
732 char * cp;
733 char * pnbuf;
734 size_t pathlen;
735 struct psemcache *pcache = PSEMCACHE_NULL;
736
737 pinfo = PSEMINFO_NULL;
738
739 MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
740 if (pnbuf == NULL) {
741 return(ENOSPC); /* XXX non-standard */
742 }
743 pathlen = MAXPATHLEN;
744 error = copyinstr(uap->name, pnbuf, MAXPATHLEN, &pathlen);
745 if (error) {
746 goto bad;
747 }
748 AUDIT_ARG(text, pnbuf);
749 if (pathlen > PSEMNAMLEN) {
750 error = ENAMETOOLONG;
751 goto bad;
752 }
753
754 nameptr = pnbuf;
755
756 #ifdef PSXSEM_NAME_RESTRICT
757 if (*nameptr == '/') {
758 while (*(nameptr++) == '/') {
759 pathlen--;
760 error = EINVAL;
761 goto bad;
762 }
763 } else {
764 error = EINVAL;
765 goto bad;
766 }
767 #endif /* PSXSEM_NAME_RESTRICT */
768
769 nd.psem_nameptr = nameptr;
770 nd.psem_namelen = pathlen;
771 nd. psem_hash =0;
772
773 for (cp = nameptr, i=1; *cp != 0 && i <= pathlen; i++, cp++) {
774 nd.psem_hash += (unsigned char)*cp * i;
775 }
776
777 PSEM_SUBSYS_LOCK();
778 error = psem_cache_search(&pinfo, &nd, &pcache);
779
780 if (error != PSEMCACHE_FOUND) {
781 PSEM_SUBSYS_UNLOCK();
782 error = EINVAL;
783 goto bad;
784
785 }
786
787 #if CONFIG_MACF
788 error = mac_posixsem_check_unlink(kauth_cred_get(), pinfo, nameptr);
789 if (error) {
790 PSEM_SUBSYS_UNLOCK();
791 goto bad;
792 }
793 #endif
794 if ( (error = psem_access(pinfo, pinfo->psem_mode, kauth_cred_get())) ) {
795 PSEM_SUBSYS_UNLOCK();
796 goto bad;
797 }
798
799 error = psem_unlink_internal(pinfo, pcache);
800 PSEM_SUBSYS_UNLOCK();
801
802 bad:
803 FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI);
804 return error;
805 }
806
807 int
808 sem_close(proc_t p, struct sem_close_args *uap, __unused int32_t *retval)
809 {
810 int fd = CAST_DOWN_EXPLICIT(int,uap->sem);
811 struct fileproc *fp;
812 int error = 0;
813
814 AUDIT_ARG(fd, fd); /* XXX This seems wrong; uap->sem is a pointer */
815
816 proc_fdlock(p);
817 error = fp_lookup(p,fd, &fp, 1);
818 if (error) {
819 proc_fdunlock(p);
820 return(error);
821 }
822 procfdtbl_markclosefd(p, fd);
823 fileproc_drain(p, fp);
824 fdrelse(p, fd);
825 error = closef_locked(fp, fp->f_fglob, p);
826 fileproc_free(fp);
827 proc_fdunlock(p);
828 return(error);
829 }
830
831 int
832 sem_wait(proc_t p, struct sem_wait_args *uap, int32_t *retval)
833 {
834 __pthread_testcancel(1);
835 return(sem_wait_nocancel(p, (struct sem_wait_nocancel_args *)uap, retval));
836 }
837
838 int
839 sem_wait_nocancel(proc_t p, struct sem_wait_nocancel_args *uap, __unused int32_t *retval)
840 {
841 int fd = CAST_DOWN_EXPLICIT(int,uap->sem);
842 struct fileproc *fp;
843 struct pseminfo * pinfo;
844 struct psemnode * pnode ;
845 kern_return_t kret;
846 int error;
847
848 error = fp_getfpsem(p, fd, &fp, &pnode);
849 if (error)
850 return (error);
851 if (((pnode = (struct psemnode *)fp->f_data)) == PSEMNODE_NULL ) {
852 error = EINVAL;
853 goto out;
854 }
855 PSEM_SUBSYS_LOCK();
856 if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
857 PSEM_SUBSYS_UNLOCK();
858 error = EINVAL;
859 goto out;
860 }
861 if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))
862 != PSEM_ALLOCATED) {
863 PSEM_SUBSYS_UNLOCK();
864 error = EINVAL;
865 goto out;
866 }
867 #if CONFIG_MACF
868 error = mac_posixsem_check_wait(kauth_cred_get(), pinfo);
869 if (error) {
870 PSEM_SUBSYS_UNLOCK();
871 goto out;
872 }
873 #endif
874 PSEM_SUBSYS_UNLOCK();
875 kret = semaphore_wait(pinfo->psem_semobject);
876 switch (kret) {
877 case KERN_INVALID_ADDRESS:
878 case KERN_PROTECTION_FAILURE:
879 error = EACCES;
880 break;
881 case KERN_ABORTED:
882 case KERN_OPERATION_TIMED_OUT:
883 error = EINTR;
884 break;
885 case KERN_SUCCESS:
886 error = 0;
887 break;
888 default:
889 error = EINVAL;
890 break;
891 }
892 out:
893 fp_drop(p, fd, fp, 0);
894 return(error);
895
896 }
897
898 int
899 sem_trywait(proc_t p, struct sem_trywait_args *uap, __unused int32_t *retval)
900 {
901 int fd = CAST_DOWN_EXPLICIT(int,uap->sem);
902 struct fileproc *fp;
903 struct pseminfo * pinfo;
904 struct psemnode * pnode ;
905 kern_return_t kret;
906 mach_timespec_t wait_time;
907 int error;
908
909 error = fp_getfpsem(p, fd, &fp, &pnode);
910 if (error)
911 return (error);
912 if (((pnode = (struct psemnode *)fp->f_data)) == PSEMNODE_NULL ) {
913 error = EINVAL;
914 goto out;
915 }
916 PSEM_SUBSYS_LOCK();
917 if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
918 PSEM_SUBSYS_UNLOCK();
919 error = EINVAL;
920 goto out;
921 }
922 if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))
923 != PSEM_ALLOCATED) {
924 PSEM_SUBSYS_UNLOCK();
925 error = EINVAL;
926 goto out;
927 }
928 #if CONFIG_MACF
929 error = mac_posixsem_check_wait(kauth_cred_get(), pinfo);
930 if (error) {
931 PSEM_SUBSYS_UNLOCK();
932 goto out;
933 }
934 #endif
935 PSEM_SUBSYS_UNLOCK();
936 wait_time.tv_sec = 0;
937 wait_time.tv_nsec = 0;
938
939 kret = semaphore_timedwait(pinfo->psem_semobject, MACH_TIMESPEC_ZERO);
940 switch (kret) {
941 case KERN_INVALID_ADDRESS:
942 case KERN_PROTECTION_FAILURE:
943 error = EINVAL;
944 break;
945 case KERN_ABORTED:
946 error = EINTR;
947 break;
948 case KERN_OPERATION_TIMED_OUT:
949 error = EAGAIN;
950 break;
951 case KERN_SUCCESS:
952 error = 0;
953 break;
954 default:
955 error = EINVAL;
956 break;
957 }
958 out:
959 fp_drop(p, fd, fp, 0);
960 return(error);
961 }
962
963 int
964 sem_post(proc_t p, struct sem_post_args *uap, __unused int32_t *retval)
965 {
966 int fd = CAST_DOWN_EXPLICIT(int,uap->sem);
967 struct fileproc *fp;
968 struct pseminfo * pinfo;
969 struct psemnode * pnode ;
970 kern_return_t kret;
971 int error;
972
973 error = fp_getfpsem(p, fd, &fp, &pnode);
974 if (error)
975 return (error);
976 if (((pnode = (struct psemnode *)fp->f_data)) == PSEMNODE_NULL ) {
977 error = EINVAL;
978 goto out;
979 }
980 PSEM_SUBSYS_LOCK();
981 if ((pinfo = pnode->pinfo) == PSEMINFO_NULL) {
982 PSEM_SUBSYS_UNLOCK();
983 error = EINVAL;
984 goto out;
985 }
986 if ((pinfo->psem_flags & (PSEM_DEFINED | PSEM_ALLOCATED))
987 != PSEM_ALLOCATED) {
988 PSEM_SUBSYS_UNLOCK();
989 error = EINVAL;
990 goto out;
991 }
992 #if CONFIG_MACF
993 error = mac_posixsem_check_post(kauth_cred_get(), pinfo);
994 if (error) {
995 PSEM_SUBSYS_UNLOCK();
996 goto out;
997 }
998 #endif
999 PSEM_SUBSYS_UNLOCK();
1000 kret = semaphore_signal(pinfo->psem_semobject);
1001 switch (kret) {
1002 case KERN_INVALID_ADDRESS:
1003 case KERN_PROTECTION_FAILURE:
1004 error = EINVAL;
1005 break;
1006 case KERN_ABORTED:
1007 case KERN_OPERATION_TIMED_OUT:
1008 error = EINTR;
1009 break;
1010 case KERN_SUCCESS:
1011 error = 0;
1012 break;
1013 default:
1014 error = EINVAL;
1015 break;
1016 }
1017 out:
1018 fp_drop(p, fd, fp, 0);
1019 return(error);
1020 }
1021
1022 static int
1023 psem_close(struct psemnode *pnode, __unused int flags)
1024 {
1025 int error=0;
1026 struct pseminfo *pinfo;
1027
1028 PSEM_SUBSYS_LOCK();
1029 if ((pinfo = pnode->pinfo) == PSEMINFO_NULL){
1030 PSEM_SUBSYS_UNLOCK();
1031 return(EINVAL);
1032 }
1033
1034 if ((pinfo->psem_flags & PSEM_ALLOCATED) != PSEM_ALLOCATED) {
1035 PSEM_SUBSYS_UNLOCK();
1036 return(EINVAL);
1037 }
1038 #if DIAGNOSTIC
1039 if(!pinfo->psem_usecount) {
1040 kprintf("negative usecount in psem_close\n");
1041 }
1042 #endif /* DIAGNOSTIC */
1043 pinfo->psem_usecount--;
1044
1045 if ((pinfo->psem_flags & PSEM_REMOVED) && !pinfo->psem_usecount) {
1046 PSEM_SUBSYS_UNLOCK();
1047 /* lock dropped as only semaphore is destroyed here */
1048 error = psem_delete(pinfo);
1049 FREE(pinfo,M_SHM);
1050 } else {
1051 PSEM_SUBSYS_UNLOCK();
1052 }
1053 /* subsystem lock is dropped when we get here */
1054 FREE(pnode, M_SHM);
1055 return (error);
1056 }
1057
1058 static int
1059 psem_closefile(struct fileglob *fg, __unused vfs_context_t ctx)
1060 {
1061 int error;
1062
1063 /*
1064 * Not locked as psem_close is called only from here and is locked
1065 * properly
1066 */
1067 error = psem_close(((struct psemnode *)fg->fg_data), fg->fg_flag);
1068
1069 return(error);
1070 }
1071
1072 static int
1073 psem_delete(struct pseminfo * pinfo)
1074 {
1075 kern_return_t kret;
1076
1077 kret = semaphore_destroy(kernel_task, pinfo->psem_semobject);
1078 #if CONFIG_MACF
1079 mac_posixsem_label_destroy(pinfo);
1080 #endif
1081
1082 switch (kret) {
1083 case KERN_INVALID_ADDRESS:
1084 case KERN_PROTECTION_FAILURE:
1085 return (EINVAL);
1086 case KERN_ABORTED:
1087 case KERN_OPERATION_TIMED_OUT:
1088 return (EINTR);
1089 case KERN_SUCCESS:
1090 return(0);
1091 default:
1092 return (EINVAL);
1093 }
1094 }
1095
1096 static int
1097 psem_read(__unused struct fileproc *fp, __unused struct uio *uio,
1098 __unused int flags, __unused vfs_context_t ctx)
1099 {
1100 return(ENOTSUP);
1101 }
1102
1103 static int
1104 psem_write(__unused struct fileproc *fp, __unused struct uio *uio,
1105 __unused int flags, __unused vfs_context_t ctx)
1106 {
1107 return(ENOTSUP);
1108 }
1109
1110 static int
1111 psem_ioctl(__unused struct fileproc *fp, __unused u_long com,
1112 __unused caddr_t data, __unused vfs_context_t ctx)
1113 {
1114 return(ENOTSUP);
1115 }
1116
1117 static int
1118 psem_select(__unused struct fileproc *fp, __unused int which,
1119 __unused void *wql, __unused vfs_context_t ctx)
1120 {
1121 return(ENOTSUP);
1122 }
1123
1124 static int
1125 psem_kqfilter(__unused struct fileproc *fp, struct knote *kn,
1126 __unused struct kevent_internal_s *kev, __unused vfs_context_t ctx)
1127 {
1128 kn->kn_flags = EV_ERROR;
1129 kn->kn_data = ENOTSUP;
1130 return 0;
1131 }
1132
1133 int
1134 fill_pseminfo(struct psemnode *pnode, struct psem_info * info)
1135 {
1136 struct pseminfo *pinfo;
1137 struct vinfo_stat *sb;
1138
1139 PSEM_SUBSYS_LOCK();
1140 if ((pinfo = pnode->pinfo) == PSEMINFO_NULL){
1141 PSEM_SUBSYS_UNLOCK();
1142 return(EINVAL);
1143 }
1144
1145 #if 0
1146 if ((pinfo->psem_flags & PSEM_ALLOCATED) != PSEM_ALLOCATED) {
1147 PSEM_SUBSYS_UNLOCK();
1148 return(EINVAL);
1149 }
1150 #endif
1151
1152 sb = &info->psem_stat;
1153 bzero(sb, sizeof(struct vinfo_stat));
1154
1155 sb->vst_mode = pinfo->psem_mode;
1156 sb->vst_uid = pinfo->psem_uid;
1157 sb->vst_gid = pinfo->psem_gid;
1158 sb->vst_size = pinfo->psem_usecount;
1159 bcopy(&pinfo->psem_name[0], &info->psem_name[0], PSEMNAMLEN+1);
1160
1161 PSEM_SUBSYS_UNLOCK();
1162 return(0);
1163 }
1164
1165 #if CONFIG_MACF
1166 void
1167 psem_label_associate(struct fileproc *fp, struct vnode *vp, vfs_context_t ctx)
1168 {
1169 struct psemnode *pnode;
1170 struct pseminfo *psem;
1171
1172 PSEM_SUBSYS_LOCK();
1173 pnode = (struct psemnode *)fp->f_fglob->fg_data;
1174 if (pnode != NULL) {
1175 psem = pnode->pinfo;
1176 if (psem != NULL)
1177 mac_posixsem_vnode_label_associate(
1178 vfs_context_ucred(ctx), psem, psem->psem_label,
1179 vp, vp->v_label);
1180 }
1181 PSEM_SUBSYS_UNLOCK();
1182 }
1183 #endif
1184
mirror of XNU