4 * Copyright (c) 1991, 1993
5 * The Regents of the University of California. All rights reserved.
7 * This code is derived from software contributed to Berkeley by
8 * The Mach Operating System project at Carnegie-Mellon University.
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: @(#)vm_kern.c 8.3 (Berkeley) 1/12/94
41 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
42 * All rights reserved.
44 * Authors: Avadis Tevanian, Jr., Michael Wayne Young
46 * Permission to use, copy, modify and distribute this software and
47 * its documentation is hereby granted, provided that both the copyright
48 * notice and this permission notice appear in all copies of the
49 * software, derivative works or modified versions, and any portions
50 * thereof, and that both notices appear in supporting documentation.
52 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
53 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
54 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
56 * Carnegie Mellon requests users of this software to return to
58 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
59 * School of Computer Science
60 * Carnegie Mellon University
61 * Pittsburgh PA 15213-3890
63 * any improvements or extensions that they make and grant Carnegie the
64 * rights to redistribute these changes.
66 * $FreeBSD: src/sys/vm/vm_kern.c,v 1.61.2.2 2002/03/12 18:25:26 tegge Exp $
67 * $DragonFly: src/sys/vm/vm_kern.c,v 1.29 2007/06/07 23:14:29 dillon Exp $
71 * Kernel memory management.
74 #include <sys/param.h>
75 #include <sys/systm.h>
77 #include <sys/malloc.h>
78 #include <sys/kernel.h>
79 #include <sys/sysctl.h>
82 #include <vm/vm_param.h>
85 #include <vm/vm_map.h>
86 #include <vm/vm_object.h>
87 #include <vm/vm_page.h>
88 #include <vm/vm_pageout.h>
89 #include <vm/vm_kern.h>
90 #include <vm/vm_extern.h>
92 struct vm_map kernel_map;
93 struct vm_map clean_map;
94 struct vm_map buffer_map;
97 * Allocate pageable memory to the kernel's address map. "map" must
98 * be kernel_map or a submap of kernel_map.
103 kmem_alloc_pageable(vm_map_t map, vm_size_t size)
108 size = round_page(size);
109 addr = vm_map_min(map);
110 result = vm_map_find(map, NULL, (vm_offset_t) 0,
111 &addr, size, PAGE_SIZE,
112 TRUE, VM_MAPTYPE_NORMAL,
113 VM_PROT_ALL, VM_PROT_ALL,
115 if (result != KERN_SUCCESS)
121 * Same as kmem_alloc_pageable, except that it create a nofault entry.
126 kmem_alloc_nofault(vm_map_t map, vm_size_t size, vm_size_t align)
131 size = round_page(size);
132 addr = vm_map_min(map);
133 result = vm_map_find(map, NULL, (vm_offset_t) 0,
135 TRUE, VM_MAPTYPE_NORMAL,
136 VM_PROT_ALL, VM_PROT_ALL,
138 if (result != KERN_SUCCESS)
144 * Allocate wired-down memory in the kernel's address map or a submap.
149 kmem_alloc3(vm_map_t map, vm_size_t size, int kmflags)
157 size = round_page(size);
159 if (kmflags & KM_KRESERVE)
160 count = vm_map_entry_kreserve(MAP_RESERVE_COUNT);
162 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
164 if (kmflags & KM_STACK) {
173 * Use the kernel object for wired-down kernel pages. Assume that no
174 * region of the kernel object is referenced more than once.
176 * Locate sufficient space in the map. This will give us the final
177 * virtual address for the new memory, and thus will tell us the
178 * offset within the kernel map.
181 if (vm_map_findspace(map, vm_map_min(map), size, PAGE_SIZE, 0, &addr)) {
183 if (kmflags & KM_KRESERVE)
184 vm_map_entry_krelease(count);
186 vm_map_entry_release(count);
189 vm_object_hold(&kernel_object);
190 vm_object_reference_locked(&kernel_object);
191 vm_map_insert(map, &count,
192 &kernel_object, addr, addr, addr + size,
194 VM_PROT_ALL, VM_PROT_ALL,
196 vm_object_drop(&kernel_object);
199 if (kmflags & KM_KRESERVE)
200 vm_map_entry_krelease(count);
202 vm_map_entry_release(count);
205 * Guarantee that there are pages already in this object before
206 * calling vm_map_wire. This is to prevent the following
209 * 1) Threads have swapped out, so that there is a pager for the
210 * kernel_object. 2) The kmsg zone is empty, and so we are
211 * kmem_allocing a new page for it. 3) vm_map_wire calls vm_fault;
212 * there is no page, but there is a pager, so we call
213 * pager_data_request. But the kmsg zone is empty, so we must
214 * kmem_alloc. 4) goto 1 5) Even if the kmsg zone is not empty: when
215 * we get the data back from the pager, it will be (very stale)
216 * non-zero data. kmem_alloc is defined to return zero-filled memory.
218 * We're intentionally not activating the pages we allocate to prevent a
219 * race with page-out. vm_map_wire will wire the pages.
221 vm_object_hold(&kernel_object);
222 for (i = gstart; i < size; i += PAGE_SIZE) {
225 mem = vm_page_grab(&kernel_object, OFF_TO_IDX(addr + i),
226 VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
227 if ((mem->flags & PG_ZERO) == 0)
228 vm_page_zero_fill(mem);
229 mem->valid = VM_PAGE_BITS_ALL;
230 vm_page_flag_clear(mem, PG_ZERO);
233 vm_object_drop(&kernel_object);
236 * And finally, mark the data as non-pageable.
238 * NOTE: vm_map_wire() handles any kstack guard.
240 vm_map_wire(map, (vm_offset_t)addr, addr + size, kmflags);
246 * Release a region of kernel virtual memory allocated with kmem_alloc,
247 * and return the physical pages associated with that region.
249 * WARNING! If the caller entered pages into the region using pmap_kenter()
250 * it must remove the pages using pmap_kremove[_quick]() before freeing the
251 * underlying kmem, otherwise resident_count will be mistabulated.
256 kmem_free(vm_map_t map, vm_offset_t addr, vm_size_t size)
258 vm_map_remove(map, trunc_page(addr), round_page(addr + size));
262 * Used to break a system map into smaller maps, usually to reduce
263 * contention and to provide large KVA spaces for subsystems like the
266 * parent Map to take range from
268 * size Size of range to find
269 * min, max Returned endpoints of map
270 * pageable Can the region be paged
275 kmem_suballoc(vm_map_t parent, vm_map_t result,
276 vm_offset_t *min, vm_offset_t *max, vm_size_t size)
280 size = round_page(size);
282 *min = (vm_offset_t) vm_map_min(parent);
283 ret = vm_map_find(parent, NULL, (vm_offset_t) 0,
284 min, size, PAGE_SIZE,
285 TRUE, VM_MAPTYPE_UNSPECIFIED,
286 VM_PROT_ALL, VM_PROT_ALL,
288 if (ret != KERN_SUCCESS) {
289 kprintf("kmem_suballoc: bad status return of %d.\n", ret);
290 panic("kmem_suballoc");
293 pmap_reference(vm_map_pmap(parent));
294 vm_map_init(result, *min, *max, vm_map_pmap(parent));
295 if ((ret = vm_map_submap(parent, *min, *max, result)) != KERN_SUCCESS)
296 panic("kmem_suballoc: unable to change range to submap");
300 * Allocates pageable memory from a sub-map of the kernel. If the submap
301 * has no room, the caller sleeps waiting for more memory in the submap.
306 kmem_alloc_wait(vm_map_t map, vm_size_t size)
311 size = round_page(size);
313 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
317 * To make this work for more than one map, use the map's lock
318 * to lock out sleepers/wakers.
321 if (vm_map_findspace(map, vm_map_min(map),
322 size, PAGE_SIZE, 0, &addr) == 0) {
325 /* no space now; see if we can ever get space */
326 if (vm_map_max(map) - vm_map_min(map) < size) {
327 vm_map_entry_release(count);
332 tsleep(map, 0, "kmaw", 0);
334 vm_map_insert(map, &count,
335 NULL, (vm_offset_t) 0,
338 VM_PROT_ALL, VM_PROT_ALL,
341 vm_map_entry_release(count);
347 * Returns memory to a submap of the kernel, and wakes up any processes
348 * waiting for memory in that map.
353 kmem_free_wakeup(vm_map_t map, vm_offset_t addr, vm_size_t size)
357 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
359 vm_map_delete(map, trunc_page(addr), round_page(addr + size), &count);
362 vm_map_entry_release(count);
366 * Create the kernel_ma for (KvaStart,KvaEnd) and insert mappings to
367 * cover areas already allocated or reserved thus far.
369 * The areas (virtual_start, virtual_end) and (virtual2_start, virtual2_end)
370 * are available so the cutouts are the areas around these ranges between
371 * KvaStart and KvaEnd.
373 * Depend on the zalloc bootstrap cache to get our vm_map_entry_t.
374 * Called from the low level boot code only.
383 m = vm_map_create(&kernel_map, &kernel_pmap, KvaStart, KvaEnd);
385 /* N.B.: cannot use kgdb to debug, starting with this assignment ... */
387 count = vm_map_entry_reserve(MAP_RESERVE_COUNT);
389 if (virtual2_start) {
390 if (addr < virtual2_start) {
391 vm_map_insert(m, &count, NULL, (vm_offset_t) 0,
392 addr, virtual2_start,
394 VM_PROT_ALL, VM_PROT_ALL,
399 if (addr < virtual_start) {
400 vm_map_insert(m, &count, NULL, (vm_offset_t) 0,
403 VM_PROT_ALL, VM_PROT_ALL,
408 vm_map_insert(m, &count, NULL, (vm_offset_t) 0,
411 VM_PROT_ALL, VM_PROT_ALL,
414 /* ... and ending with the completion of the above `insert' */
416 vm_map_entry_release(count);
423 kvm_size(SYSCTL_HANDLER_ARGS)
425 unsigned long ksize = KvaSize;
427 return sysctl_handle_long(oidp, &ksize, 0, req);
429 SYSCTL_PROC(_vm, OID_AUTO, kvm_size, CTLTYPE_ULONG|CTLFLAG_RD,
430 0, 0, kvm_size, "LU", "Size of KVM");
436 kvm_free(SYSCTL_HANDLER_ARGS)
438 unsigned long kfree = virtual_end - kernel_vm_end;
440 return sysctl_handle_long(oidp, &kfree, 0, req);
442 SYSCTL_PROC(_vm, OID_AUTO, kvm_free, CTLTYPE_ULONG|CTLFLAG_RD,
443 0, 0, kvm_free, "LU", "Amount of KVM free");