]>
Commit | Line | Data |
---|---|---|
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_shm.c : Support for POSIX shared memory APIs | |
34 | * | |
35 | * File: posix_shm.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/vnode_internal.h> | |
63 | #include <sys/ioctl.h> | |
64 | #include <sys/tty.h> | |
65 | #include <sys/malloc.h> | |
66 | #include <sys/mman.h> | |
67 | #include <sys/stat.h> | |
68 | #include <sys/sysproto.h> | |
69 | #include <sys/proc_info.h> | |
70 | #include <security/audit/audit.h> | |
71 | ||
72 | #if CONFIG_MACF | |
73 | #include <security/mac_framework.h> | |
74 | #endif | |
75 | ||
76 | #include <mach/mach_types.h> | |
77 | #include <mach/mach_vm.h> | |
78 | #include <mach/vm_map.h> | |
79 | #include <mach/vm_prot.h> | |
80 | #include <mach/vm_inherit.h> | |
81 | #include <mach/kern_return.h> | |
82 | #include <mach/memory_object_control.h> | |
83 | ||
84 | #include <vm/vm_map.h> | |
85 | #include <vm/vm_protos.h> | |
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 PSHMNAMLEN 31 /* maximum name segment length we bother with */ | |
95 | ||
96 | struct pshmobj { | |
97 | void * pshmo_memobject; | |
98 | memory_object_size_t pshmo_size; | |
99 | struct pshmobj * pshmo_next; | |
100 | }; | |
101 | ||
102 | struct pshminfo { | |
103 | unsigned int pshm_flags; | |
104 | unsigned int pshm_usecount; | |
105 | off_t pshm_length; | |
106 | mode_t pshm_mode; | |
107 | uid_t pshm_uid; | |
108 | gid_t pshm_gid; | |
109 | char pshm_name[PSHMNAMLEN + 1]; /* segment name */ | |
110 | struct pshmobj *pshm_memobjects; | |
111 | #if DIAGNOSTIC | |
112 | unsigned int pshm_readcount; | |
113 | unsigned int pshm_writecount; | |
114 | proc_t pshm_proc; | |
115 | #endif /* DIAGNOSTIC */ | |
116 | struct label* pshm_label; | |
117 | }; | |
118 | #define PSHMINFO_NULL (struct pshminfo *)0 | |
119 | ||
120 | #define PSHM_NONE 0x001 | |
121 | #define PSHM_DEFINED 0x002 | |
122 | #define PSHM_ALLOCATED 0x004 | |
123 | #define PSHM_MAPPED 0x008 | |
124 | #define PSHM_INUSE 0x010 | |
125 | #define PSHM_REMOVED 0x020 | |
126 | #define PSHM_INCREATE 0x040 | |
127 | #define PSHM_INDELETE 0x080 | |
128 | #define PSHM_ALLOCATING 0x100 | |
129 | ||
130 | struct pshmcache { | |
131 | LIST_ENTRY(pshmcache) pshm_hash; /* hash chain */ | |
132 | struct pshminfo *pshminfo; /* vnode the name refers to */ | |
133 | int pshm_nlen; /* length of name */ | |
134 | char pshm_name[PSHMNAMLEN + 1]; /* segment name */ | |
135 | }; | |
136 | #define PSHMCACHE_NULL (struct pshmcache *)0 | |
137 | ||
138 | #define PSHMCACHE_NOTFOUND (0) | |
139 | #define PSHMCACHE_FOUND (-1) | |
140 | #define PSHMCACHE_NEGATIVE (ENOENT) | |
141 | ||
142 | struct pshmstats { | |
143 | long goodhits; /* hits that we can really use */ | |
144 | long neghits; /* negative hits that we can use */ | |
145 | long badhits; /* hits we must drop */ | |
146 | long falsehits; /* hits with id mismatch */ | |
147 | long miss; /* misses */ | |
148 | long longnames; /* long names that ignore cache */ | |
149 | }; | |
150 | ||
151 | struct pshmname { | |
152 | char *pshm_nameptr; /* pointer to looked up name */ | |
153 | long pshm_namelen; /* length of looked up component */ | |
154 | u_long pshm_hash; /* hash value of looked up name */ | |
155 | }; | |
156 | ||
157 | struct pshmnode { | |
158 | off_t mapp_addr; | |
159 | user_size_t map_size; /* XXX unused ? */ | |
160 | struct pshminfo *pinfo; | |
161 | unsigned int pshm_usecount; | |
162 | #if DIAGNOSTIC | |
163 | unsigned int readcnt; | |
164 | unsigned int writecnt; | |
165 | #endif | |
166 | }; | |
167 | #define PSHMNODE_NULL (struct pshmnode *)0 | |
168 | ||
169 | ||
170 | #define PSHMHASH(pnp) \ | |
171 | (&pshmhashtbl[(pnp)->pshm_hash & pshmhash]) | |
172 | ||
173 | LIST_HEAD(pshmhashhead, pshmcache) *pshmhashtbl; /* Hash Table */ | |
174 | u_long pshmhash; /* size of hash table - 1 */ | |
175 | long pshmnument; /* number of cache entries allocated */ | |
176 | struct pshmstats pshmstats; /* cache effectiveness statistics */ | |
177 | ||
178 | static int pshm_read (struct fileproc *fp, struct uio *uio, | |
179 | int flags, vfs_context_t ctx); | |
180 | static int pshm_write (struct fileproc *fp, struct uio *uio, | |
181 | int flags, vfs_context_t ctx); | |
182 | static int pshm_ioctl (struct fileproc *fp, u_long com, | |
183 | caddr_t data, vfs_context_t ctx); | |
184 | static int pshm_select (struct fileproc *fp, int which, void *wql, vfs_context_t ctx); | |
185 | static int pshm_close(struct pshminfo *pinfo, int dropref); | |
186 | static int pshm_closefile (struct fileglob *fg, vfs_context_t ctx); | |
187 | ||
188 | static int pshm_kqfilter(struct fileproc *fp, struct knote *kn, | |
189 | struct kevent_internal_s *kev, vfs_context_t ctx); | |
190 | ||
191 | int pshm_access(struct pshminfo *pinfo, int mode, kauth_cred_t cred, proc_t p); | |
192 | int pshm_cache_purge_all(proc_t p); | |
193 | ||
194 | static int pshm_cache_add(struct pshminfo *pshmp, struct pshmname *pnp, struct pshmcache *pcp); | |
195 | static void pshm_cache_delete(struct pshmcache *pcp); | |
196 | static int pshm_cache_search(struct pshminfo **pshmp, struct pshmname *pnp, | |
197 | struct pshmcache **pcache, int addref); | |
198 | static int pshm_unlink_internal(struct pshminfo *pinfo, struct pshmcache *pcache); | |
199 | ||
200 | static const struct fileops pshmops = { | |
201 | .fo_type = DTYPE_PSXSHM, | |
202 | .fo_read = pshm_read, | |
203 | .fo_write = pshm_write, | |
204 | .fo_ioctl = pshm_ioctl, | |
205 | .fo_select = pshm_select, | |
206 | .fo_close = pshm_closefile, | |
207 | .fo_kqfilter = pshm_kqfilter, | |
208 | .fo_drain = NULL, | |
209 | }; | |
210 | ||
211 | static lck_grp_t *psx_shm_subsys_lck_grp; | |
212 | static lck_grp_attr_t *psx_shm_subsys_lck_grp_attr; | |
213 | static lck_attr_t *psx_shm_subsys_lck_attr; | |
214 | static lck_mtx_t psx_shm_subsys_mutex; | |
215 | ||
216 | #define PSHM_SUBSYS_LOCK() lck_mtx_lock(& psx_shm_subsys_mutex) | |
217 | #define PSHM_SUBSYS_UNLOCK() lck_mtx_unlock(& psx_shm_subsys_mutex) | |
218 | #define PSHM_SUBSYS_ASSERT_HELD() LCK_MTX_ASSERT(&psx_shm_subsys_mutex, LCK_MTX_ASSERT_OWNED) | |
219 | ||
220 | ||
221 | /* Initialize the mutex governing access to the posix shm subsystem */ | |
222 | __private_extern__ void | |
223 | pshm_lock_init( void ) | |
224 | { | |
225 | ||
226 | psx_shm_subsys_lck_grp_attr = lck_grp_attr_alloc_init(); | |
227 | ||
228 | psx_shm_subsys_lck_grp = lck_grp_alloc_init("posix shared memory", psx_shm_subsys_lck_grp_attr); | |
229 | ||
230 | psx_shm_subsys_lck_attr = lck_attr_alloc_init(); | |
231 | lck_mtx_init(& psx_shm_subsys_mutex, psx_shm_subsys_lck_grp, psx_shm_subsys_lck_attr); | |
232 | } | |
233 | ||
234 | /* | |
235 | * Lookup an entry in the cache | |
236 | * | |
237 | * | |
238 | * status of -1 is returned if matches | |
239 | * If the lookup determines that the name does not exist | |
240 | * (negative cacheing), a status of ENOENT is returned. If the lookup | |
241 | * fails, a status of zero is returned. | |
242 | */ | |
243 | ||
244 | static int | |
245 | pshm_cache_search(struct pshminfo **pshmp, struct pshmname *pnp, | |
246 | struct pshmcache **pcache, int addref) | |
247 | { | |
248 | struct pshmcache *pcp, *nnp; | |
249 | struct pshmhashhead *pcpp; | |
250 | ||
251 | if (pnp->pshm_namelen > PSHMNAMLEN) { | |
252 | pshmstats.longnames++; | |
253 | return PSHMCACHE_NOTFOUND; | |
254 | } | |
255 | ||
256 | pcpp = PSHMHASH(pnp); | |
257 | for (pcp = pcpp->lh_first; pcp != 0; pcp = nnp) { | |
258 | nnp = pcp->pshm_hash.le_next; | |
259 | if (pcp->pshm_nlen == pnp->pshm_namelen && | |
260 | !bcmp(pcp->pshm_name, pnp->pshm_nameptr, (u_int)pcp-> pshm_nlen)) | |
261 | break; | |
262 | } | |
263 | ||
264 | if (pcp == 0) { | |
265 | pshmstats.miss++; | |
266 | return PSHMCACHE_NOTFOUND; | |
267 | } | |
268 | ||
269 | /* We found a "positive" match, return the vnode */ | |
270 | if (pcp->pshminfo) { | |
271 | pshmstats.goodhits++; | |
272 | /* TOUCH(ncp); */ | |
273 | *pshmp = pcp->pshminfo; | |
274 | *pcache = pcp; | |
275 | if (addref) | |
276 | pcp->pshminfo->pshm_usecount++; | |
277 | return PSHMCACHE_FOUND; | |
278 | } | |
279 | ||
280 | /* | |
281 | * We found a "negative" match, ENOENT notifies client of this match. | |
282 | */ | |
283 | pshmstats.neghits++; | |
284 | return PSHMCACHE_NEGATIVE; | |
285 | } | |
286 | ||
287 | /* | |
288 | * Add an entry to the cache. | |
289 | * XXX should be static? | |
290 | */ | |
291 | static int | |
292 | pshm_cache_add(struct pshminfo *pshmp, struct pshmname *pnp, struct pshmcache *pcp) | |
293 | { | |
294 | struct pshmhashhead *pcpp; | |
295 | struct pshminfo *dpinfo; | |
296 | struct pshmcache *dpcp; | |
297 | ||
298 | #if DIAGNOSTIC | |
299 | if (pnp->pshm_namelen > PSHMNAMLEN) | |
300 | panic("cache_enter: name too long"); | |
301 | #endif | |
302 | ||
303 | ||
304 | /* if the entry has already been added by some one else return */ | |
305 | if (pshm_cache_search(&dpinfo, pnp, &dpcp, 0) == PSHMCACHE_FOUND) { | |
306 | return EEXIST; | |
307 | } | |
308 | pshmnument++; | |
309 | ||
310 | /* | |
311 | * Fill in cache info, if vp is NULL this is a "negative" cache entry. | |
312 | */ | |
313 | pcp->pshminfo = pshmp; | |
314 | pcp->pshm_nlen = pnp->pshm_namelen; | |
315 | bcopy(pnp->pshm_nameptr, pcp->pshm_name, (unsigned)pcp->pshm_nlen); | |
316 | pcpp = PSHMHASH(pnp); | |
317 | #if DIAGNOSTIC | |
318 | { | |
319 | struct pshmcache *p; | |
320 | ||
321 | for (p = pcpp->lh_first; p != 0; p = p->pshm_hash.le_next) | |
322 | if (p == pcp) | |
323 | panic("cache_enter: duplicate"); | |
324 | } | |
325 | #endif | |
326 | LIST_INSERT_HEAD(pcpp, pcp, pshm_hash); | |
327 | return 0; | |
328 | } | |
329 | ||
330 | /* | |
331 | * Name cache initialization, from vfs_init() when we are booting | |
332 | */ | |
333 | void | |
334 | pshm_cache_init(void) | |
335 | { | |
336 | pshmhashtbl = hashinit(desiredvnodes / 8, M_SHM, &pshmhash); | |
337 | } | |
338 | ||
339 | /* | |
340 | * Invalidate all entries and delete all objects associated with it. Entire | |
341 | * non Kernel entries are going away. Just dump'em all | |
342 | * | |
343 | * We actually just increment the v_id, that will do it. The entries will | |
344 | * be purged by lookup as they get found. If the v_id wraps around, we | |
345 | * need to ditch the entire cache, to avoid confusion. No valid vnode will | |
346 | * ever have (v_id == 0). | |
347 | */ | |
348 | int | |
349 | pshm_cache_purge_all(__unused proc_t p) | |
350 | { | |
351 | struct pshmcache *pcp, *tmppcp; | |
352 | struct pshmhashhead *pcpp; | |
353 | int error = 0; | |
354 | ||
355 | if (kauth_cred_issuser(kauth_cred_get()) == 0) | |
356 | return EPERM; | |
357 | ||
358 | PSHM_SUBSYS_LOCK(); | |
359 | for (pcpp = &pshmhashtbl[pshmhash]; pcpp >= pshmhashtbl; pcpp--) { | |
360 | LIST_FOREACH_SAFE(pcp, pcpp, pshm_hash, tmppcp) { | |
361 | assert(pcp->pshm_nlen); | |
362 | error = pshm_unlink_internal(pcp->pshminfo, pcp); | |
363 | if (error) | |
364 | goto out; | |
365 | } | |
366 | } | |
367 | assert(pshmnument == 0); | |
368 | ||
369 | out: | |
370 | PSHM_SUBSYS_UNLOCK(); | |
371 | ||
372 | if (error) | |
373 | printf("%s: Error %d removing shm cache: %ld remain!\n", | |
374 | __func__, error, pshmnument); | |
375 | return error; | |
376 | } | |
377 | ||
378 | static void | |
379 | pshm_cache_delete(struct pshmcache *pcp) | |
380 | { | |
381 | #if DIAGNOSTIC | |
382 | if (pcp->pshm_hash.le_prev == 0) | |
383 | panic("namecache purge le_prev"); | |
384 | if (pcp->pshm_hash.le_next == pcp) | |
385 | panic("namecache purge le_next"); | |
386 | #endif /* DIAGNOSTIC */ | |
387 | LIST_REMOVE(pcp, pshm_hash); | |
388 | pcp->pshm_hash.le_prev = 0; | |
389 | pshmnument--; | |
390 | } | |
391 | ||
392 | ||
393 | int | |
394 | shm_open(proc_t p, struct shm_open_args *uap, int32_t *retval) | |
395 | { | |
396 | size_t i; | |
397 | int indx, error; | |
398 | struct pshmname nd; | |
399 | struct pshminfo *pinfo; | |
400 | struct fileproc *fp = NULL; | |
401 | char *pnbuf = NULL; | |
402 | struct pshminfo *new_pinfo = PSHMINFO_NULL; | |
403 | struct pshmnode *new_pnode = PSHMNODE_NULL; | |
404 | struct pshmcache *pcache = PSHMCACHE_NULL; /* ignored on return */ | |
405 | char * nameptr; | |
406 | char * cp; | |
407 | size_t pathlen, plen; | |
408 | int fmode ; | |
409 | int cmode = uap->mode; | |
410 | int incache = 0; | |
411 | struct pshmcache *pcp = NULL; | |
412 | ||
413 | AUDIT_ARG(fflags, uap->oflag); | |
414 | AUDIT_ARG(mode, uap->mode); | |
415 | ||
416 | pinfo = PSHMINFO_NULL; | |
417 | ||
418 | /* | |
419 | * Preallocate everything we might need up front to avoid taking | |
420 | * and dropping the lock, opening us up to race conditions. | |
421 | */ | |
422 | MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK); | |
423 | if (pnbuf == NULL) { | |
424 | error = ENOSPC; | |
425 | goto bad; | |
426 | } | |
427 | ||
428 | pathlen = MAXPATHLEN; | |
429 | error = copyinstr(uap->name, (void *)pnbuf, MAXPATHLEN, &pathlen); | |
430 | if (error) { | |
431 | goto bad; | |
432 | } | |
433 | AUDIT_ARG(text, pnbuf); | |
434 | if (pathlen > PSHMNAMLEN) { | |
435 | error = ENAMETOOLONG; | |
436 | goto bad; | |
437 | } | |
438 | #ifdef PSXSHM_NAME_RESTRICT | |
439 | nameptr = pnbuf; | |
440 | if (*nameptr == '/') { | |
441 | while (*(nameptr++) == '/') { | |
442 | plen--; | |
443 | error = EINVAL; | |
444 | goto bad; | |
445 | } | |
446 | } else { | |
447 | error = EINVAL; | |
448 | goto bad; | |
449 | } | |
450 | #endif /* PSXSHM_NAME_RESTRICT */ | |
451 | ||
452 | plen = pathlen; | |
453 | nameptr = pnbuf; | |
454 | nd.pshm_nameptr = nameptr; | |
455 | nd.pshm_namelen = plen; | |
456 | nd. pshm_hash =0; | |
457 | ||
458 | for (cp = nameptr, i=1; *cp != 0 && i <= plen; i++, cp++) { | |
459 | nd.pshm_hash += (unsigned char)*cp * i; | |
460 | } | |
461 | ||
462 | /* | |
463 | * attempt to allocate a new fp; if unsuccessful, the fp will be | |
464 | * left unmodified (NULL). | |
465 | */ | |
466 | error = falloc(p, &fp, &indx, vfs_context_current()); | |
467 | if (error) | |
468 | goto bad; | |
469 | ||
470 | cmode &= ALLPERMS; | |
471 | ||
472 | fmode = FFLAGS(uap->oflag); | |
473 | if ((fmode & (FREAD | FWRITE)) == 0) { | |
474 | error = EINVAL; | |
475 | goto bad; | |
476 | } | |
477 | ||
478 | /* | |
479 | * We allocate a new entry if we are less than the maximum | |
480 | * allowed and the one at the front of the LRU list is in use. | |
481 | * Otherwise we use the one at the front of the LRU list. | |
482 | */ | |
483 | MALLOC(pcp, struct pshmcache *, sizeof(struct pshmcache), M_SHM, M_WAITOK|M_ZERO); | |
484 | if (pcp == NULL) { | |
485 | error = ENOSPC; | |
486 | goto bad; | |
487 | } | |
488 | ||
489 | MALLOC(new_pinfo, struct pshminfo *, sizeof(struct pshminfo), M_SHM, M_WAITOK|M_ZERO); | |
490 | if (new_pinfo == PSHMINFO_NULL) { | |
491 | error = ENOSPC; | |
492 | goto bad; | |
493 | } | |
494 | #if CONFIG_MACF | |
495 | mac_posixshm_label_init(new_pinfo); | |
496 | #endif | |
497 | ||
498 | MALLOC(new_pnode, struct pshmnode *, sizeof(struct pshmnode), M_SHM, M_WAITOK|M_ZERO); | |
499 | if (new_pnode == PSHMNODE_NULL) { | |
500 | error = ENOSPC; | |
501 | goto bad; | |
502 | } | |
503 | ||
504 | PSHM_SUBSYS_LOCK(); | |
505 | ||
506 | /* | |
507 | * If we find the entry in the cache, this will take a reference, | |
508 | * allowing us to unlock it for the permissions check. | |
509 | */ | |
510 | error = pshm_cache_search(&pinfo, &nd, &pcache, 1); | |
511 | ||
512 | PSHM_SUBSYS_UNLOCK(); | |
513 | ||
514 | if (error == PSHMCACHE_NEGATIVE) { | |
515 | error = EINVAL; | |
516 | goto bad; | |
517 | } | |
518 | ||
519 | if (error == PSHMCACHE_NOTFOUND) { | |
520 | incache = 0; | |
521 | if (fmode & O_CREAT) { | |
522 | /* create a new one (commit the allocation) */ | |
523 | pinfo = new_pinfo; | |
524 | pinfo->pshm_flags = PSHM_DEFINED | PSHM_INCREATE; | |
525 | pinfo->pshm_usecount = 1; /* existence reference */ | |
526 | pinfo->pshm_mode = cmode; | |
527 | pinfo->pshm_uid = kauth_getuid(); | |
528 | pinfo->pshm_gid = kauth_getgid(); | |
529 | bcopy(pnbuf, &pinfo->pshm_name[0], pathlen); | |
530 | pinfo->pshm_name[pathlen]=0; | |
531 | #if CONFIG_MACF | |
532 | error = mac_posixshm_check_create(kauth_cred_get(), nameptr); | |
533 | if (error) { | |
534 | goto bad; | |
535 | } | |
536 | mac_posixshm_label_associate(kauth_cred_get(), pinfo, nameptr); | |
537 | #endif | |
538 | } | |
539 | } else { | |
540 | incache = 1; | |
541 | if (fmode & O_CREAT) { | |
542 | /* already exists */ | |
543 | if ((fmode & O_EXCL)) { | |
544 | AUDIT_ARG(posix_ipc_perm, pinfo->pshm_uid, | |
545 | pinfo->pshm_gid, | |
546 | pinfo->pshm_mode); | |
547 | ||
548 | /* shm obj exists and opened O_EXCL */ | |
549 | error = EEXIST; | |
550 | goto bad; | |
551 | } | |
552 | ||
553 | if( pinfo->pshm_flags & PSHM_INDELETE) { | |
554 | error = ENOENT; | |
555 | goto bad; | |
556 | } | |
557 | AUDIT_ARG(posix_ipc_perm, pinfo->pshm_uid, | |
558 | pinfo->pshm_gid, pinfo->pshm_mode); | |
559 | #if CONFIG_MACF | |
560 | if ((error = mac_posixshm_check_open(kauth_cred_get(), pinfo, fmode))) { | |
561 | goto bad; | |
562 | } | |
563 | #endif | |
564 | if ( (error = pshm_access(pinfo, fmode, kauth_cred_get(), p)) ) { | |
565 | goto bad; | |
566 | } | |
567 | } | |
568 | } | |
569 | if (!(fmode & O_CREAT)) { | |
570 | if (!incache) { | |
571 | /* O_CREAT is not set and the object does not exist */ | |
572 | error = ENOENT; | |
573 | goto bad; | |
574 | } | |
575 | if( pinfo->pshm_flags & PSHM_INDELETE) { | |
576 | error = ENOENT; | |
577 | goto bad; | |
578 | } | |
579 | #if CONFIG_MACF | |
580 | if ((error = mac_posixshm_check_open(kauth_cred_get(), pinfo, fmode))) { | |
581 | goto bad; | |
582 | } | |
583 | #endif | |
584 | ||
585 | if ((error = pshm_access(pinfo, fmode, kauth_cred_get(), p))) { | |
586 | goto bad; | |
587 | } | |
588 | } | |
589 | if (fmode & O_TRUNC) { | |
590 | error = EINVAL; | |
591 | goto bad; | |
592 | } | |
593 | ||
594 | ||
595 | PSHM_SUBSYS_LOCK(); | |
596 | ||
597 | #if DIAGNOSTIC | |
598 | if (fmode & FWRITE) | |
599 | pinfo->pshm_writecount++; | |
600 | if (fmode & FREAD) | |
601 | pinfo->pshm_readcount++; | |
602 | #endif | |
603 | if (!incache) { | |
604 | /* if successful, this will consume the pcp */ | |
605 | if ( (error = pshm_cache_add(pinfo, &nd, pcp)) ) { | |
606 | goto bad_locked; | |
607 | } | |
608 | /* | |
609 | * add reference for the new entry; otherwise, we obtained | |
610 | * one from the cache hit earlier. | |
611 | */ | |
612 | pinfo->pshm_usecount++; | |
613 | } | |
614 | pinfo->pshm_flags &= ~PSHM_INCREATE; | |
615 | new_pnode->pinfo = pinfo; | |
616 | ||
617 | PSHM_SUBSYS_UNLOCK(); | |
618 | ||
619 | /* | |
620 | * if incache, we did not use the new pcp or new_pinfo and must | |
621 | * free them | |
622 | */ | |
623 | if (incache) { | |
624 | FREE(pcp, M_SHM); | |
625 | ||
626 | if (new_pinfo != PSHMINFO_NULL) { | |
627 | #if CONFIG_MACF | |
628 | mac_posixshm_label_destroy(new_pinfo); | |
629 | #endif | |
630 | FREE(new_pinfo, M_SHM); | |
631 | } | |
632 | } | |
633 | ||
634 | proc_fdlock(p); | |
635 | fp->f_flag = fmode & FMASK; | |
636 | fp->f_ops = &pshmops; | |
637 | fp->f_data = (caddr_t)new_pnode; | |
638 | *fdflags(p, indx) |= UF_EXCLOSE; | |
639 | procfdtbl_releasefd(p, indx, NULL); | |
640 | fp_drop(p, indx, fp, 1); | |
641 | proc_fdunlock(p); | |
642 | ||
643 | *retval = indx; | |
644 | FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI); | |
645 | return (0); | |
646 | ||
647 | bad_locked: | |
648 | PSHM_SUBSYS_UNLOCK(); | |
649 | bad: | |
650 | /* | |
651 | * If we obtained the entry from the cache, we need to drop the | |
652 | * reference; holding the reference may have prevented unlinking, | |
653 | * so we need to call pshm_close() to get the full effect. | |
654 | */ | |
655 | if (incache) { | |
656 | PSHM_SUBSYS_LOCK(); | |
657 | pshm_close(pinfo, 1); | |
658 | PSHM_SUBSYS_UNLOCK(); | |
659 | } | |
660 | ||
661 | if (pcp != NULL) | |
662 | FREE(pcp, M_SHM); | |
663 | ||
664 | if (new_pnode != PSHMNODE_NULL) | |
665 | FREE(new_pnode, M_SHM); | |
666 | ||
667 | if (fp != NULL) | |
668 | fp_free(p, indx, fp); | |
669 | ||
670 | if (new_pinfo != PSHMINFO_NULL) { | |
671 | #if CONFIG_MACF | |
672 | mac_posixshm_label_destroy(new_pinfo); | |
673 | #endif | |
674 | FREE(new_pinfo, M_SHM); | |
675 | } | |
676 | if (pnbuf != NULL) | |
677 | FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI); | |
678 | return (error); | |
679 | } | |
680 | ||
681 | ||
682 | int | |
683 | pshm_truncate(__unused proc_t p, struct fileproc *fp, __unused int fd, | |
684 | off_t length, __unused int32_t *retval) | |
685 | { | |
686 | struct pshminfo * pinfo; | |
687 | struct pshmnode * pnode ; | |
688 | kern_return_t kret; | |
689 | mem_entry_name_port_t mem_object; | |
690 | mach_vm_size_t total_size, alloc_size; | |
691 | memory_object_size_t mosize; | |
692 | struct pshmobj *pshmobj, *pshmobj_next, **pshmobj_next_p; | |
693 | vm_map_t user_map; | |
694 | #if CONFIG_MACF | |
695 | int error; | |
696 | #endif | |
697 | ||
698 | user_map = current_map(); | |
699 | ||
700 | if (fp->f_type != DTYPE_PSXSHM) { | |
701 | return(EINVAL); | |
702 | } | |
703 | ||
704 | ||
705 | if (((pnode = (struct pshmnode *)fp->f_data)) == PSHMNODE_NULL ) | |
706 | return(EINVAL); | |
707 | ||
708 | PSHM_SUBSYS_LOCK(); | |
709 | if ((pinfo = pnode->pinfo) == PSHMINFO_NULL) { | |
710 | PSHM_SUBSYS_UNLOCK(); | |
711 | return(EINVAL); | |
712 | } | |
713 | if ((pinfo->pshm_flags & (PSHM_DEFINED|PSHM_ALLOCATING|PSHM_ALLOCATED)) | |
714 | != PSHM_DEFINED) { | |
715 | PSHM_SUBSYS_UNLOCK(); | |
716 | return(EINVAL); | |
717 | } | |
718 | #if CONFIG_MACF | |
719 | error = mac_posixshm_check_truncate(kauth_cred_get(), pinfo, length); | |
720 | if (error) { | |
721 | PSHM_SUBSYS_UNLOCK(); | |
722 | return(error); | |
723 | } | |
724 | #endif | |
725 | ||
726 | pinfo->pshm_flags |= PSHM_ALLOCATING; | |
727 | total_size = vm_map_round_page(length, | |
728 | vm_map_page_mask(user_map)); | |
729 | pshmobj_next_p = &pinfo->pshm_memobjects; | |
730 | ||
731 | for (alloc_size = 0; | |
732 | alloc_size < total_size; | |
733 | alloc_size += mosize) { | |
734 | ||
735 | PSHM_SUBSYS_UNLOCK(); | |
736 | ||
737 | mosize = MIN(total_size - alloc_size, ANON_MAX_SIZE); | |
738 | kret = mach_make_memory_entry_64( | |
739 | VM_MAP_NULL, | |
740 | &mosize, | |
741 | 0, | |
742 | MAP_MEM_NAMED_CREATE | VM_PROT_DEFAULT, | |
743 | &mem_object, | |
744 | 0); | |
745 | ||
746 | if (kret != KERN_SUCCESS) | |
747 | goto out; | |
748 | ||
749 | MALLOC(pshmobj, struct pshmobj *, sizeof (struct pshmobj), | |
750 | M_SHM, M_WAITOK); | |
751 | if (pshmobj == NULL) { | |
752 | kret = KERN_NO_SPACE; | |
753 | mach_memory_entry_port_release(mem_object); | |
754 | mem_object = NULL; | |
755 | goto out; | |
756 | } | |
757 | ||
758 | PSHM_SUBSYS_LOCK(); | |
759 | ||
760 | pshmobj->pshmo_memobject = (void *) mem_object; | |
761 | pshmobj->pshmo_size = mosize; | |
762 | pshmobj->pshmo_next = NULL; | |
763 | ||
764 | *pshmobj_next_p = pshmobj; | |
765 | pshmobj_next_p = &pshmobj->pshmo_next; | |
766 | } | |
767 | ||
768 | pinfo->pshm_flags |= PSHM_ALLOCATED; | |
769 | pinfo->pshm_flags &= ~(PSHM_ALLOCATING); | |
770 | pinfo->pshm_length = total_size; | |
771 | PSHM_SUBSYS_UNLOCK(); | |
772 | return(0); | |
773 | ||
774 | out: | |
775 | PSHM_SUBSYS_LOCK(); | |
776 | for (pshmobj = pinfo->pshm_memobjects; | |
777 | pshmobj != NULL; | |
778 | pshmobj = pshmobj_next) { | |
779 | pshmobj_next = pshmobj->pshmo_next; | |
780 | mach_memory_entry_port_release(pshmobj->pshmo_memobject); | |
781 | FREE(pshmobj, M_SHM); | |
782 | } | |
783 | pinfo->pshm_memobjects = NULL; | |
784 | pinfo->pshm_flags &= ~PSHM_ALLOCATING; | |
785 | PSHM_SUBSYS_UNLOCK(); | |
786 | ||
787 | switch (kret) { | |
788 | case KERN_INVALID_ADDRESS: | |
789 | case KERN_NO_SPACE: | |
790 | return (ENOMEM); | |
791 | case KERN_PROTECTION_FAILURE: | |
792 | return (EACCES); | |
793 | default: | |
794 | return (EINVAL); | |
795 | ||
796 | } | |
797 | } | |
798 | ||
799 | int | |
800 | pshm_stat(struct pshmnode *pnode, void *ub, int isstat64) | |
801 | { | |
802 | struct stat *sb = (struct stat *)0; /* warning avoidance ; protected by isstat64 */ | |
803 | struct stat64 * sb64 = (struct stat64 *)0; /* warning avoidance ; protected by isstat64 */ | |
804 | struct pshminfo *pinfo; | |
805 | #if CONFIG_MACF | |
806 | int error; | |
807 | #endif | |
808 | ||
809 | PSHM_SUBSYS_LOCK(); | |
810 | if ((pinfo = pnode->pinfo) == PSHMINFO_NULL){ | |
811 | PSHM_SUBSYS_UNLOCK(); | |
812 | return(EINVAL); | |
813 | } | |
814 | ||
815 | #if CONFIG_MACF | |
816 | error = mac_posixshm_check_stat(kauth_cred_get(), pinfo); | |
817 | if (error) { | |
818 | PSHM_SUBSYS_UNLOCK(); | |
819 | return(error); | |
820 | } | |
821 | #endif | |
822 | ||
823 | if (isstat64 != 0) { | |
824 | sb64 = (struct stat64 *)ub; | |
825 | bzero(sb64, sizeof(struct stat64)); | |
826 | sb64->st_mode = pinfo->pshm_mode; | |
827 | sb64->st_uid = pinfo->pshm_uid; | |
828 | sb64->st_gid = pinfo->pshm_gid; | |
829 | sb64->st_size = pinfo->pshm_length; | |
830 | } else { | |
831 | sb = (struct stat *)ub; | |
832 | bzero(sb, sizeof(struct stat)); | |
833 | sb->st_mode = pinfo->pshm_mode; | |
834 | sb->st_uid = pinfo->pshm_uid; | |
835 | sb->st_gid = pinfo->pshm_gid; | |
836 | sb->st_size = pinfo->pshm_length; | |
837 | } | |
838 | PSHM_SUBSYS_UNLOCK(); | |
839 | ||
840 | return(0); | |
841 | } | |
842 | ||
843 | /* | |
844 | * This is called only from shm_open which holds pshm_lock(); | |
845 | * XXX This code is repeated many times | |
846 | */ | |
847 | int | |
848 | pshm_access(struct pshminfo *pinfo, int mode, kauth_cred_t cred, __unused proc_t p) | |
849 | { | |
850 | int mode_req = ((mode & FREAD) ? S_IRUSR : 0) | | |
851 | ((mode & FWRITE) ? S_IWUSR : 0); | |
852 | ||
853 | /* Otherwise, user id 0 always gets access. */ | |
854 | if (!suser(cred, NULL)) | |
855 | return (0); | |
856 | ||
857 | return(posix_cred_access(cred, pinfo->pshm_uid, pinfo->pshm_gid, pinfo->pshm_mode, mode_req)); | |
858 | } | |
859 | ||
860 | int | |
861 | pshm_mmap(__unused proc_t p, struct mmap_args *uap, user_addr_t *retval, struct fileproc *fp, off_t pageoff) | |
862 | { | |
863 | vm_map_offset_t user_addr = (vm_map_offset_t)uap->addr; | |
864 | vm_map_size_t user_size = (vm_map_size_t)uap->len ; | |
865 | vm_map_offset_t user_start_addr; | |
866 | vm_map_size_t map_size, mapped_size; | |
867 | int prot = uap->prot; | |
868 | int flags = uap->flags; | |
869 | vm_object_offset_t file_pos = (vm_object_offset_t)uap->pos; | |
870 | vm_object_offset_t map_pos; | |
871 | vm_map_t user_map; | |
872 | int alloc_flags; | |
873 | vm_map_kernel_flags_t vmk_flags; | |
874 | boolean_t docow; | |
875 | kern_return_t kret; | |
876 | struct pshminfo * pinfo; | |
877 | struct pshmnode * pnode; | |
878 | struct pshmobj * pshmobj; | |
879 | #if CONFIG_MACF | |
880 | int error; | |
881 | #endif | |
882 | ||
883 | if (user_size == 0) | |
884 | return(0); | |
885 | ||
886 | if ((flags & MAP_SHARED) == 0) | |
887 | return(EINVAL); | |
888 | ||
889 | ||
890 | if ((prot & PROT_WRITE) && ((fp->f_flag & FWRITE) == 0)) { | |
891 | return(EPERM); | |
892 | } | |
893 | ||
894 | if (((pnode = (struct pshmnode *)fp->f_data)) == PSHMNODE_NULL ) | |
895 | return(EINVAL); | |
896 | ||
897 | PSHM_SUBSYS_LOCK(); | |
898 | if ((pinfo = pnode->pinfo) == PSHMINFO_NULL) { | |
899 | PSHM_SUBSYS_UNLOCK(); | |
900 | return(EINVAL); | |
901 | } | |
902 | ||
903 | if ((pinfo->pshm_flags & PSHM_ALLOCATED) != PSHM_ALLOCATED) { | |
904 | PSHM_SUBSYS_UNLOCK(); | |
905 | return(EINVAL); | |
906 | } | |
907 | if (user_size > (vm_map_size_t)pinfo->pshm_length) { | |
908 | PSHM_SUBSYS_UNLOCK(); | |
909 | return(EINVAL); | |
910 | } | |
911 | vm_map_size_t end_pos = 0; | |
912 | if (os_add_overflow(user_size, file_pos, &end_pos)) { | |
913 | PSHM_SUBSYS_UNLOCK(); | |
914 | return(EINVAL); | |
915 | } | |
916 | if (end_pos > (vm_map_size_t)pinfo->pshm_length) { | |
917 | PSHM_SUBSYS_UNLOCK(); | |
918 | return(EINVAL); | |
919 | } | |
920 | if ((pshmobj = pinfo->pshm_memobjects) == NULL) { | |
921 | PSHM_SUBSYS_UNLOCK(); | |
922 | return(EINVAL); | |
923 | } | |
924 | ||
925 | #if CONFIG_MACF | |
926 | error = mac_posixshm_check_mmap(kauth_cred_get(), pinfo, prot, flags); | |
927 | if (error) { | |
928 | PSHM_SUBSYS_UNLOCK(); | |
929 | return(error); | |
930 | } | |
931 | #endif | |
932 | ||
933 | PSHM_SUBSYS_UNLOCK(); | |
934 | user_map = current_map(); | |
935 | ||
936 | if ((flags & MAP_FIXED) == 0) { | |
937 | alloc_flags = VM_FLAGS_ANYWHERE; | |
938 | user_addr = vm_map_round_page(user_addr, | |
939 | vm_map_page_mask(user_map)); | |
940 | } else { | |
941 | if (user_addr != vm_map_round_page(user_addr, | |
942 | vm_map_page_mask(user_map))) | |
943 | return (EINVAL); | |
944 | /* | |
945 | * We do not get rid of the existing mappings here because | |
946 | * it wouldn't be atomic (see comment in mmap()). We let | |
947 | * Mach VM know that we want it to replace any existing | |
948 | * mapping with the new one. | |
949 | */ | |
950 | alloc_flags = VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE; | |
951 | } | |
952 | docow = FALSE; | |
953 | ||
954 | mapped_size = 0; | |
955 | vmk_flags = VM_MAP_KERNEL_FLAGS_NONE; | |
956 | /* reserve the entire space first... */ | |
957 | kret = vm_map_enter_mem_object(user_map, | |
958 | &user_addr, | |
959 | user_size, | |
960 | 0, | |
961 | alloc_flags, | |
962 | vmk_flags, | |
963 | VM_KERN_MEMORY_NONE, | |
964 | IPC_PORT_NULL, | |
965 | 0, | |
966 | FALSE, | |
967 | VM_PROT_NONE, | |
968 | VM_PROT_NONE, | |
969 | VM_INHERIT_NONE); | |
970 | user_start_addr = user_addr; | |
971 | if (kret != KERN_SUCCESS) { | |
972 | goto out; | |
973 | } | |
974 | ||
975 | /* ... and overwrite with the real mappings */ | |
976 | for (map_pos = 0, pshmobj = pinfo->pshm_memobjects; | |
977 | user_size != 0; | |
978 | map_pos += pshmobj->pshmo_size, pshmobj = pshmobj->pshmo_next) { | |
979 | if (pshmobj == NULL) { | |
980 | /* nothing there to map !? */ | |
981 | goto out; | |
982 | } | |
983 | if (file_pos >= map_pos + pshmobj->pshmo_size) { | |
984 | continue; | |
985 | } | |
986 | map_size = pshmobj->pshmo_size - (file_pos - map_pos); | |
987 | if (map_size > user_size) { | |
988 | map_size = user_size; | |
989 | } | |
990 | vmk_flags = VM_MAP_KERNEL_FLAGS_NONE; | |
991 | kret = vm_map_enter_mem_object( | |
992 | user_map, | |
993 | &user_addr, | |
994 | map_size, | |
995 | 0, | |
996 | VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE, | |
997 | vmk_flags, | |
998 | VM_KERN_MEMORY_NONE, | |
999 | pshmobj->pshmo_memobject, | |
1000 | file_pos - map_pos, | |
1001 | docow, | |
1002 | prot, | |
1003 | VM_PROT_DEFAULT, | |
1004 | VM_INHERIT_SHARE); | |
1005 | if (kret != KERN_SUCCESS) | |
1006 | goto out; | |
1007 | ||
1008 | user_addr += map_size; | |
1009 | user_size -= map_size; | |
1010 | mapped_size += map_size; | |
1011 | file_pos += map_size; | |
1012 | } | |
1013 | ||
1014 | PSHM_SUBSYS_LOCK(); | |
1015 | pnode->mapp_addr = user_start_addr; | |
1016 | pnode->map_size = mapped_size; | |
1017 | pinfo->pshm_flags |= (PSHM_MAPPED | PSHM_INUSE); | |
1018 | PSHM_SUBSYS_UNLOCK(); | |
1019 | out: | |
1020 | if (kret != KERN_SUCCESS) { | |
1021 | if (mapped_size != 0) { | |
1022 | (void) mach_vm_deallocate(current_map(), | |
1023 | user_start_addr, | |
1024 | mapped_size); | |
1025 | } | |
1026 | } | |
1027 | ||
1028 | switch (kret) { | |
1029 | case KERN_SUCCESS: | |
1030 | *retval = (user_start_addr + pageoff); | |
1031 | return (0); | |
1032 | case KERN_INVALID_ADDRESS: | |
1033 | case KERN_NO_SPACE: | |
1034 | return (ENOMEM); | |
1035 | case KERN_PROTECTION_FAILURE: | |
1036 | return (EACCES); | |
1037 | default: | |
1038 | return (EINVAL); | |
1039 | } | |
1040 | ||
1041 | } | |
1042 | ||
1043 | static int | |
1044 | pshm_unlink_internal(struct pshminfo *pinfo, struct pshmcache *pcache) | |
1045 | { | |
1046 | struct pshmobj *pshmobj, *pshmobj_next; | |
1047 | ||
1048 | PSHM_SUBSYS_ASSERT_HELD(); | |
1049 | ||
1050 | if (!pinfo || !pcache) | |
1051 | return EINVAL; | |
1052 | ||
1053 | if ((pinfo->pshm_flags & (PSHM_DEFINED | PSHM_ALLOCATED)) == 0) | |
1054 | return EINVAL; | |
1055 | ||
1056 | if (pinfo->pshm_flags & PSHM_INDELETE) | |
1057 | return 0; | |
1058 | ||
1059 | pinfo->pshm_flags |= PSHM_INDELETE; | |
1060 | pinfo->pshm_usecount--; | |
1061 | ||
1062 | pshm_cache_delete(pcache); | |
1063 | pinfo->pshm_flags |= PSHM_REMOVED; | |
1064 | ||
1065 | /* release the existence reference */ | |
1066 | if (!pinfo->pshm_usecount) { | |
1067 | #if CONFIG_MACF | |
1068 | mac_posixshm_label_destroy(pinfo); | |
1069 | #endif | |
1070 | /* | |
1071 | * If this is the last reference going away on the object, | |
1072 | * then we need to destroy the backing object. The name | |
1073 | * has an implied but uncounted reference on the object, | |
1074 | * once it's created, since it's used as a rendezvous, and | |
1075 | * therefore may be subsequently reopened. | |
1076 | */ | |
1077 | for (pshmobj = pinfo->pshm_memobjects; | |
1078 | pshmobj != NULL; | |
1079 | pshmobj = pshmobj_next) { | |
1080 | mach_memory_entry_port_release(pshmobj->pshmo_memobject); | |
1081 | pshmobj_next = pshmobj->pshmo_next; | |
1082 | FREE(pshmobj, M_SHM); | |
1083 | } | |
1084 | FREE(pinfo,M_SHM); | |
1085 | } | |
1086 | ||
1087 | FREE(pcache, M_SHM); | |
1088 | ||
1089 | return 0; | |
1090 | } | |
1091 | ||
1092 | int | |
1093 | shm_unlink(proc_t p, struct shm_unlink_args *uap, __unused int32_t *retval) | |
1094 | { | |
1095 | size_t i; | |
1096 | char * pnbuf; | |
1097 | size_t pathlen; | |
1098 | int error = 0; | |
1099 | ||
1100 | struct pshmname nd; | |
1101 | struct pshminfo *pinfo; | |
1102 | char * nameptr; | |
1103 | char * cp; | |
1104 | struct pshmcache *pcache = PSHMCACHE_NULL; | |
1105 | ||
1106 | pinfo = PSHMINFO_NULL; | |
1107 | ||
1108 | ||
1109 | MALLOC_ZONE(pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK); | |
1110 | if (pnbuf == NULL) { | |
1111 | return(ENOSPC); /* XXX non-standard */ | |
1112 | } | |
1113 | pathlen = MAXPATHLEN; | |
1114 | error = copyinstr(uap->name, (void *)pnbuf, MAXPATHLEN, &pathlen); | |
1115 | if (error) { | |
1116 | goto bad; | |
1117 | } | |
1118 | AUDIT_ARG(text, pnbuf); | |
1119 | if (pathlen > PSHMNAMLEN) { | |
1120 | error = ENAMETOOLONG; | |
1121 | goto bad; | |
1122 | } | |
1123 | ||
1124 | nameptr = pnbuf; | |
1125 | ||
1126 | #ifdef PSXSHM_NAME_RESTRICT | |
1127 | if (*nameptr == '/') { | |
1128 | while (*(nameptr++) == '/') { | |
1129 | pathlen--; | |
1130 | error = EINVAL; | |
1131 | goto bad; | |
1132 | } | |
1133 | } else { | |
1134 | error = EINVAL; | |
1135 | goto bad; | |
1136 | } | |
1137 | #endif /* PSXSHM_NAME_RESTRICT */ | |
1138 | ||
1139 | nd.pshm_nameptr = nameptr; | |
1140 | nd.pshm_namelen = pathlen; | |
1141 | nd.pshm_hash = 0; | |
1142 | ||
1143 | for (cp = nameptr, i=1; *cp != 0 && i <= pathlen; i++, cp++) { | |
1144 | nd.pshm_hash += (unsigned char)*cp * i; | |
1145 | } | |
1146 | ||
1147 | PSHM_SUBSYS_LOCK(); | |
1148 | error = pshm_cache_search(&pinfo, &nd, &pcache, 0); | |
1149 | ||
1150 | /* During unlink lookup failure also implies ENOENT */ | |
1151 | if (error != PSHMCACHE_FOUND) { | |
1152 | PSHM_SUBSYS_UNLOCK(); | |
1153 | error = ENOENT; | |
1154 | goto bad; | |
1155 | ||
1156 | } | |
1157 | ||
1158 | if ((pinfo->pshm_flags & (PSHM_DEFINED | PSHM_ALLOCATED))==0) { | |
1159 | PSHM_SUBSYS_UNLOCK(); | |
1160 | error = EINVAL; | |
1161 | goto bad; | |
1162 | } | |
1163 | ||
1164 | if (pinfo->pshm_flags & PSHM_ALLOCATING) { | |
1165 | /* XXX should we wait for flag to clear and then proceed ? */ | |
1166 | PSHM_SUBSYS_UNLOCK(); | |
1167 | error = EAGAIN; | |
1168 | goto bad; | |
1169 | } | |
1170 | ||
1171 | if (pinfo->pshm_flags & PSHM_INDELETE) { | |
1172 | PSHM_SUBSYS_UNLOCK(); | |
1173 | error = 0; | |
1174 | goto bad; | |
1175 | } | |
1176 | ||
1177 | #if CONFIG_MACF | |
1178 | error = mac_posixshm_check_unlink(kauth_cred_get(), pinfo, nameptr); | |
1179 | if (error) { | |
1180 | PSHM_SUBSYS_UNLOCK(); | |
1181 | goto bad; | |
1182 | } | |
1183 | #endif | |
1184 | ||
1185 | AUDIT_ARG(posix_ipc_perm, pinfo->pshm_uid, pinfo->pshm_gid, | |
1186 | pinfo->pshm_mode); | |
1187 | ||
1188 | /* | |
1189 | * following file semantics, unlink should be allowed | |
1190 | * for users with write permission only. | |
1191 | */ | |
1192 | if ( (error = pshm_access(pinfo, FWRITE, kauth_cred_get(), p)) ) { | |
1193 | PSHM_SUBSYS_UNLOCK(); | |
1194 | goto bad; | |
1195 | } | |
1196 | ||
1197 | error = pshm_unlink_internal(pinfo, pcache); | |
1198 | PSHM_SUBSYS_UNLOCK(); | |
1199 | ||
1200 | bad: | |
1201 | FREE_ZONE(pnbuf, MAXPATHLEN, M_NAMEI); | |
1202 | return error; | |
1203 | } | |
1204 | ||
1205 | /* already called locked */ | |
1206 | static int | |
1207 | pshm_close(struct pshminfo *pinfo, int dropref) | |
1208 | { | |
1209 | int error = 0; | |
1210 | struct pshmobj *pshmobj, *pshmobj_next; | |
1211 | ||
1212 | /* | |
1213 | * If we are dropping the reference we took on the cache object, don't | |
1214 | * enforce the allocation requirement. | |
1215 | */ | |
1216 | if ( !dropref && ((pinfo->pshm_flags & PSHM_ALLOCATED) != PSHM_ALLOCATED)) { | |
1217 | return(EINVAL); | |
1218 | } | |
1219 | #if DIAGNOSTIC | |
1220 | if(!pinfo->pshm_usecount) { | |
1221 | kprintf("negative usecount in pshm_close\n"); | |
1222 | } | |
1223 | #endif /* DIAGNOSTIC */ | |
1224 | pinfo->pshm_usecount--; /* release this fd's reference */ | |
1225 | ||
1226 | if ((pinfo->pshm_flags & PSHM_REMOVED) && !pinfo->pshm_usecount) { | |
1227 | #if CONFIG_MACF | |
1228 | mac_posixshm_label_destroy(pinfo); | |
1229 | #endif | |
1230 | PSHM_SUBSYS_UNLOCK(); | |
1231 | /* | |
1232 | * If this is the last reference going away on the object, | |
1233 | * then we need to destroy the backing object. | |
1234 | */ | |
1235 | for (pshmobj = pinfo->pshm_memobjects; | |
1236 | pshmobj != NULL; | |
1237 | pshmobj = pshmobj_next) { | |
1238 | mach_memory_entry_port_release(pshmobj->pshmo_memobject); | |
1239 | pshmobj_next = pshmobj->pshmo_next; | |
1240 | FREE(pshmobj, M_SHM); | |
1241 | } | |
1242 | PSHM_SUBSYS_LOCK(); | |
1243 | FREE(pinfo,M_SHM); | |
1244 | } | |
1245 | return (error); | |
1246 | } | |
1247 | ||
1248 | /* vfs_context_t passed to match prototype for struct fileops */ | |
1249 | static int | |
1250 | pshm_closefile(struct fileglob *fg, __unused vfs_context_t ctx) | |
1251 | { | |
1252 | int error = EINVAL; | |
1253 | struct pshmnode *pnode; | |
1254 | ||
1255 | PSHM_SUBSYS_LOCK(); | |
1256 | ||
1257 | if ((pnode = (struct pshmnode *)fg->fg_data) != NULL) { | |
1258 | if (pnode->pinfo != PSHMINFO_NULL) { | |
1259 | error = pshm_close(pnode->pinfo, 0); | |
1260 | } | |
1261 | FREE(pnode, M_SHM); | |
1262 | } | |
1263 | ||
1264 | PSHM_SUBSYS_UNLOCK(); | |
1265 | ||
1266 | return(error); | |
1267 | } | |
1268 | ||
1269 | static int | |
1270 | pshm_read(__unused struct fileproc *fp, __unused struct uio *uio, | |
1271 | __unused int flags, __unused vfs_context_t ctx) | |
1272 | { | |
1273 | return(ENOTSUP); | |
1274 | } | |
1275 | ||
1276 | static int | |
1277 | pshm_write(__unused struct fileproc *fp, __unused struct uio *uio, | |
1278 | __unused int flags, __unused vfs_context_t ctx) | |
1279 | { | |
1280 | return(ENOTSUP); | |
1281 | } | |
1282 | ||
1283 | static int | |
1284 | pshm_ioctl(__unused struct fileproc *fp, __unused u_long com, | |
1285 | __unused caddr_t data, __unused vfs_context_t ctx) | |
1286 | { | |
1287 | return(ENOTSUP); | |
1288 | } | |
1289 | ||
1290 | static int | |
1291 | pshm_select(__unused struct fileproc *fp, __unused int which, __unused void *wql, | |
1292 | __unused vfs_context_t ctx) | |
1293 | { | |
1294 | return(ENOTSUP); | |
1295 | } | |
1296 | ||
1297 | static int | |
1298 | pshm_kqfilter(__unused struct fileproc *fp, struct knote *kn, | |
1299 | __unused struct kevent_internal_s *kev, __unused vfs_context_t ctx) | |
1300 | { | |
1301 | kn->kn_flags = EV_ERROR; | |
1302 | kn->kn_data = ENOTSUP; | |
1303 | return 0; | |
1304 | } | |
1305 | ||
1306 | int | |
1307 | fill_pshminfo(struct pshmnode * pshm, struct pshm_info * info) | |
1308 | { | |
1309 | struct pshminfo *pinfo; | |
1310 | struct vinfo_stat *sb; | |
1311 | ||
1312 | PSHM_SUBSYS_LOCK(); | |
1313 | if ((pinfo = pshm->pinfo) == PSHMINFO_NULL){ | |
1314 | PSHM_SUBSYS_UNLOCK(); | |
1315 | return(EINVAL); | |
1316 | } | |
1317 | ||
1318 | sb = &info->pshm_stat; | |
1319 | ||
1320 | bzero(sb, sizeof(struct vinfo_stat)); | |
1321 | sb->vst_mode = pinfo->pshm_mode; | |
1322 | sb->vst_uid = pinfo->pshm_uid; | |
1323 | sb->vst_gid = pinfo->pshm_gid; | |
1324 | sb->vst_size = pinfo->pshm_length; | |
1325 | ||
1326 | info->pshm_mappaddr = pshm->mapp_addr; | |
1327 | bcopy(&pinfo->pshm_name[0], &info->pshm_name[0], PSHMNAMLEN+1); | |
1328 | ||
1329 | PSHM_SUBSYS_UNLOCK(); | |
1330 | return(0); | |
1331 | } | |
1332 | ||
1333 | #if CONFIG_MACF | |
1334 | void | |
1335 | pshm_label_associate(struct fileproc *fp, struct vnode *vp, vfs_context_t ctx) | |
1336 | { | |
1337 | struct pshmnode *pnode; | |
1338 | struct pshminfo *pshm; | |
1339 | ||
1340 | PSHM_SUBSYS_LOCK(); | |
1341 | pnode = (struct pshmnode *)fp->f_fglob->fg_data; | |
1342 | if (pnode != NULL) { | |
1343 | pshm = pnode->pinfo; | |
1344 | if (pshm != NULL) | |
1345 | mac_posixshm_vnode_label_associate( | |
1346 | vfs_context_ucred(ctx), pshm, pshm->pshm_label, | |
1347 | vp, vp->v_label); | |
1348 | } | |
1349 | PSHM_SUBSYS_UNLOCK(); | |
1350 | } | |
1351 | #endif |