![[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 XNU] / XNU / bsd / kern|
Return to kern_mman.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1988 University of Utah.
24: * Copyright (c) 1991, 1993
25: * The Regents of the University of California. All rights reserved.
26: *
27: * This code is derived from software contributed to Berkeley by
28: * the Systems Programming Group of the University of Utah Computer
29: * Science Department.
30: *
31: * Redistribution and use in source and binary forms, with or without
32: * modification, are permitted provided that the following conditions
33: * are met:
34: * 1. Redistributions of source code must retain the above copyright
35: * notice, this list of conditions and the following disclaimer.
36: * 2. Redistributions in binary form must reproduce the above copyright
37: * notice, this list of conditions and the following disclaimer in the
38: * documentation and/or other materials provided with the distribution.
39: * 3. All advertising materials mentioning features or use of this software
40: * must display the following acknowledgement:
41: * This product includes software developed by the University of
42: * California, Berkeley and its contributors.
43: * 4. Neither the name of the University nor the names of its contributors
44: * may be used to endorse or promote products derived from this software
45: * without specific prior written permission.
46: *
47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57: * SUCH DAMAGE.
58: *
59: * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$
60: *
61: * @(#)vm_mmap.c 8.10 (Berkeley) 2/19/95
62: */
63:
64: /*
65: * Mapped file (mmap) interface to VM
66: */
67:
68: #include <sys/param.h>
69: #include <sys/systm.h>
70: #include <sys/filedesc.h>
71: #include <sys/proc.h>
72: #include <sys/resourcevar.h>
73: #include <sys/buf.h>
74: #include <sys/vnode.h>
75: #include <sys/acct.h>
76: #include <sys/wait.h>
77: #include <sys/file.h>
78: #include <sys/vadvise.h>
79: #include <sys/trace.h>
80: #include <sys/mman.h>
81: #include <sys/conf.h>
82: #include <sys/stat.h>
83:
84: #include <mach/mach_types.h>
85:
86: #include <kern/cpu_number.h>
87:
88: #include <vm/vm_map.h>
89: #include <vm/vm_kern.h>
90: #include <vm/vm_pager.h>
91: #include <vm/vnode_pager.h>
92: #include <kern/mapfs.h>
93:
94: #include <mach/vm_sync.h>
95: #include <mach/vm_behavior.h>
96: #include <mach/vm_inherit.h>
97: #include <mach/vm_statistics.h>
98:
99: struct sbrk_args {
100: int incr;
101: };
102:
103: /* ARGSUSED */
104: int
105: sbrk(p, uap, retval)
106: struct proc *p;
107: struct sbrk_args *uap;
108: register_t *retval;
109: {
110: /* Not yet implemented */
111: return (EOPNOTSUPP);
112: }
113:
114: struct sstk_args {
115: int incr;
116: } *uap;
117:
118: /* ARGSUSED */
119: int
120: sstk(p, uap, retval)
121: struct proc *p;
122: struct sstk_args *uap;
123: register_t *retval;
124: {
125: /* Not yet implemented */
126: return (EOPNOTSUPP);
127: }
128:
129: #if COMPAT_43
130: /* ARGSUSED */
131: int
132: ogetpagesize(p, uap, retval)
133: struct proc *p;
134: void *uap;
135: register_t *retval;
136: {
137:
138: *retval = PAGE_SIZE;
139: return (0);
140: }
141: #endif /* COMPAT_43 */
142:
143: struct osmmap_args {
144: caddr_t addr;
145: int len;
146: int prot;
147: int share;
148: int fd;
149: long pos;
150: };
151:
152: osmmap(curp, uap, retval)
153: struct proc *curp;
154: register struct osmmap_args *uap;
155: register_t *retval;
156: {
157: struct mmap_args {
158: caddr_t addr;
159: size_t len;
160: int prot;
161: int flags;
162: int fd;
163: #ifdef DOUBLE_ALIGN_PARAMS
164: long pad;
165: #endif
166: off_t pos;
167: } newargs;
168:
169: if ((uap->share == MAP_SHARED )|| (uap->share == MAP_PRIVATE )) {
170: newargs.addr = uap->addr;
171: newargs.len = (size_t)uap->len;
172: newargs.prot = uap->prot;
173: newargs.flags = uap->share;
174: newargs.fd = uap->fd;
175: newargs.pos = (off_t)uap->pos;
176: return(mmap(curp,&newargs, retval));
177: } else
178: return(EINVAL);
179: }
180:
181: struct mmap_args {
182: caddr_t addr;
183: size_t len;
184: int prot;
185: int flags;
186: int fd;
187: #ifdef DOUBLE_ALIGN_PARAMS
188: long pad;
189: #endif
190: off_t pos;
191: };
192: int
193: mmap(p, uap, retval)
194: struct proc *p;
195: struct mmap_args *uap;
196: register_t *retval;
197: {
198: /*
199: * Map in special device (must be SHARED) or file
200: */
201: struct file *fp;
202: register struct vnode *vp;
203: int flags;
204: int prot;
205: int err=0;
206: vm_map_t user_map;
207: kern_return_t result;
208: vm_offset_t user_addr;
209: vm_size_t user_size, pageoff;
210: vm_offset_t file_pos;
211: boolean_t find_space, docow;
212: vm_prot_t maxprot;
213: void *handle;
214: vm_pager_t pager;
215: struct vm_info *vmp;
216: int mapanon=0;
217:
218: user_addr = (vm_offset_t)uap->addr;
219: user_size = (vm_size_t) uap->len;
220: prot = (uap->prot & VM_PROT_ALL);
221: flags = uap->flags;
222:
223: /*
224: * The vm code does not have prototypes & compiler doesn't do the'
225: * the right thing when you cast 64bit value and pass it in function
226: * call. So here it is.
227: */
228: file_pos = (vm_offset_t)uap->pos;
229:
230:
231: /* make sure mapping fits into numeric range etc */
232: if ((file_pos + user_size > (vm_offset_t)-PAGE_SIZE) ||
233: ((ssize_t) uap->len < 0 )||
234: ((flags & MAP_ANON) && uap->fd != -1))
235: return (EINVAL);
236:
237: /*
238: * Align the file position to a page boundary,
239: * and save its page offset component.
240: */
241: pageoff = (file_pos & PAGE_MASK);
242: file_pos -= pageoff;
243:
244:
245: /* Adjust size for rounding (on both ends). */
246: user_size += pageoff; /* low end... */
247: user_size = (vm_size_t) round_page(user_size); /* hi end */
248:
249:
250: /*
251: * Check for illegal addresses. Watch out for address wrap... Note
252: * that VM_*_ADDRESS are not constants due to casts (argh).
253: */
254: if (flags & MAP_FIXED) {
255: /*
256: * The specified address must have the same remainder
257: * as the file offset taken modulo PAGE_SIZE, so it
258: * should be aligned after adjustment by pageoff.
259: */
260: user_addr -= pageoff;
261: if (user_addr & PAGE_MASK)
262: return (EINVAL);
263: /* Address range must be all in user VM space. */
264: if (VM_MAX_ADDRESS > 0 && (user_addr + user_size > VM_MAX_ADDRESS))
265: return (EINVAL);
266: if (VM_MIN_ADDRESS > 0 && user_addr < VM_MIN_ADDRESS)
267: return (EINVAL);
268: if (user_addr + user_size < user_addr)
269: return (EINVAL);
270: }
271: #ifdef notyet
272: /* DO not have apis to get this info, need to wait till then*/
273: /*
274: * XXX for non-fixed mappings where no hint is provided or
275: * the hint would fall in the potential heap space,
276: * place it after the end of the largest possible heap.
277: *
278: * There should really be a pmap call to determine a reasonable
279: * location.
280: */
281: else if (addr < round_page(p->p_vmspace->vm_daddr + MAXDSIZ))
282: addr = round_page(p->p_vmspace->vm_daddr + MAXDSIZ);
283:
284: #endif
285:
286:
287: if (flags & MAP_ANON) {
288: /*
289: * Mapping blank space is trivial.
290: */
291: handle = NULL;
292: maxprot = VM_PROT_ALL;
293: file_pos = 0;
294: mapanon = 1;
295: } else {
296: /*
297: * Mapping file, get fp for validation. Obtain vnode and make
298: * sure it is of appropriate type.
299: */
300: err = fdgetf(p, uap->fd, &fp);
301: if (err)
302: return(err);
303: if(fp->f_type == DTYPE_PSXSHM) {
304: uap->addr = user_addr;
305: uap->len = user_size;
306: uap->prot = prot;
307: uap->flags = flags;
308: uap->pos = file_pos;
309: return(pshm_mmap(p, uap, retval, fp , pageoff));
310: }
311:
312: if (fp->f_type != DTYPE_VNODE)
313: return(EINVAL);
314: vp = (struct vnode *)fp->f_data;
315:
316: if (vp->v_type != VREG && vp->v_type != VCHR)
317: return (EINVAL);
318: /*
319: * XXX hack to handle use of /dev/zero to map anon memory (ala
320: * SunOS).
321: */
322: if (vp->v_type == VCHR || vp->v_type == VSTR) {
323: return(EOPNOTSUPP);
324: } else {
325: /*
326: * Ensure that file and memory protections are
327: * compatible. Note that we only worry about
328: * writability if mapping is shared; in this case,
329: * current and max prot are dictated by the open file.
330: * XXX use the vnode instead? Problem is: what
331: * credentials do we use for determination? What if
332: * proc does a setuid?
333: */
334: maxprot = VM_PROT_EXECUTE; /* ??? */
335: if (fp->f_flag & FREAD)
336: maxprot |= VM_PROT_READ;
337: else if (prot & PROT_READ)
338: return (EACCES);
339: /*
340: * If we are sharing potential changes (either via
341: * MAP_SHARED or via the implicit sharing of character
342: * device mappings), and we are trying to get write
343: * permission although we opened it without asking
344: * for it, bail out.
345: */
346:
347: if ((flags & MAP_SHARED) != 0) {
348: if ((fp->f_flag & FWRITE) != 0) {
349: struct vattr va;
350: if ((err =
351: VOP_GETATTR(vp, &va,
352: p->p_ucred, p)))
353: return (err);
354: if ((va.va_flags &
355: (IMMUTABLE|APPEND)) == 0)
356: maxprot |= VM_PROT_WRITE;
357: else if (prot & PROT_WRITE)
358: return (EPERM);
359: } else if ((prot & PROT_WRITE) != 0)
360: return (EACCES);
361: } else
362: maxprot |= VM_PROT_WRITE;
363:
364: handle = (void *)vp;
365: }
366: }
367:
368: if (user_size == 0)
369: return(0);
370:
371: /*
372: * We bend a little - round the start and end addresses
373: * to the nearest page boundary.
374: */
375: user_size = round_page(user_size);
376:
377: if (file_pos & PAGE_MASK)
378: return (EINVAL);
379:
380: user_map = current_map();
381:
382: if ((flags & MAP_FIXED) == 0) {
383: find_space = TRUE;
384: user_addr = round_page(user_addr);
385: } else {
386: if (user_addr != trunc_page(user_addr))
387: return (EINVAL);
388: find_space = FALSE;
389: (void) vm_deallocate(user_map, user_addr, user_size);
390: }
391:
392:
393: /*
394: * Lookup/allocate object.
395: */
396: if (flags & MAP_ANON) {
397: /*
398: * Unnamed anonymous regions always start at 0.
399: */
400: if (handle == 0)
401: file_pos = 0;
402: }
403:
404: if (handle == NULL) {
405: pager = NULL;
406: #ifdef notyet
407: /* Hmm .. */
408: #if defined(VM_PROT_READ_IS_EXEC)
409: if (prot & VM_PROT_READ)
410: prot |= VM_PROT_EXECUTE;
411:
412: if (maxprot & VM_PROT_READ)
413: maxprot |= VM_PROT_EXECUTE;
414: #endif
415: #endif
416: result = vm_allocate(user_map, &user_addr, user_size, find_space);
417: if (result != KERN_SUCCESS)
418: goto out;
419:
420: } else {
421: if (!vp->v_vm_info) {
422: vm_info_init(vp);
423: }
424: pager = vnode_pager_setup(vp,
425: vp->v_vm_info->pager, FALSE, FALSE);
426:
427: if (pager == NULL)
428: return (ENOMEM);
429: /*
430: * Set credentials:
431: * FIXME: if we're writing the file we need a way to
432: * ensure that someone doesn't replace our R/W creds
433: * with ones that only work for read.
434: */
435: vmp = vp->v_vm_info;
436: if (vmp->cred == NULL) {
437: crhold(p->p_ucred);
438: vmp->cred = p->p_ucred;
439: }
440: docow = FALSE;
441: if ((flags & (MAP_ANON|MAP_SHARED)) == 0) {
442: docow = TRUE;
443: }
444:
445: #ifdef notyet
446: /* Hmm .. */
447: #if defined(VM_PROT_READ_IS_EXEC)
448: if (prot & VM_PROT_READ)
449: prot |= VM_PROT_EXECUTE;
450:
451: if (maxprot & VM_PROT_READ)
452: maxprot |= VM_PROT_EXECUTE;
453: #endif
454: #endif /* notyet */
455:
456: result = vm_map(user_map, &user_addr, user_size,
457: 0, find_space, pager, file_pos, docow,
458: prot, maxprot,
459: VM_INHERIT_DEFAULT);
460:
461: if (result != KERN_SUCCESS)
462: goto out;
463:
464: }
465:
466: if (flags & (MAP_SHARED|MAP_INHERIT)) {
467: result = vm_inherit(user_map, user_addr, user_size,
468: VM_INHERIT_SHARE);
469: if (result != KERN_SUCCESS) {
470: (void) vm_deallocate(user_map, user_addr, user_size);
471: goto out;
472: }
473: }
474:
475: out:
476: switch (result) {
477: case KERN_SUCCESS:
478: if(!mapanon) {
479: *fdflags(p, uap->fd) |= UF_MAPPED;
480: if (ISMAPPABLEFILE(vp))
481: vp->v_vm_info->mapped = 1;
482: }
483: *retval = (register_t)(user_addr + pageoff);
484: return (0);
485: case KERN_INVALID_ADDRESS:
486: case KERN_NO_SPACE:
487: return (ENOMEM);
488: case KERN_PROTECTION_FAILURE:
489: return (EACCES);
490: default:
491: return (EINVAL);
492: }
493: /*NOTREACHED*/
494: }
495:
496: struct msync_args {
497: caddr_t addr;
498: int len;
499: int flags;
500: };
501: int
502: msync(p, uap, retval)
503: struct proc *p;
504: struct msync_args *uap;
505: register_t *retval;
506: {
507: vm_offset_t addr;
508: vm_size_t size, pageoff;
509: int flags;
510: vm_map_t user_map;
511: int rv;
512: vm_sync_t sync_flags=0;
513:
514: addr = (vm_offset_t) uap->addr;
515: pageoff = (addr & PAGE_MASK);
516: addr -= pageoff;
517: size = uap->len;
518: size = (vm_size_t) round_page(size);
519: flags = uap->flags;
520:
521: if (addr + size < addr)
522: return(EINVAL);
523:
524: user_map = current_map();
525:
526: if ((flags & (MS_ASYNC|MS_INVALIDATE)) == (MS_ASYNC|MS_INVALIDATE))
527: return (EINVAL);
528:
529: #ifdef notyet
530: /* XXX Gak! If size is zero we are supposed to sync "all modified
531: * pages with the region containing addr". Unfortunately, we don't
532: * really keep track of individual mmaps so we approximate by flushing
533: * the range of the map entry containing addr. This can be incorrect
534: * if the region splits or is coalesced with a neighbor.
535: */
536: if (size == 0) {
537: vm_map_entry_t entry;
538:
539: vm_map_lock_read(map);
540: rv = vm_map_lookup_entry(map, addr, &entry);
541: vm_map_unlock_read(map);
542: if (rv == FALSE)
543: return (EINVAL);
544: addr = entry->start;
545: size = entry->end - entry->start;
546: }
547: #endif /* notyet */
548:
549: if (flags & MS_ASYNC)
550: sync_flags |= VM_SYNC_ASYNCHRONOUS;
551: else
552: sync_flags |= VM_SYNC_SYNCHRONOUS;
553:
554: if (flags & MS_INVALIDATE)
555: sync_flags |= VM_SYNC_INVALIDATE;
556:
557: rv = vm_msync(user_map, addr, size, sync_flags);
558:
559: switch (rv) {
560: case KERN_SUCCESS:
561: break;
562: case KERN_INVALID_ADDRESS:
563: return (EINVAL); /* Sun returns ENOMEM? */
564: case KERN_FAILURE:
565: return (EIO);
566: default:
567: return (EINVAL);
568: }
569:
570: return (0);
571:
572: }
573:
574:
575: mremap()
576: {
577: /* Not yet implemented */
578: return (EOPNOTSUPP);
579: }
580:
581: struct munmap_args {
582: caddr_t addr;
583: int len;
584: };
585: munmap(p, uap, retval)
586: struct proc *p;
587: struct munmap_args *uap;
588: register_t *retval;
589:
590: {
591: vm_offset_t user_addr;
592: vm_size_t user_size, pageoff;
593: kern_return_t result;
594:
595: user_addr = (vm_offset_t) uap->addr;
596: user_size = (vm_size_t) uap->len;
597:
598: pageoff = (user_addr & PAGE_MASK);
599:
600: user_addr -= pageoff;
601: user_size += pageoff;
602: user_size = round_page(user_size);
603: if (user_addr + user_size < user_addr)
604: return(EINVAL);
605:
606: if (user_size == 0)
607: return (0);
608:
609: /* Address range must be all in user VM space. */
610: if (VM_MAX_ADDRESS > 0 && (user_addr + user_size > VM_MAX_ADDRESS))
611: return (EINVAL);
612: if (VM_MIN_ADDRESS > 0 && user_addr < VM_MIN_ADDRESS)
613: return (EINVAL);
614:
615:
616: result = vm_deallocate(current_map(), user_addr, user_size);
617: if (result != KERN_SUCCESS) {
618: return(EINVAL);
619: }
620: return(0);
621: }
622:
623: void
624: munmapfd(p, fd)
625: struct proc *p;
626: int fd;
627: {
628: /*
629: * XXX should vm_deallocate any regions mapped to this file
630: */
631: *fdflags(p, fd) &= ~UF_MAPPED;
632: }
633:
634: struct mprotect_args {
635: caddr_t addr;
636: int len;
637: int prot;
638: };
639: int
640: mprotect(p, uap, retval)
641: struct proc *p;
642: struct mprotect_args *uap;
643: register_t *retval;
644: {
645: register vm_prot_t prot;
646: vm_offset_t user_addr;
647: vm_size_t user_size, pageoff;
648: kern_return_t result;
649: vm_map_t user_map;
650:
651: user_addr = (vm_offset_t) uap->addr;
652: user_size = (vm_size_t) uap->len;
653: prot = (vm_prot_t)(uap->prot & VM_PROT_ALL);
654:
655: #ifdef notyet
656: /* Hmm .. */
657: #if defined(VM_PROT_READ_IS_EXEC)
658: if (prot & VM_PROT_READ)
659: prot |= VM_PROT_EXECUTE;
660: #endif
661: #endif /* notyet */
662:
663: pageoff = (user_addr & PAGE_MASK);
664: user_addr -= pageoff;
665: user_size += pageoff;
666: user_size = round_page(user_size);
667: if (user_addr + user_size < user_addr)
668: return(EINVAL);
669:
670: user_map = current_map();
671:
672: result = vm_map_protect(user_map, user_addr, user_addr+user_size, prot,
673: FALSE);
674: switch (result) {
675: case KERN_SUCCESS:
676: return (0);
677: case KERN_PROTECTION_FAILURE:
678: return (EACCES);
679: }
680: return (EINVAL);
681: }
682:
683:
684: struct minherit_args {
685: void *addr;
686: size_t len;
687: int inherit;
688: };
689:
690: int
691: minherit(p, uap, retval)
692: struct proc *p;
693: struct minherit_args *uap;
694: register_t *retval;
695: {
696: vm_offset_t addr;
697: vm_size_t size, pageoff;
698: register vm_inherit_t inherit;
699: vm_map_t user_map;
700: kern_return_t result;
701:
702: addr = (vm_offset_t)uap->addr;
703: size = uap->len;
704: inherit = uap->inherit;
705:
706: pageoff = (addr & PAGE_MASK);
707: addr -= pageoff;
708: size += pageoff;
709: size = (vm_size_t) round_page(size);
710: if (addr + size < addr)
711: return(EINVAL);
712:
713: user_map = current_map();
714: result = vm_inherit(user_map, addr, size,
715: inherit);
716: switch (result) {
717: case KERN_SUCCESS:
718: return (0);
719: case KERN_PROTECTION_FAILURE:
720: return (EACCES);
721: }
722: return (EINVAL);
723: }
724:
725: struct madvise_args {
726: caddr_t addr;
727: int len;
728: int behav;
729: };
730: /* ARGSUSED */
731: int
732: madvise(p, uap, retval)
733: struct proc *p;
734: struct madvise_args *uap;
735: register_t *retval;
736: {
737: vm_map_t user_map;
738: vm_offset_t start, end;
739: vm_behavior_t new_behavior;
740: kern_return_t result;
741:
742: /*
743: * Check for illegal addresses. Watch out for address wrap... Note
744: * that VM_*_ADDRESS are not constants due to casts (argh).
745: */
746: if (VM_MAX_ADDRESS > 0 &&
747: ((vm_offset_t) uap->addr + uap->len) > VM_MAX_ADDRESS)
748: return (EINVAL);
749: if (VM_MIN_ADDRESS > 0 && uap->addr < VM_MIN_ADDRESS)
750: return (EINVAL);
751:
752: if (((vm_offset_t) uap->addr + uap->len) < (vm_offset_t) uap->addr)
753: return (EINVAL);
754:
755: /*
756: * Since this routine is only advisory, we default to conservative
757: * behavior.
758: */
759: start = trunc_page((vm_offset_t) uap->addr);
760: end = round_page((vm_offset_t) uap->addr + uap->len);
761:
762: user_map = current_map();
763:
764: switch (uap->behav) {
765: case MADV_RANDOM:
766: new_behavior = VM_BEHAVIOR_RANDOM;
767: case MADV_SEQUENTIAL:
768: new_behavior = VM_BEHAVIOR_SEQUENTIAL;
769: case MADV_NORMAL:
770: default:
771: new_behavior = VM_BEHAVIOR_DEFAULT;
772: }
773:
774: result = vm_behavior_set(user_map, start, end, uap->behav);
775: switch (result) {
776: case KERN_SUCCESS:
777: return (0);
778: case KERN_INVALID_ADDRESS:
779: return (EINVAL);
780: }
781:
782: return (EINVAL);
783: }
784:
785: struct mincore_args {
786: const void *addr;
787: size_t len;
788: char *vec;
789: };
790: /* ARGSUSED */
791: int
792: mincore(p, uap, retval)
793: struct proc *p;
794: struct mincore_args *uap;
795: register_t *retval;
796: {
797: vm_offset_t addr, first_addr;
798: vm_offset_t end;
799: vm_map_t map;
800: char *vec;
801: int error;
802: int vecindex, lastvecindex;
803: int mincoreinfo=0;
804: int pqueryinfo;
805: kern_return_t ret;
806: int numref;
807:
808: map = current_map();
809:
810: /*
811: * Make sure that the addresses presented are valid for user
812: * mode.
813: */
814: first_addr = addr = trunc_page((vm_offset_t) uap->addr);
815: end = addr + (vm_size_t)round_page(uap->len);
816:
817: if (VM_MAX_ADDRESS > 0 && end > VM_MAX_ADDRESS)
818: return (EINVAL);
819: if (end < addr)
820: return (EINVAL);
821:
822: /*
823: * Address of byte vector
824: */
825: vec = uap->vec;
826:
827: map = current_map();
828:
829: /*
830: * Do this on a map entry basis so that if the pages are not
831: * in the current processes address space, we can easily look
832: * up the pages elsewhere.
833: */
834: lastvecindex = -1;
835: for(addr; addr < end; addr += PAGE_SIZE) {
836: pqueryinfo = 0;
837: ret = vm_map_page_query(map, addr, &pqueryinfo, &numref);
838: if (ret != KERN_SUCCESS)
839: pqueryinfo = 0;
840: mincoreinfo = 0;
841: if (pqueryinfo & VM_PAGE_QUERY_PAGE_PRESENT)
842: mincoreinfo |= MINCORE_INCORE;
843: if (pqueryinfo & VM_PAGE_QUERY_PAGE_REF)
844: mincoreinfo |= MINCORE_REFERENCED;
845: if (pqueryinfo & VM_PAGE_QUERY_PAGE_DIRTY)
846: mincoreinfo |= MINCORE_MODIFIED;
847:
848:
849: /*
850: * calculate index into user supplied byte vector
851: */
852: vecindex = (addr - first_addr)>> PAGE_SHIFT;
853:
854: /*
855: * If we have skipped map entries, we need to make sure that
856: * the byte vector is zeroed for those skipped entries.
857: */
858: while((lastvecindex + 1) < vecindex) {
859: error = subyte( vec + lastvecindex, 0);
860: if (error) {
861: return (EFAULT);
862: }
863: ++lastvecindex;
864: }
865:
866: /*
867: * Pass the page information to the user
868: */
869: error = subyte( vec + vecindex, mincoreinfo);
870: if (error) {
871: return (EFAULT);
872: }
873: lastvecindex = vecindex;
874: }
875:
876:
877: /*
878: * Zero the last entries in the byte vector.
879: */
880: vecindex = (end - first_addr) >> PAGE_SHIFT;
881: while((lastvecindex + 1) < vecindex) {
882: error = subyte( vec + lastvecindex, 0);
883: if (error) {
884: return (EFAULT);
885: }
886: ++lastvecindex;
887: }
888:
889: return (0);
890: }
891:
892: struct mlock_args {
893: caddr_t addr;
894: size_t len;
895: };
896:
897: #define BSD_DUMMY_HOST 1
898:
899: int
900: mlock(p, uap, retval)
901: struct proc *p;
902: struct mlock_args *uap;
903: register_t *retval;
904: {
905: vm_map_t user_map;
906: vm_offset_t addr;
907: vm_size_t size, pageoff;
908: int error;
909: kern_return_t result;
910:
911: addr = (vm_offset_t) uap->addr;
912: size = uap->len;
913:
914: pageoff = (addr & PAGE_MASK);
915: addr -= pageoff;
916: size += pageoff;
917: size = (vm_size_t) round_page(size);
918:
919: /* disable wrap around */
920: if (addr + size < addr)
921: return (EINVAL);
922: #ifdef notyet
923: /* Hmm.. What am I going to do with this? */
924: if (atop(size) + cnt.v_wire_count > vm_page_max_wired)
925: return (EAGAIN);
926: #ifdef pmap_wired_count
927: if (size + ptoa(pmap_wired_count(vm_map_pmap(&p->p_vmspace->vm_map))) >
928: p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur)
929: return (ENOMEM);
930: #else
931: error = suser(p->p_ucred, &p->p_acflag);
932: if (error)
933: return (error);
934: #endif
935: #endif /* notyet */
936:
937: user_map = current_map();
938:
939: /* vm_wire */
940: result = vm_wire(BSD_DUMMY_HOST, user_map, addr, size, VM_PROT_ALL);
941: return (result == KERN_SUCCESS ? 0 : ENOMEM);
942: }
943:
944: struct munlock_args {
945: caddr_t addr;
946: size_t len;
947: };
948: int
949: munlock(p, uap, retval)
950: struct proc *p;
951: struct munlock_args *uap;
952: register_t *retval;
953: {
954: vm_offset_t addr;
955: vm_size_t size, pageoff;
956: int error;
957: vm_map_t user_map;
958: kern_return_t result;
959:
960: addr = (vm_offset_t) uap->addr;
961: size = uap->len;
962:
963: pageoff = (addr & PAGE_MASK);
964: addr -= pageoff;
965: size += pageoff;
966: size = (vm_size_t) round_page(size);
967:
968: /* disable wrap around */
969: if (addr + size < addr)
970: return (EINVAL);
971:
972: #ifdef notyet
973: /* Hmm.. What am I going to do with this? */
974: #ifndef pmap_wired_count
975: error = suser(p->p_ucred, &p->p_acflag);
976: if (error)
977: return (error);
978: #endif
979: #endif /* notyet */
980:
981: user_map = current_map();
982:
983: /* vm_wire */
984: result = vm_wire(BSD_DUMMY_HOST, user_map, addr, size, VM_PROT_NONE);
985: return (result == KERN_SUCCESS ? 0 : ENOMEM);
986: }
987:
988:
989: struct mlockall_args {
990: int how;
991: };
992:
993: int
994: mlockall(p, uap)
995: struct proc *p;
996: struct mlockall_args *uap;
997: {
998: return 0;
999: }
1000:
1001: struct munlockall_args {
1002: int how;
1003: };
1004:
1005: int
1006: munlockall(p, uap)
1007: struct proc *p;
1008: struct munlockall_args *uap;
1009: {
1010: return 0;
1011: }
1012:
1013:
1014: /* BEGIN DEFUNCT */
1015: struct obreak_args {
1016: char *nsiz;
1017: };
1018: obreak(p, uap, retval)
1019: struct proc *p;
1020: struct obreak_args *uap;
1021: register_t *retval;
1022: {
1023: /* Not implemented, obsolete */
1024: return (ENOMEM);
1025: }
1026:
1027: int both;
1028:
1029: ovadvise()
1030: {
1031:
1032: #ifdef lint
1033: both = 0;
1034: #endif
1035: }
1036: /* END DEFUNCT */
1037: #if 1
1038: int print_map_addr=0;
1039: #endif /* 1 */
1040:
1041: kern_return_t map_fd(
1042: int fd,
1043: vm_offset_t offset,
1044: vm_offset_t *va,
1045: boolean_t findspace,
1046: vm_size_t size)
1047: {
1048: kern_return_t ret;
1049: boolean_t funnel_state;
1050:
1051: funnel_state = thread_set_funneled(TRUE);
1052:
1053: ret = map_fd_funneled( fd, offset, va, findspace, size);
1054:
1055: (void) thread_set_funneled(funnel_state);
1056:
1057: return ret;
1058: }
1059:
1060: kern_return_t map_fd_funneled(
1061: int fd,
1062: vm_offset_t offset,
1063: vm_offset_t *va,
1064: boolean_t findspace,
1065: vm_size_t size)
1066: {
1067: kern_return_t result;
1068: struct file *fp;
1069: struct vnode *vp;
1070: void * pager;
1071: vm_offset_t map_addr=0;
1072: vm_size_t map_size;
1073: vm_map_copy_t tmp;
1074: int err=0;
1075: vm_map_t my_map;
1076: struct proc *p =(struct proc *)(get_bsdtask_info(current_task()));
1077: #if 0
1078: extern int print_map_addr;
1079: #endif /* 0 */
1080:
1081: /*
1082: * Find the inode; verify that it's a regular file.
1083: */
1084:
1085: err = fdgetf(p, fd, &fp);
1086: if (err)
1087: return(err);
1088:
1089: if (fp->f_type != DTYPE_VNODE)
1090: return(KERN_INVALID_ARGUMENT);
1091: vp = (struct vnode *)fp->f_data;
1092:
1093: if (vp->v_type != VREG)
1094: return (KERN_INVALID_ARGUMENT);
1095:
1096: map_size = round_page(size);
1097:
1098: /*
1099: * Allow user to map in a zero length file.
1100: */
1101: if (size == 0)
1102: return (KERN_SUCCESS);
1103: /*
1104: * Map in the file.
1105: */
1106: if (!vp->v_vm_info) {
1107: vm_info_init(vp);
1108: }
1109:
1110: pager = (void *) vnode_pager_setup(vp, vp->v_vm_info->pager, FALSE, TRUE);
1111: if (pager == NULL)
1112: return (KERN_FAILURE);
1113:
1114:
1115: my_map = current_map();
1116:
1117: result = vm_map(
1118: my_map,
1119: &map_addr, map_size, (vm_offset_t)0, TRUE,
1120: pager, offset, TRUE,
1121: VM_PROT_DEFAULT, VM_PROT_ALL,
1122: VM_INHERIT_DEFAULT);
1123: if (result != KERN_SUCCESS)
1124: return (result);
1125:
1126:
1127: if (!findspace) {
1128: vm_offset_t dst_addr;
1129: vm_map_copy_t tmp;
1130:
1131: if (copyin(va, &dst_addr, sizeof (dst_addr)) ||
1132: trunc_page(dst_addr) != dst_addr) {
1133: (void) vm_map_remove(
1134: my_map,
1135: map_addr, map_addr + map_size,
1136: VM_MAP_NO_FLAGS);
1137: return (KERN_INVALID_ADDRESS);
1138: }
1139:
1140: result = vm_map_copyin(
1141: my_map,
1142: map_addr, map_size, TRUE,
1143: &tmp);
1144: if (result != KERN_SUCCESS) {
1145:
1146: (void) vm_map_remove(
1147: my_map,
1148: map_addr, map_addr + map_size,
1149: VM_MAP_NO_FLAGS);
1150: return (result);
1151: }
1152:
1153: result = vm_map_copy_overwrite(
1154: my_map,
1155: dst_addr, tmp, FALSE);
1156: if (result != KERN_SUCCESS) {
1157: vm_map_copy_discard(tmp);
1158: return (result);
1159: }
1160: }
1161: else {
1162: if (copyout(&map_addr, va, sizeof (map_addr))) {
1163: (void) vm_map_remove(
1164: my_map,
1165: map_addr, map_addr + map_size,
1166: VM_MAP_NO_FLAGS);
1167: return (KERN_INVALID_ADDRESS);
1168: }
1169: }
1170: if (ISMAPPABLEFILE(vp))
1171: vp->v_vm_info->mapped = 1;
1172:
1173: /*
1174: * Set credentials.
1175: */
1176: if (vp->v_vm_info->cred == NULL) {
1177: crhold(current_proc()->p_ucred);
1178: vp->v_vm_info->cred = current_proc()->p_ucred;
1179: }
1180:
1181: return (KERN_SUCCESS);
1182: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.