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 | |
1185 | |