![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_mman.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / kern|
Return to kern_mman.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1988 University of Utah.
27: * Copyright (c) 1991, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * the Systems Programming Group of the University of Utah Computer
32: * Science Department.
33: *
34: * Redistribution and use in source and binary forms, with or without
35: * modification, are permitted provided that the following conditions
36: * are met:
37: * 1. Redistributions of source code must retain the above copyright
38: * notice, this list of conditions and the following disclaimer.
39: * 2. Redistributions in binary form must reproduce the above copyright
40: * notice, this list of conditions and the following disclaimer in the
41: * documentation and/or other materials provided with the distribution.
42: * 3. All advertising materials mentioning features or use of this software
43: * must display the following acknowledgement:
44: * This product includes software developed by the University of
45: * California, Berkeley and its contributors.
46: * 4. Neither the name of the University nor the names of its contributors
47: * may be used to endorse or promote products derived from this software
48: * without specific prior written permission.
49: *
50: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60: * SUCH DAMAGE.
61: *
62: * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$
63: *
64: * @(#)vm_mmap.c 8.10 (Berkeley) 2/19/95
65: */
66:
67: /*
68: * Mapped file (mmap) interface to VM
69: */
70:
71: #import <sys/param.h>
72: #import <sys/systm.h>
73: #import <sys/filedesc.h>
74: #import <sys/proc.h>
75: #import <sys/resourcevar.h>
76: #import <sys/buf.h>
77: #import <sys/vnode.h>
78: #import <sys/acct.h>
79: #import <sys/wait.h>
80: #import <sys/file.h>
81: #import <sys/vadvise.h>
82: #import <sys/trace.h>
83: #import <sys/mman.h>
84: #import <sys/conf.h>
85: #import <mach/kern_return.h>
86: #import <kern/task.h>
87: #import <mach/vm_param.h>
88: #import <vm/vm_map.h>
89: #import <vm/vm_pager.h>
90: #import <vm/vnode_pager.h>
91: #import <kern/mapfs.h>
92: #import <miscfs/specfs/specdev.h>
93:
94: struct sbrk_args {
95: int incr;
96: };
97:
98: /* ARGSUSED */
99: int
100: sbrk(p, uap, retval)
101: struct proc *p;
102: struct sbrk_args *uap;
103: register_t *retval;
104: {
105: /* Not yet implemented */
106: kprintf("sbrk(): not supported!\n");
107: return (EOPNOTSUPP);
108: }
109:
110: struct sstk_args {
111: int incr;
112: } *uap;
113:
114: /* ARGSUSED */
115: int
116: sstk(p, uap, retval)
117: struct proc *p;
118: struct sstk_args *uap;
119: register_t *retval;
120: {
121: /* Not yet implemented */
122: kprintf("sstk(): not supported!\n");
123: return (EOPNOTSUPP);
124: }
125:
126: #if COMPAT_43
127: /* ARGSUSED */
128: int
129: ogetpagesize(p, uap, retval)
130: struct proc *p;
131: void *uap;
132: register_t *retval;
133: {
134:
135: *retval = PAGE_SIZE;
136: return (0);
137: }
138: #endif /* COMPAT_43 */
139:
140: struct osmmap_args {
141: caddr_t addr;
142: int len;
143: int prot;
144: int share;
145: int fd;
146: long pos;
147: };
148:
149: osmmap(curp, uap, retval)
150: struct proc *curp;
151: register struct osmmap_args *uap;
152: register_t *retval;
153: {
154: struct mmap_args {
155: caddr_t addr;
156: size_t len;
157: int prot;
158: int flags;
159: int fd;
160: #ifdef DOUBLE_ALIGN_PARAMS
161: long pad;
162: #endif
163: off_t pos;
164: } newargs;
165:
166: if ((uap->share == MAP_SHARED )|| (uap->share == MAP_PRIVATE )) {
167: newargs.addr = uap->addr;
168: newargs.len = (size_t)uap->len;
169: newargs.prot = uap->prot;
170: newargs.flags = uap->share;
171: newargs.fd = uap->fd;
172: newargs.pos = (off_t)uap->pos;
173: return(mmap(curp,&newargs, retval));
174: } else
175: return(EINVAL);
176: }
177:
178: struct mmap_args {
179: caddr_t addr;
180: size_t len;
181: int prot;
182: int flags;
183: int fd;
184: #ifdef DOUBLE_ALIGN_PARAMS
185: long pad;
186: #endif
187: off_t pos;
188: };
189:
190: mmap(p, uap, retval)
191: struct proc *p;
192: struct mmap_args *uap;
193: register_t *retval;
194: {
195: /*
196: * Map in special device (must be SHARED) or file
197: */
198: struct file *fp;
199: register struct vnode *vp;
200: int flags;
201: int prot;
202: int err=0;
203: vm_map_t user_map;
204: kern_return_t result;
205: vm_offset_t user_addr;
206: vm_size_t user_size;
207: vm_offset_t file_pos;
208: boolean_t find_space;
209: extern vm_object_t vm_object_special();
210:
211: user_addr = (vm_offset_t)uap->addr;
212: user_size = (vm_size_t) uap->len;
213:
214: prot = (uap->prot & VM_PROT_ALL);
215: flags = uap->flags;
216:
217: /*
218: * The vm code does not have prototypes & compileser doesn't do the'
219: * the right thing when you cast 64bit value and pass it in function
220: * call. So here it is.
221: */
222: file_pos = (vm_offset_t)uap->pos;
223:
224: /* Anonymous mapping not supported, for now. */
225: if (((flags & MAP_FIXED) && !page_aligned(user_addr)) ||
226: (user_size < 0) || (flags & MAP_ANON)) {
227: return(EINVAL);
228: }
229:
230: err = fdgetf(p, uap->fd, &fp);
231: if (err)
232: return(err);
233:
234: if (fp->f_type != DTYPE_VNODE)
235: return(EBADF);
236: vp = (struct vnode *)fp->f_data;
237:
238: /*
239: * We bend a little - round the start and end addresses
240: * to the nearest page boundary.
241: */
242: user_addr = trunc_page(user_addr);
243: user_size = round_page(user_size);
244:
245: /*
246: * File can be COPIED at an arbitrary offset.
247: * File can only be SHARED if the offset is at a
248: * page boundary.
249: */
250:
251: if ((flags & MAP_SHARED) && ((vm_offset_t)file_pos & page_mask)) {
252: return(EINVAL);
253: }
254:
255: /*
256: * File must be writable if memory will be.
257: */
258: if ((prot & PROT_WRITE) && (fp->f_flag&FWRITE) == 0) {
259: if ((flags & MAP_PRIVATE) == 0) {
260: /* #2211802 */
261: /* If private map, its okay to have write access
262: as allocated space is both read and write
263: */
264: return(EACCES);
265: }
266: }
267: if ((prot & PROT_READ) && (fp->f_flag&FREAD) == 0) {
268: return(EACCES);
269: }
270: /*
271: * Bug# 2203998 -> zero sized length is a valid arg
272: * in 4.4; for ex, copy of zero sized file
273: * will call mmap with length 0
274: */
275: if (user_size == 0)
276: return(0);
277:
278: /*
279: * memory must exist and be writable (even if we're
280: * just reading)
281: */
282:
283: user_map = current_task()->map;
284:
285: #if 0
286: if (!vm_map_check_protection(user_map, user_addr,
287: (vm_offset_t)(user_addr + user_size),
288: VM_PROT_READ|VM_PROT_WRITE)) {
289: return(EINVAL);
290: }
291: #endif
292: if (flags & MAP_FIXED) {
293: find_space = FALSE;
294: } else {
295: find_space = TRUE;
296: }
297:
298: if (vp->v_type == VCHR || vp->v_type == VSTR) {
299: return(EOPNOTSUPP);
300: }
301: else {
302: /*
303: * Map in a file. May be PRIVATE (copy-on-write)
304: * or SHARED (changes go back to file)
305: */
306: vm_pager_t pager;
307: vm_map_t copy_map;
308: vm_offset_t off;
309: struct vm_info *vmp;
310:
311: /*
312: * Only allow regular files for the moment.
313: */
314: if (vp->v_type != VREG) {
315: return(EBADF);
316: }
317:
318: pager = vnode_pager_setup(vp, FALSE, TRUE);
319:
320: /*
321: * Set credentials:
322: * FIXME: if we're writing the file we need a way to
323: * ensure that someone doesn't replace our R/W creds
324: * with ones that only work for read.
325: */
326: vmp = vp->v_vm_info;
327: if (vmp->cred == NULL) {
328: crhold(p->p_ucred);
329: vmp->cred = p->p_ucred;
330: }
331: /* Find space if not MAP_FIXED; otherwise validate */
332: /* This also fixes 2215605 */
333: result = vm_map_find(user_map, NULL, (vm_offset_t) 0,
334: &user_addr, user_size, find_space);
335: if (result != KERN_SUCCESS) {
336: goto out;
337: }
338: if (flags & MAP_SHARED) {
339: /*
340: * Map it directly, allowing modifications
341: * to go out to the inode.
342: */
343: (void) vm_deallocate(user_map, user_addr, user_size);
344: result = vm_allocate_with_pager(user_map,
345: &user_addr, user_size, find_space,
346: pager,
347: (vm_offset_t)file_pos);
348: if (result != KERN_SUCCESS) {
349: goto out;
350: }
351: }
352: else {
353: #if 0
354: /* Moved to cover both shared and private cases */
355: result = vm_map_find(user_map, NULL, (vm_offset_t) 0,
356: &user_addr, user_size, find_space);
357: if (result != KERN_SUCCESS) {
358: goto out;
359: }
360: #endif /* 0 */
361: /*
362: * Copy-on-write of file. Map into private
363: * map, then copy into our address space.
364: */
365: copy_map = vm_map_create(pmap_create(user_size),
366: 0, user_size, TRUE);
367: off = 0;
368: result = vm_allocate_with_pager(copy_map,
369: &off, user_size, find_space,
370: pager,
371: (vm_offset_t)file_pos);
372: if (result != KERN_SUCCESS) {
373: vm_map_deallocate(copy_map);
374: goto out;
375: }
376: result = vm_map_copy(user_map, copy_map,
377: user_addr, user_size,
378: 0, FALSE, FALSE);
379: if (result != KERN_SUCCESS) {
380: vm_map_deallocate(copy_map);
381: goto out;
382: }
383: vm_map_deallocate(copy_map);
384: }
385: }
386:
387: /*
388: * Our memory defaults to read-write. If it shouldn't
389: * be readable, protect it.
390: */
391: if ((prot & PROT_WRITE) == 0) {
392: result = vm_protect(user_map, user_addr, user_size,
393: FALSE, VM_PROT_READ);
394: if (result != KERN_SUCCESS) {
395: (void) vm_deallocate(user_map, user_addr, user_size);
396: goto out;
397: }
398: }
399:
400: /*
401: * Shared memory is also shared with children
402: */
403: /*
404: * HACK HACK HACK
405: * Since this memory CAN'T be made copy-on-write, and since
406: * its users fork, we must change its inheritance to SHARED.
407: * HACK HACK HACK
408: */
409: if (flags & MAP_SHARED) {
410: result = vm_inherit(user_map, user_addr, user_size,
411: VM_INHERIT_SHARE);
412: if (result != KERN_SUCCESS) {
413: (void) vm_deallocate(user_map, user_addr, user_size);
414: goto out;
415: }
416: }
417:
418: *fdflags(p, uap->fd) |= UF_MAPPED;
419:
420: if (result == KERN_SUCCESS)
421: *retval = (register_t)user_addr;
422: /* FALL THROUGH */
423: out:
424: switch (result) {
425: case KERN_SUCCESS:
426: return (0);
427: case KERN_INVALID_ADDRESS:
428: case KERN_NO_SPACE:
429: return (ENOMEM);
430: case KERN_PROTECTION_FAILURE:
431: return (EACCES);
432: default:
433: return (EINVAL);
434: }
435: }
436:
437: struct msync_args {
438: caddr_t addr;
439: int len;
440: };
441: int
442: msync(p, uap, retval)
443: struct proc *p;
444: struct msync_args *uap;
445: register_t *retval;
446: {
447: /* Not yet implemented */
448: return (EOPNOTSUPP);
449: }
450:
451:
452: mremap()
453: {
454: /* Not yet implemented */
455: return (EOPNOTSUPP);
456: }
457:
458: struct munmap_args {
459: caddr_t addr;
460: int len;
461: };
462: munmap(p, uap, retval)
463: struct proc *p;
464: struct munmap_args *uap;
465: register_t *retval;
466:
467: {
468: vm_offset_t user_addr;
469: vm_size_t user_size;
470: kern_return_t result;
471:
472: user_addr = (vm_offset_t) uap->addr;
473: user_size = (vm_size_t) uap->len;
474:
475: /*
476: * user size is allocated to page boundary and size from
477: * the user land is not necessarily in multiple of page size
478: */
479: user_size = round_page(user_size);
480: if ((user_addr & page_mask) ||
481: (user_size & page_mask)) {
482: return(EINVAL);
483: }
484: result = vm_deallocate(current_task()->map, user_addr, user_size);
485: if (result != KERN_SUCCESS) {
486: return(EINVAL);
487: }
488: return(0);
489: }
490:
491: void
492: munmapfd(p, fd)
493: struct proc *p;
494: int fd;
495: {
496: /*
497: * XXX should vm_deallocate any regions mapped to this file
498: */
499: *fdflags(p, fd) &= ~UF_MAPPED;
500: }
501:
502: struct mprotect_args {
503: caddr_t addr;
504: int len;
505: int prot;
506: };
507: int
508: mprotect(p, uap, retval)
509: struct proc *p;
510: struct mprotect_args *uap;
511: register_t *retval;
512: {
513: vm_size_t size;
514: register vm_prot_t prot;
515: caddr_t addr;
516: int len;
517: vm_map_t user_map;
518:
519: addr = uap->addr;
520: len = uap->len;
521: prot = (vm_prot_t)(uap->prot & VM_PROT_ALL);
522:
523: if (((unsigned long)addr & page_mask) || len < 0)
524: return(EINVAL);
525: size = (vm_size_t)len;
526:
527: user_map = current_task()->map;
528: switch (vm_map_protect(user_map, addr, addr+size, prot,
529: FALSE)) {
530: case KERN_SUCCESS:
531: return (0);
532: case KERN_PROTECTION_FAILURE:
533: return (EACCES);
534: }
535: return (EINVAL);
536: }
537:
538: struct madvise_args {
539: caddr_t addr;
540: int len;
541: int behav;
542: };
543: /* ARGSUSED */
544: int
545: madvise(p, uap, retval)
546: struct proc *p;
547: struct madvise_args *uap;
548: register_t *retval;
549: {
550: /* Not yet implemented */
551: return (EOPNOTSUPP);
552: }
553:
554: struct mincore_args {
555: caddr_t addr;
556: int len;
557: char * vec;
558: };
559: /* ARGSUSED */
560: int
561: mincore(p, uap, retval)
562: struct proc *p;
563: struct mincore_args *uap;
564: register_t *retval;
565: {
566: /* Not yet implemented */
567: return (EOPNOTSUPP);
568: }
569:
570: struct mlock_args {
571: caddr_t addr;
572: size_t len;
573: };
574: int
575: mlock(p, uap, retval)
576: struct proc *p;
577: struct mlock_args *uap;
578: register_t *retval;
579: {
580: /* Not yet implemented */
581: return (EOPNOTSUPP);
582: }
583:
584: struct munlock_args {
585: caddr_t addr;
586: size_t len;
587: };
588: int
589: munlock(p, uap, retval)
590: struct proc *p;
591: struct munlock_args *uap;
592: register_t *retval;
593: {
594: /* Not yet implemented */
595: return (EOPNOTSUPP);
596: }
597:
598: int
599: map_fd(fd, offset, va, findspace, size)
600: int fd;
601: vm_offset_t offset;
602: vm_offset_t *va;
603: boolean_t findspace;
604: vm_size_t size;
605: {
606: struct file *fp;
607: register struct vnode *vp;
608: vm_map_t user_map;
609: kern_return_t result;
610: vm_offset_t user_addr;
611: vm_size_t user_size;
612: vm_pager_t pager;
613: vm_map_t copy_map;
614: vm_offset_t off;
615:
616: user_map = current_task()->map;
617:
618: /*
619: * Find the inode; verify that it's a regular file.
620: */
621: if (getvnode(current_proc(), fd, &fp))
622: return (KERN_INVALID_ARGUMENT);
623:
624: vp = (struct vnode *)fp->f_data;
625: if (vp->v_type != VREG)
626: return(KERN_INVALID_ARGUMENT);
627:
628: user_size = round_page(size);
629:
630: if (findspace) {
631: /*
632: * Allocate dummy memory.
633: */
634: result = vm_allocate(user_map, &user_addr, size, TRUE);
635: if (result != KERN_SUCCESS)
636: return(result);
637: if (copyout(&user_addr, va, sizeof(vm_offset_t))) {
638: (void) vm_deallocate(user_map, user_addr, size);
639: return(KERN_INVALID_ADDRESS);
640: }
641: }
642: else {
643: /*
644: * Get user's address, and verify that it's
645: * page-aligned and writable.
646: */
647:
648: if (copyin(va, &user_addr, sizeof(vm_offset_t)))
649: return(KERN_INVALID_ADDRESS);
650: if ((trunc_page(user_addr) != user_addr))
651: return(KERN_INVALID_ARGUMENT);
652: if (!vm_map_check_protection(user_map, user_addr,
653: (vm_offset_t)(user_addr + user_size),
654: VM_PROT_READ|VM_PROT_WRITE))
655: return(KERN_INVALID_ARGUMENT);
656: }
657:
658: /*
659: * Allow user to map in a zero length file.
660: */
661: if (size == 0)
662: return KERN_SUCCESS;
663:
664: /*
665: * Map in the file.
666: */
667:
668: pager = vnode_pager_setup(vp, FALSE, TRUE);
669:
670: /*
671: * Map into private map, then copy into our address space.
672: */
673: copy_map = vm_map_create(pmap_create(user_size), 0, user_size, TRUE);
674: off = 0;
675: result = vm_allocate_with_pager(copy_map, &off, user_size, FALSE,
676: pager,
677: offset);
678: if (result == KERN_SUCCESS)
679: result = vm_map_copy(user_map, copy_map, user_addr, user_size,
680: 0, FALSE, FALSE);
681:
682: if ((result != KERN_SUCCESS) && findspace)
683: (void) vm_deallocate(user_map, user_addr, user_size);
684:
685: vm_map_deallocate(copy_map);
686:
687: /*
688: * Set credentials.
689: */
690: if (vp->v_vm_info->cred == NULL) {
691: crhold(current_proc()->p_ucred);
692: vp->v_vm_info->cred = current_proc()->p_ucred;
693: }
694:
695: return(result);
696: }
697:
698:
699: /* BEGIN DEFUNCT */
700: struct obreak_args {
701: char *nsiz;
702: };
703: obreak(p, uap, retval)
704: struct proc *p;
705: struct obreak_args *uap;
706: register_t *retval;
707: {
708: /* Not implemented, obsolete */
709: return (ENOMEM);
710: }
711:
712: int both;
713:
714: ovadvise()
715: {
716:
717: #ifdef lint
718: both = 0;
719: #endif
720: }
721: /* END DEFUNCT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.