2 * Copyright (c) 1988 University of Utah.
3 * Copyright (c) 1991, 1993
4 * The Regents of the University of California. All rights reserved.
6 * This code is derived from software contributed to Berkeley by
7 * the Systems Programming Group of the University of Utah Computer
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * from: Utah $Hdr: vm_mmap.c 1.6 91/10/21$
40 * @(#)vm_mmap.c 8.4 (Berkeley) 1/12/94
41 * $FreeBSD: src/sys/vm/vm_mmap.c,v 1.108.2.6 2002/07/02 20:06:19 dillon Exp $
42 * $DragonFly: src/sys/vm/vm_mmap.c,v 1.39 2007/04/30 07:18:57 dillon Exp $
46 * Mapped file (mmap) interface to VM
49 #include <sys/param.h>
50 #include <sys/kernel.h>
51 #include <sys/systm.h>
52 #include <sys/sysproto.h>
53 #include <sys/filedesc.h>
54 #include <sys/kern_syscall.h>
57 #include <sys/resource.h>
58 #include <sys/resourcevar.h>
59 #include <sys/vnode.h>
60 #include <sys/fcntl.h>
65 #include <sys/vmmeter.h>
66 #include <sys/sysctl.h>
69 #include <vm/vm_param.h>
72 #include <vm/vm_map.h>
73 #include <vm/vm_object.h>
74 #include <vm/vm_page.h>
75 #include <vm/vm_pager.h>
76 #include <vm/vm_pageout.h>
77 #include <vm/vm_extern.h>
78 #include <vm/vm_page.h>
79 #include <vm/vm_kern.h>
81 #include <sys/file2.h>
82 #include <sys/thread2.h>
83 #include <sys/mplock2.h>
85 static int max_proc_mmap
;
86 SYSCTL_INT(_vm
, OID_AUTO
, max_proc_mmap
, CTLFLAG_RW
, &max_proc_mmap
, 0, "");
88 SYSCTL_INT(_vm
, OID_AUTO
, vkernel_enable
, CTLFLAG_RW
, &vkernel_enable
, 0, "");
91 * Set the maximum number of vm_map_entry structures per process. Roughly
92 * speaking vm_map_entry structures are tiny, so allowing them to eat 1/100
93 * of our KVM malloc space still results in generous limits. We want a
94 * default that is good enough to prevent the kernel running out of resources
95 * if attacked from compromised user account but generous enough such that
96 * multi-threaded processes are not unduly inconvenienced.
99 static void vmmapentry_rsrc_init (void *);
100 SYSINIT(vmmersrc
, SI_BOOT1_POST
, SI_ORDER_ANY
, vmmapentry_rsrc_init
, NULL
)
103 vmmapentry_rsrc_init(void *dummy
)
105 max_proc_mmap
= KvaSize
/ sizeof(struct vm_map_entry
);
106 max_proc_mmap
/= 100;
113 sys_sbrk(struct sbrk_args
*uap
)
115 /* Not yet implemented */
120 * sstk_args(int incr)
125 sys_sstk(struct sstk_args
*uap
)
127 /* Not yet implemented */
132 * mmap_args(void *addr, size_t len, int prot, int flags, int fd,
133 * long pad, off_t pos)
135 * Memory Map (mmap) system call. Note that the file offset
136 * and address are allowed to be NOT page aligned, though if
137 * the MAP_FIXED flag it set, both must have the same remainder
138 * modulo the PAGE_SIZE (POSIX 1003.1b). If the address is not
139 * page-aligned, the actual mapping starts at trunc_page(addr)
140 * and the return value is adjusted up by the page offset.
142 * Generally speaking, only character devices which are themselves
143 * memory-based, such as a video framebuffer, can be mmap'd. Otherwise
144 * there would be no cache coherency between a descriptor and a VM mapping
145 * both to the same character device.
147 * Block devices can be mmap'd no matter what they represent. Cache coherency
148 * is maintained as long as you do not write directly to the underlying
153 kern_mmap(struct vmspace
*vms
, caddr_t uaddr
, size_t ulen
,
154 int uprot
, int uflags
, int fd
, off_t upos
, void **res
)
156 struct thread
*td
= curthread
;
157 struct proc
*p
= td
->td_proc
;
158 struct file
*fp
= NULL
;
162 vm_size_t size
, pageoff
;
163 vm_prot_t prot
, maxprot
;
166 int disablexworkaround
;
172 addr
= (vm_offset_t
) uaddr
;
174 prot
= uprot
& VM_PROT_ALL
;
179 * Make sure mapping fits into numeric range etc.
181 * NOTE: We support the full unsigned range for size now.
183 if (((flags
& MAP_ANON
) && fd
!= -1))
186 if (flags
& MAP_STACK
) {
188 ((prot
& (PROT_READ
| PROT_WRITE
)) != (PROT_READ
| PROT_WRITE
)))
195 * Virtual page tables cannot be used with MAP_STACK. Apart from
196 * it not making any sense, the aux union is used by both
199 * Because the virtual page table is stored in the backing object
200 * and might be updated by the kernel, the mapping must be R+W.
202 if (flags
& MAP_VPAGETABLE
) {
203 if (vkernel_enable
== 0)
205 if (flags
& MAP_STACK
)
207 if ((prot
& (PROT_READ
|PROT_WRITE
)) != (PROT_READ
|PROT_WRITE
))
212 * Align the file position to a page boundary,
213 * and save its page offset component.
215 pageoff
= (pos
& PAGE_MASK
);
218 /* Adjust size for rounding (on both ends). */
219 size
+= pageoff
; /* low end... */
220 size
= (vm_size_t
) round_page(size
); /* hi end */
221 if (size
< ulen
) /* wrap */
225 * Check for illegal addresses. Watch out for address wrap... Note
226 * that VM_*_ADDRESS are not constants due to casts (argh).
228 if (flags
& (MAP_FIXED
| MAP_TRYFIXED
)) {
230 * The specified address must have the same remainder
231 * as the file offset taken modulo PAGE_SIZE, so it
232 * should be aligned after adjustment by pageoff.
235 if (addr
& PAGE_MASK
)
239 * Address range must be all in user VM space and not wrap.
241 tmpaddr
= addr
+ size
;
244 if (VM_MAX_USER_ADDRESS
> 0 && tmpaddr
> VM_MAX_USER_ADDRESS
)
246 if (VM_MIN_USER_ADDRESS
> 0 && addr
< VM_MIN_USER_ADDRESS
)
250 * Set a reasonable start point for the hint if it was
251 * not specified or if it falls within the heap space.
252 * Hinted mmap()s do not allocate out of the heap space.
255 (addr
>= round_page((vm_offset_t
)vms
->vm_taddr
) &&
256 addr
< round_page((vm_offset_t
)vms
->vm_daddr
+ maxdsiz
)))
257 addr
= round_page((vm_offset_t
)vms
->vm_daddr
+ maxdsiz
);
260 if (flags
& MAP_ANON
) {
262 * Mapping blank space is trivial.
265 maxprot
= VM_PROT_ALL
;
269 * Mapping file, get fp for validation. Obtain vnode and make
270 * sure it is of appropriate type.
272 fp
= holdfp(p
->p_fd
, fd
, -1);
275 if (fp
->f_type
!= DTYPE_VNODE
) {
280 * POSIX shared-memory objects are defined to have
281 * kernel persistence, and are not defined to support
282 * read(2)/write(2) -- or even open(2). Thus, we can
283 * use MAP_ASYNC to trade on-disk coherence for speed.
284 * The shm_open(3) library routine turns on the FPOSIXSHM
285 * flag to request this behavior.
287 if (fp
->f_flag
& FPOSIXSHM
)
289 vp
= (struct vnode
*) fp
->f_data
;
292 * Validate the vnode for the operation.
297 * Get the proper underlying object
299 if ((obj
= vp
->v_object
) == NULL
) {
303 KKASSERT((struct vnode
*)obj
->handle
== vp
);
307 * Make sure a device has not been revoked.
308 * Mappability is handled by the device layer.
310 if (vp
->v_rdev
== NULL
) {
317 * Nothing else is mappable.
324 * XXX hack to handle use of /dev/zero to map anon memory (ala
327 if (vp
->v_type
== VCHR
&& iszerodev(vp
->v_rdev
)) {
329 maxprot
= VM_PROT_ALL
;
334 * cdevs does not provide private mappings of any kind.
337 * However, for XIG X server to continue to work,
338 * we should allow the superuser to do it anyway.
339 * We only allow it at securelevel < 1.
340 * (Because the XIG X server writes directly to video
341 * memory via /dev/mem, it should never work at any
343 * XXX this will have to go
345 if (securelevel
>= 1)
346 disablexworkaround
= 1;
348 disablexworkaround
= priv_check(td
, PRIV_ROOT
);
349 if (vp
->v_type
== VCHR
&& disablexworkaround
&&
350 (flags
& (MAP_PRIVATE
|MAP_COPY
))) {
355 * Ensure that file and memory protections are
356 * compatible. Note that we only worry about
357 * writability if mapping is shared; in this case,
358 * current and max prot are dictated by the open file.
359 * XXX use the vnode instead? Problem is: what
360 * credentials do we use for determination? What if
361 * proc does a setuid?
363 maxprot
= VM_PROT_EXECUTE
; /* ??? */
364 if (fp
->f_flag
& FREAD
) {
365 maxprot
|= VM_PROT_READ
;
366 } else if (prot
& PROT_READ
) {
371 * If we are sharing potential changes (either via
372 * MAP_SHARED or via the implicit sharing of character
373 * device mappings), and we are trying to get write
374 * permission although we opened it without asking
375 * for it, bail out. Check for superuser, only if
376 * we're at securelevel < 1, to allow the XIG X server
377 * to continue to work.
380 if ((flags
& MAP_SHARED
) != 0 ||
381 (vp
->v_type
== VCHR
&& disablexworkaround
)) {
382 if ((fp
->f_flag
& FWRITE
) != 0) {
384 if ((error
= VOP_GETATTR(vp
, &va
))) {
388 (IMMUTABLE
|APPEND
)) == 0) {
389 maxprot
|= VM_PROT_WRITE
;
390 } else if (prot
& PROT_WRITE
) {
394 } else if ((prot
& PROT_WRITE
) != 0) {
399 maxprot
|= VM_PROT_WRITE
;
406 * Do not allow more then a certain number of vm_map_entry structures
407 * per process. Scale with the number of rforks sharing the map
408 * to make the limit reasonable for threads.
411 vms
->vm_map
.nentries
>= max_proc_mmap
* vms
->vm_sysref
.refcnt
) {
416 error
= vm_mmap(&vms
->vm_map
, &addr
, size
, prot
, maxprot
,
419 *res
= (void *)(addr
+ pageoff
);
430 sys_mmap(struct mmap_args
*uap
)
435 error
= kern_mmap(curproc
->p_vmspace
, uap
->addr
, uap
->len
,
436 uap
->prot
, uap
->flags
,
437 uap
->fd
, uap
->pos
, &uap
->sysmsg_resultp
);
444 * msync_args(void *addr, size_t len, int flags)
449 sys_msync(struct msync_args
*uap
)
451 struct proc
*p
= curproc
;
454 vm_size_t size
, pageoff
;
459 addr
= (vm_offset_t
) uap
->addr
;
463 pageoff
= (addr
& PAGE_MASK
);
466 size
= (vm_size_t
) round_page(size
);
467 if (size
< uap
->len
) /* wrap */
469 tmpaddr
= addr
+ size
; /* workaround gcc4 opt */
470 if (tmpaddr
< addr
) /* wrap */
473 if ((flags
& (MS_ASYNC
|MS_INVALIDATE
)) == (MS_ASYNC
|MS_INVALIDATE
))
477 map
= &p
->p_vmspace
->vm_map
;
480 * XXX Gak! If size is zero we are supposed to sync "all modified
481 * pages with the region containing addr". Unfortunately, we don't
482 * really keep track of individual mmaps so we approximate by flushing
483 * the range of the map entry containing addr. This can be incorrect
484 * if the region splits or is coalesced with a neighbor.
487 vm_map_entry_t entry
;
489 vm_map_lock_read(map
);
490 rv
= vm_map_lookup_entry(map
, addr
, &entry
);
492 vm_map_unlock_read(map
);
493 rv
= KERN_INVALID_ADDRESS
;
497 size
= entry
->end
- entry
->start
;
498 vm_map_unlock_read(map
);
502 * Clean the pages and interpret the return value.
504 rv
= vm_map_clean(map
, addr
, addr
+ size
, (flags
& MS_ASYNC
) == 0,
505 (flags
& MS_INVALIDATE
) != 0);
512 case KERN_INVALID_ADDRESS
:
513 return (EINVAL
); /* Sun returns ENOMEM? */
524 * munmap_args(void *addr, size_t len)
529 sys_munmap(struct munmap_args
*uap
)
531 struct proc
*p
= curproc
;
534 vm_size_t size
, pageoff
;
537 addr
= (vm_offset_t
) uap
->addr
;
540 pageoff
= (addr
& PAGE_MASK
);
543 size
= (vm_size_t
) round_page(size
);
544 if (size
< uap
->len
) /* wrap */
546 tmpaddr
= addr
+ size
; /* workaround gcc4 opt */
547 if (tmpaddr
< addr
) /* wrap */
554 * Check for illegal addresses. Watch out for address wrap... Note
555 * that VM_*_ADDRESS are not constants due to casts (argh).
557 if (VM_MAX_USER_ADDRESS
> 0 && tmpaddr
> VM_MAX_USER_ADDRESS
)
559 if (VM_MIN_USER_ADDRESS
> 0 && addr
< VM_MIN_USER_ADDRESS
)
563 map
= &p
->p_vmspace
->vm_map
;
565 * Make sure entire range is allocated.
567 if (!vm_map_check_protection(map
, addr
, addr
+ size
, VM_PROT_NONE
)) {
571 /* returns nothing but KERN_SUCCESS anyway */
572 vm_map_remove(map
, addr
, addr
+ size
);
578 * mprotect_args(const void *addr, size_t len, int prot)
583 sys_mprotect(struct mprotect_args
*uap
)
585 struct proc
*p
= curproc
;
588 vm_size_t size
, pageoff
;
592 addr
= (vm_offset_t
) uap
->addr
;
594 prot
= uap
->prot
& VM_PROT_ALL
;
595 #if defined(VM_PROT_READ_IS_EXEC)
596 if (prot
& VM_PROT_READ
)
597 prot
|= VM_PROT_EXECUTE
;
600 pageoff
= (addr
& PAGE_MASK
);
603 size
= (vm_size_t
) round_page(size
);
604 if (size
< uap
->len
) /* wrap */
606 tmpaddr
= addr
+ size
; /* workaround gcc4 opt */
607 if (tmpaddr
< addr
) /* wrap */
611 switch (vm_map_protect(&p
->p_vmspace
->vm_map
, addr
, addr
+ size
,
616 case KERN_PROTECTION_FAILURE
:
628 * minherit_args(void *addr, size_t len, int inherit)
633 sys_minherit(struct minherit_args
*uap
)
635 struct proc
*p
= curproc
;
638 vm_size_t size
, pageoff
;
639 vm_inherit_t inherit
;
642 addr
= (vm_offset_t
)uap
->addr
;
644 inherit
= uap
->inherit
;
646 pageoff
= (addr
& PAGE_MASK
);
649 size
= (vm_size_t
) round_page(size
);
650 if (size
< uap
->len
) /* wrap */
652 tmpaddr
= addr
+ size
; /* workaround gcc4 opt */
653 if (tmpaddr
< addr
) /* wrap */
658 switch (vm_map_inherit(&p
->p_vmspace
->vm_map
, addr
,
659 addr
+ size
, inherit
)) {
663 case KERN_PROTECTION_FAILURE
:
675 * madvise_args(void *addr, size_t len, int behav)
680 sys_madvise(struct madvise_args
*uap
)
682 struct proc
*p
= curproc
;
683 vm_offset_t start
, end
;
684 vm_offset_t tmpaddr
= (vm_offset_t
)uap
->addr
+ uap
->len
;
688 * Check for illegal behavior
690 if (uap
->behav
< 0 || uap
->behav
>= MADV_CONTROL_END
)
693 * Check for illegal addresses. Watch out for address wrap... Note
694 * that VM_*_ADDRESS are not constants due to casts (argh).
696 if (tmpaddr
< (vm_offset_t
)uap
->addr
)
698 if (VM_MAX_USER_ADDRESS
> 0 && tmpaddr
> VM_MAX_USER_ADDRESS
)
700 if (VM_MIN_USER_ADDRESS
> 0 && uap
->addr
< VM_MIN_USER_ADDRESS
)
704 * Since this routine is only advisory, we default to conservative
707 start
= trunc_page((vm_offset_t
)uap
->addr
);
708 end
= round_page(tmpaddr
);
711 error
= vm_map_madvise(&p
->p_vmspace
->vm_map
, start
, end
,
718 * mcontrol_args(void *addr, size_t len, int behav, off_t value)
723 sys_mcontrol(struct mcontrol_args
*uap
)
725 struct proc
*p
= curproc
;
726 vm_offset_t start
, end
;
727 vm_offset_t tmpaddr
= (vm_offset_t
)uap
->addr
+ uap
->len
;
731 * Check for illegal behavior
733 if (uap
->behav
< 0 || uap
->behav
> MADV_CONTROL_END
)
736 * Check for illegal addresses. Watch out for address wrap... Note
737 * that VM_*_ADDRESS are not constants due to casts (argh).
739 if (tmpaddr
< (vm_offset_t
) uap
->addr
)
741 if (VM_MAX_USER_ADDRESS
> 0 && tmpaddr
> VM_MAX_USER_ADDRESS
)
743 if (VM_MIN_USER_ADDRESS
> 0 && uap
->addr
< VM_MIN_USER_ADDRESS
)
747 * Since this routine is only advisory, we default to conservative
750 start
= trunc_page((vm_offset_t
)uap
->addr
);
751 end
= round_page(tmpaddr
);
754 error
= vm_map_madvise(&p
->p_vmspace
->vm_map
, start
, end
,
755 uap
->behav
, uap
->value
);
762 * mincore_args(const void *addr, size_t len, char *vec)
767 sys_mincore(struct mincore_args
*uap
)
769 struct proc
*p
= curproc
;
770 vm_offset_t addr
, first_addr
;
771 vm_offset_t end
, cend
;
776 int vecindex
, lastvecindex
;
777 vm_map_entry_t current
;
778 vm_map_entry_t entry
;
780 unsigned int timestamp
;
783 * Make sure that the addresses presented are valid for user
786 first_addr
= addr
= trunc_page((vm_offset_t
) uap
->addr
);
787 end
= addr
+ (vm_size_t
)round_page(uap
->len
);
790 if (VM_MAX_USER_ADDRESS
> 0 && end
> VM_MAX_USER_ADDRESS
)
794 * Address of byte vector
798 map
= &p
->p_vmspace
->vm_map
;
799 pmap
= vmspace_pmap(p
->p_vmspace
);
802 vm_map_lock_read(map
);
804 timestamp
= map
->timestamp
;
806 if (!vm_map_lookup_entry(map
, addr
, &entry
))
810 * Do this on a map entry basis so that if the pages are not
811 * in the current processes address space, we can easily look
812 * up the pages elsewhere.
816 (current
!= &map
->header
) && (current
->start
< end
);
817 current
= current
->next
) {
820 * ignore submaps (for now) or null objects
822 if (current
->maptype
!= VM_MAPTYPE_NORMAL
&&
823 current
->maptype
!= VM_MAPTYPE_VPAGETABLE
) {
826 if (current
->object
.vm_object
== NULL
)
830 * limit this scan to the current map entry and the
831 * limits for the mincore call
833 if (addr
< current
->start
)
834 addr
= current
->start
;
840 * scan this entry one page at a time
842 while (addr
< cend
) {
844 * Check pmap first, it is likely faster, also
845 * it can provide info as to whether we are the
846 * one referencing or modifying the page.
848 * If we have to check the VM object, only mess
849 * around with normal maps. Do not mess around
850 * with virtual page tables (XXX).
852 mincoreinfo
= pmap_mincore(pmap
, addr
);
853 if (mincoreinfo
== 0 &&
854 current
->maptype
== VM_MAPTYPE_NORMAL
) {
860 * calculate the page index into the object
862 offset
= current
->offset
+ (addr
- current
->start
);
863 pindex
= OFF_TO_IDX(offset
);
866 * if the page is resident, then gather
867 * information about it. spl protection is
868 * required to maintain the object
869 * association. And XXX what if the page is
870 * busy? What's the deal with that?
873 m
= vm_page_lookup(current
->object
.vm_object
,
876 mincoreinfo
= MINCORE_INCORE
;
879 mincoreinfo
|= MINCORE_MODIFIED_OTHER
;
880 if ((m
->flags
& PG_REFERENCED
) ||
881 pmap_ts_referenced(m
)) {
882 vm_page_flag_set(m
, PG_REFERENCED
);
883 mincoreinfo
|= MINCORE_REFERENCED_OTHER
;
890 * subyte may page fault. In case it needs to modify
891 * the map, we release the lock.
893 vm_map_unlock_read(map
);
896 * calculate index into user supplied byte vector
898 vecindex
= OFF_TO_IDX(addr
- first_addr
);
901 * If we have skipped map entries, we need to make sure that
902 * the byte vector is zeroed for those skipped entries.
904 while((lastvecindex
+ 1) < vecindex
) {
905 error
= subyte( vec
+ lastvecindex
, 0);
914 * Pass the page information to the user
916 error
= subyte( vec
+ vecindex
, mincoreinfo
);
923 * If the map has changed, due to the subyte, the previous
924 * output may be invalid.
926 vm_map_lock_read(map
);
927 if (timestamp
!= map
->timestamp
)
930 lastvecindex
= vecindex
;
936 * subyte may page fault. In case it needs to modify
937 * the map, we release the lock.
939 vm_map_unlock_read(map
);
942 * Zero the last entries in the byte vector.
944 vecindex
= OFF_TO_IDX(end
- first_addr
);
945 while((lastvecindex
+ 1) < vecindex
) {
946 error
= subyte( vec
+ lastvecindex
, 0);
955 * If the map has changed, due to the subyte, the previous
956 * output may be invalid.
958 vm_map_lock_read(map
);
959 if (timestamp
!= map
->timestamp
)
961 vm_map_unlock_read(map
);
970 * mlock_args(const void *addr, size_t len)
975 sys_mlock(struct mlock_args
*uap
)
979 vm_size_t size
, pageoff
;
980 struct thread
*td
= curthread
;
981 struct proc
*p
= td
->td_proc
;
984 addr
= (vm_offset_t
) uap
->addr
;
987 pageoff
= (addr
& PAGE_MASK
);
990 size
= (vm_size_t
) round_page(size
);
991 if (size
< uap
->len
) /* wrap */
993 tmpaddr
= addr
+ size
; /* workaround gcc4 opt */
994 if (tmpaddr
< addr
) /* wrap */
997 if (atop(size
) + vmstats
.v_wire_count
> vm_page_max_wired
)
1001 #ifdef pmap_wired_count
1002 if (size
+ ptoa(pmap_wired_count(vm_map_pmap(&p
->p_vmspace
->vm_map
))) >
1003 p
->p_rlimit
[RLIMIT_MEMLOCK
].rlim_cur
) {
1008 error
= priv_check_cred(td
->td_ucred
, PRIV_ROOT
, 0);
1014 error
= vm_map_unwire(&p
->p_vmspace
->vm_map
, addr
, addr
+ size
, FALSE
);
1016 return (error
== KERN_SUCCESS
? 0 : ENOMEM
);
1020 * mlockall_args(int how)
1022 * Dummy routine, doesn't actually do anything.
1027 sys_mlockall(struct mlockall_args
*uap
)
1033 * munlockall_args(void)
1035 * Dummy routine, doesn't actually do anything.
1040 sys_munlockall(struct munlockall_args
*uap
)
1046 * munlock_args(const void *addr, size_t len)
1051 sys_munlock(struct munlock_args
*uap
)
1053 struct thread
*td
= curthread
;
1054 struct proc
*p
= td
->td_proc
;
1056 vm_offset_t tmpaddr
;
1057 vm_size_t size
, pageoff
;
1060 addr
= (vm_offset_t
) uap
->addr
;
1063 pageoff
= (addr
& PAGE_MASK
);
1066 size
= (vm_size_t
) round_page(size
);
1068 tmpaddr
= addr
+ size
;
1069 if (tmpaddr
< addr
) /* wrap */
1072 #ifndef pmap_wired_count
1073 error
= priv_check(td
, PRIV_ROOT
);
1079 error
= vm_map_unwire(&p
->p_vmspace
->vm_map
, addr
, addr
+ size
, TRUE
);
1081 return (error
== KERN_SUCCESS
? 0 : ENOMEM
);
1085 * Internal version of mmap.
1086 * Currently used by mmap, exec, and sys5 shared memory.
1087 * Handle is either a vnode pointer or NULL for MAP_ANON.
1090 vm_mmap(vm_map_t map
, vm_offset_t
*addr
, vm_size_t size
, vm_prot_t prot
,
1091 vm_prot_t maxprot
, int flags
, void *handle
, vm_ooffset_t foff
)
1098 struct thread
*td
= curthread
;
1101 int rv
= KERN_SUCCESS
;
1108 objsize
= round_page(size
);
1114 * XXX messy code, fixme
1116 * NOTE: Overflow checks require discrete statements or GCC4
1117 * will optimize it out.
1119 if ((p
= curproc
) != NULL
&& map
== &p
->p_vmspace
->vm_map
) {
1120 esize
= map
->size
+ size
; /* workaround gcc4 opt */
1121 if (esize
< map
->size
||
1122 esize
> p
->p_rlimit
[RLIMIT_VMEM
].rlim_cur
) {
1128 * We currently can only deal with page aligned file offsets.
1129 * The check is here rather than in the syscall because the
1130 * kernel calls this function internally for other mmaping
1131 * operations (such as in exec) and non-aligned offsets will
1132 * cause pmap inconsistencies...so we want to be sure to
1133 * disallow this in all cases.
1135 * NOTE: Overflow checks require discrete statements or GCC4
1136 * will optimize it out.
1138 if (foff
& PAGE_MASK
)
1141 if ((flags
& (MAP_FIXED
| MAP_TRYFIXED
)) == 0) {
1143 *addr
= round_page(*addr
);
1145 if (*addr
!= trunc_page(*addr
))
1147 eaddr
= *addr
+ size
;
1151 if ((flags
& MAP_TRYFIXED
) == 0)
1152 vm_map_remove(map
, *addr
, *addr
+ size
);
1156 * Lookup/allocate object.
1158 if (flags
& MAP_ANON
) {
1159 type
= OBJT_DEFAULT
;
1161 * Unnamed anonymous regions always start at 0.
1167 vp
= (struct vnode
*)handle
;
1168 if (vp
->v_type
== VCHR
) {
1170 handle
= (void *)(intptr_t)vp
->v_rdev
;
1175 error
= VOP_GETATTR(vp
, &vat
);
1178 objsize
= vat
.va_size
;
1181 * if it is a regular file without any references
1182 * we do not need to sync it.
1184 if (vp
->v_type
== VREG
&& vat
.va_nlink
== 0) {
1185 flags
|= MAP_NOSYNC
;
1190 if (handle
== NULL
) {
1194 object
= vm_pager_allocate(type
, handle
, objsize
, prot
, foff
);
1196 return (type
== OBJT_DEVICE
? EINVAL
: ENOMEM
);
1197 docow
= MAP_PREFAULT_PARTIAL
;
1201 * Force device mappings to be shared.
1203 if (type
== OBJT_DEVICE
|| type
== OBJT_PHYS
) {
1204 flags
&= ~(MAP_PRIVATE
|MAP_COPY
);
1205 flags
|= MAP_SHARED
;
1208 if ((flags
& (MAP_ANON
|MAP_SHARED
)) == 0)
1209 docow
|= MAP_COPY_ON_WRITE
;
1210 if (flags
& MAP_NOSYNC
)
1211 docow
|= MAP_DISABLE_SYNCER
;
1212 if (flags
& MAP_NOCORE
)
1213 docow
|= MAP_DISABLE_COREDUMP
;
1215 #if defined(VM_PROT_READ_IS_EXEC)
1216 if (prot
& VM_PROT_READ
)
1217 prot
|= VM_PROT_EXECUTE
;
1219 if (maxprot
& VM_PROT_READ
)
1220 maxprot
|= VM_PROT_EXECUTE
;
1224 * This may place the area in its own page directory if (size) is
1225 * large enough, otherwise it typically returns its argument.
1228 *addr
= pmap_addr_hint(object
, *addr
, size
);
1232 * Stack mappings need special attention.
1234 * Mappings that use virtual page tables will default to storing
1235 * the page table at offset 0.
1237 if (flags
& MAP_STACK
) {
1238 rv
= vm_map_stack(map
, *addr
, size
, flags
,
1239 prot
, maxprot
, docow
);
1240 } else if (flags
& MAP_VPAGETABLE
) {
1241 rv
= vm_map_find(map
, object
, foff
, addr
, size
, fitit
,
1242 VM_MAPTYPE_VPAGETABLE
, prot
, maxprot
, docow
);
1244 rv
= vm_map_find(map
, object
, foff
, addr
, size
, fitit
,
1245 VM_MAPTYPE_NORMAL
, prot
, maxprot
, docow
);
1248 if (rv
!= KERN_SUCCESS
) {
1250 * Lose the object reference. Will destroy the
1251 * object if it's an unnamed anonymous mapping
1252 * or named anonymous without other references.
1254 vm_object_deallocate(object
);
1259 * Shared memory is also shared with children.
1261 if (flags
& (MAP_SHARED
|MAP_INHERIT
)) {
1262 rv
= vm_map_inherit(map
, *addr
, *addr
+ size
, VM_INHERIT_SHARE
);
1263 if (rv
!= KERN_SUCCESS
) {
1264 vm_map_remove(map
, *addr
, *addr
+ size
);
1270 * Set the access time on the vnode
1273 vn_mark_atime(vp
, td
);
1278 case KERN_INVALID_ADDRESS
:
1281 case KERN_PROTECTION_FAILURE
: