#include <cpus.h>
#include <task_swapper.h>
#include <mach_assert.h>
#include <mach/kern_return.h>
#include <mach/port.h>
#include <mach/vm_attributes.h>
#include <mach/vm_param.h>
#include <mach/vm_behavior.h>
#include <kern/assert.h>
#include <kern/counters.h>
#include <kern/zalloc.h>
#include <vm/vm_init.h>
#include <vm/vm_fault.h>
#include <vm/vm_map.h>
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <vm/vm_kern.h>
#include <ipc/ipc_port.h>
#include <kern/sched_prim.h>
#include <kern/misc_protos.h>
#include <mach/vm_map_server.h>
#include <mach/mach_host_server.h>
#include <ddb/tr.h>
#include <machine/db_machdep.h>
#include <kern/xpr.h>
extern boolean_t vm_map_range_check(
vm_map_t map,
vm_offset_t start,
vm_offset_t end,
vm_map_entry_t *entry);
extern vm_map_entry_t _vm_map_entry_create(
struct vm_map_header *map_header);
extern void _vm_map_entry_dispose(
struct vm_map_header *map_header,
vm_map_entry_t entry);
extern void vm_map_pmap_enter(
vm_map_t map,
vm_offset_t addr,
vm_offset_t end_addr,
vm_object_t object,
vm_object_offset_t offset,
vm_prot_t protection);
extern void _vm_map_clip_end(
struct vm_map_header *map_header,
vm_map_entry_t entry,
vm_offset_t end);
extern void vm_map_entry_delete(
vm_map_t map,
vm_map_entry_t entry);
extern kern_return_t vm_map_delete(
vm_map_t map,
vm_offset_t start,
vm_offset_t end,
int flags);
extern void vm_map_copy_steal_pages(
vm_map_copy_t copy);
extern kern_return_t vm_map_copy_overwrite_unaligned(
vm_map_t dst_map,
vm_map_entry_t entry,
vm_map_copy_t copy,
vm_offset_t start);
extern kern_return_t vm_map_copy_overwrite_aligned(
vm_map_t dst_map,
vm_map_entry_t tmp_entry,
vm_map_copy_t copy,
vm_offset_t start,
pmap_t pmap);
extern kern_return_t vm_map_copyin_kernel_buffer(
vm_map_t src_map,
vm_offset_t src_addr,
vm_size_t len,
boolean_t src_destroy,
vm_map_copy_t *copy_result);
extern kern_return_t vm_map_copyout_kernel_buffer(
vm_map_t map,
vm_offset_t *addr,
vm_map_copy_t copy,
boolean_t overwrite);
extern void vm_map_fork_share(
vm_map_t old_map,
vm_map_entry_t old_entry,
vm_map_t new_map);
extern boolean_t vm_map_fork_copy(
vm_map_t old_map,
vm_map_entry_t *old_entry_p,
vm_map_t new_map);
extern kern_return_t vm_remap_range_allocate(
vm_map_t map,
vm_offset_t *address,
vm_size_t size,
vm_offset_t mask,
boolean_t anywhere,
vm_map_entry_t *map_entry);
extern void _vm_map_clip_start(
struct vm_map_header *map_header,
vm_map_entry_t entry,
vm_offset_t start);
void vm_region_top_walk(
vm_map_entry_t entry,
vm_region_top_info_t top);
void vm_region_walk(
vm_map_entry_t entry,
vm_region_extended_info_t extended,
vm_object_offset_t offset,
vm_offset_t range,
vm_map_t map,
vm_offset_t va);
#define vm_map_entry_copy(NEW,OLD) \
MACRO_BEGIN \
*(NEW) = *(OLD); \
(NEW)->is_shared = FALSE; \
(NEW)->needs_wakeup = FALSE; \
(NEW)->in_transition = FALSE; \
(NEW)->wired_count = 0; \
(NEW)->user_wired_count = 0; \
MACRO_END
#define vm_map_entry_copy_full(NEW,OLD) (*(NEW) = *(OLD))
zone_t vm_map_zone;
zone_t vm_map_entry_zone;
zone_t vm_map_kentry_zone;
zone_t vm_map_copy_zone;
vm_object_t vm_submap_object;
vm_offset_t map_data;
vm_size_t map_data_size;
vm_offset_t kentry_data;
vm_size_t kentry_data_size;
int kentry_count = 2048;
#define NO_COALESCE_LIMIT (1024 * 128)
vm_size_t vm_map_aggressive_enter_max;
void
vm_map_init(
void)
{
vm_map_zone = zinit((vm_size_t) sizeof(struct vm_map), 40*1024,
PAGE_SIZE, "maps");
vm_map_entry_zone = zinit((vm_size_t) sizeof(struct vm_map_entry),
1024*1024, PAGE_SIZE*5,
"non-kernel map entries");
vm_map_kentry_zone = zinit((vm_size_t) sizeof(struct vm_map_entry),
kentry_data_size, kentry_data_size,
"kernel map entries");
vm_map_copy_zone = zinit((vm_size_t) sizeof(struct vm_map_copy),
16*1024, PAGE_SIZE, "map copies");
zone_change(vm_map_zone, Z_COLLECT, FALSE);
zone_change(vm_map_kentry_zone, Z_COLLECT, FALSE);
zone_change(vm_map_kentry_zone, Z_EXPAND, FALSE);
zcram(vm_map_zone, map_data, map_data_size);
zcram(vm_map_kentry_zone, kentry_data, kentry_data_size);
}
void
vm_map_steal_memory(
void)
{
map_data_size = round_page_32(10 * sizeof(struct vm_map));
map_data = pmap_steal_memory(map_data_size);
#if 0
#endif
kentry_count = pmap_free_pages() / 8;
kentry_data_size =
round_page_32(kentry_count * sizeof(struct vm_map_entry));
kentry_data = pmap_steal_memory(kentry_data_size);
}
vm_map_t
vm_map_create(
pmap_t pmap,
vm_offset_t min,
vm_offset_t max,
boolean_t pageable)
{
register vm_map_t result;
result = (vm_map_t) zalloc(vm_map_zone);
if (result == VM_MAP_NULL)
panic("vm_map_create");
vm_map_first_entry(result) = vm_map_to_entry(result);
vm_map_last_entry(result) = vm_map_to_entry(result);
result->hdr.nentries = 0;
result->hdr.entries_pageable = pageable;
result->size = 0;
result->ref_count = 1;
#if TASK_SWAPPER
result->res_count = 1;
result->sw_state = MAP_SW_IN;
#endif
result->pmap = pmap;
result->min_offset = min;
result->max_offset = max;
result->wiring_required = FALSE;
result->no_zero_fill = FALSE;
result->mapped = FALSE;
result->wait_for_space = FALSE;
result->first_free = vm_map_to_entry(result);
result->hint = vm_map_to_entry(result);
vm_map_lock_init(result);
mutex_init(&result->s_lock, ETAP_VM_RESULT);
return(result);
}
#define vm_map_entry_create(map) \
_vm_map_entry_create(&(map)->hdr)
#define vm_map_copy_entry_create(copy) \
_vm_map_entry_create(&(copy)->cpy_hdr)
vm_map_entry_t
_vm_map_entry_create(
register struct vm_map_header *map_header)
{
register zone_t zone;
register vm_map_entry_t entry;
if (map_header->entries_pageable)
zone = vm_map_entry_zone;
else
zone = vm_map_kentry_zone;
entry = (vm_map_entry_t) zalloc(zone);
if (entry == VM_MAP_ENTRY_NULL)
panic("vm_map_entry_create");
return(entry);
}
#define vm_map_entry_dispose(map, entry) \
MACRO_BEGIN \
if((entry) == (map)->first_free) \
(map)->first_free = vm_map_to_entry(map); \
if((entry) == (map)->hint) \
(map)->hint = vm_map_to_entry(map); \
_vm_map_entry_dispose(&(map)->hdr, (entry)); \
MACRO_END
#define vm_map_copy_entry_dispose(map, entry) \
_vm_map_entry_dispose(&(copy)->cpy_hdr, (entry))
void
_vm_map_entry_dispose(
register struct vm_map_header *map_header,
register vm_map_entry_t entry)
{
register zone_t zone;
if (map_header->entries_pageable)
zone = vm_map_entry_zone;
else
zone = vm_map_kentry_zone;
zfree(zone, (vm_offset_t) entry);
}
boolean_t first_free_is_valid(vm_map_t map);
boolean_t first_free_check = FALSE;
boolean_t
first_free_is_valid(
vm_map_t map)
{
vm_map_entry_t entry, next;
if (!first_free_check)
return TRUE;
entry = vm_map_to_entry(map);
next = entry->vme_next;
while (trunc_page_32(next->vme_start) == trunc_page_32(entry->vme_end) ||
(trunc_page_32(next->vme_start) == trunc_page_32(entry->vme_start) &&
next != vm_map_to_entry(map))) {
entry = next;
next = entry->vme_next;
if (entry == vm_map_to_entry(map))
break;
}
if (map->first_free != entry) {
printf("Bad first_free for map 0x%x: 0x%x should be 0x%x\n",
map, map->first_free, entry);
return FALSE;
}
return TRUE;
}
#define UPDATE_FIRST_FREE(map, new_first_free) \
MACRO_BEGIN \
vm_map_t UFF_map; \
vm_map_entry_t UFF_first_free; \
vm_map_entry_t UFF_next_entry; \
UFF_map = (map); \
UFF_first_free = (new_first_free); \
UFF_next_entry = UFF_first_free->vme_next; \
while (trunc_page_32(UFF_next_entry->vme_start) == \
trunc_page_32(UFF_first_free->vme_end) || \
(trunc_page_32(UFF_next_entry->vme_start) == \
trunc_page_32(UFF_first_free->vme_start) && \
UFF_next_entry != vm_map_to_entry(UFF_map))) { \
UFF_first_free = UFF_next_entry; \
UFF_next_entry = UFF_first_free->vme_next; \
if (UFF_first_free == vm_map_to_entry(UFF_map)) \
break; \
} \
UFF_map->first_free = UFF_first_free; \
assert(first_free_is_valid(UFF_map)); \
MACRO_END
#define vm_map_entry_link(map, after_where, entry) \
MACRO_BEGIN \
vm_map_t VMEL_map; \
vm_map_entry_t VMEL_entry; \
VMEL_map = (map); \
VMEL_entry = (entry); \
_vm_map_entry_link(&VMEL_map->hdr, after_where, VMEL_entry); \
UPDATE_FIRST_FREE(VMEL_map, VMEL_map->first_free); \
MACRO_END
#define vm_map_copy_entry_link(copy, after_where, entry) \
_vm_map_entry_link(&(copy)->cpy_hdr, after_where, (entry))
#define _vm_map_entry_link(hdr, after_where, entry) \
MACRO_BEGIN \
(hdr)->nentries++; \
(entry)->vme_prev = (after_where); \
(entry)->vme_next = (after_where)->vme_next; \
(entry)->vme_prev->vme_next = (entry)->vme_next->vme_prev = (entry); \
MACRO_END
#define vm_map_entry_unlink(map, entry) \
MACRO_BEGIN \
vm_map_t VMEU_map; \
vm_map_entry_t VMEU_entry; \
vm_map_entry_t VMEU_first_free; \
VMEU_map = (map); \
VMEU_entry = (entry); \
if (VMEU_entry->vme_start <= VMEU_map->first_free->vme_start) \
VMEU_first_free = VMEU_entry->vme_prev; \
else \
VMEU_first_free = VMEU_map->first_free; \
_vm_map_entry_unlink(&VMEU_map->hdr, VMEU_entry); \
UPDATE_FIRST_FREE(VMEU_map, VMEU_first_free); \
MACRO_END
#define vm_map_copy_entry_unlink(copy, entry) \
_vm_map_entry_unlink(&(copy)->cpy_hdr, (entry))
#define _vm_map_entry_unlink(hdr, entry) \
MACRO_BEGIN \
(hdr)->nentries--; \
(entry)->vme_next->vme_prev = (entry)->vme_prev; \
(entry)->vme_prev->vme_next = (entry)->vme_next; \
MACRO_END
#if MACH_ASSERT && TASK_SWAPPER
void vm_map_res_reference(register vm_map_t map)
{
assert(map->res_count >= 0);
assert(map->ref_count >= map->res_count);
if (map->res_count == 0) {
mutex_unlock(&map->s_lock);
vm_map_lock(map);
vm_map_swapin(map);
mutex_lock(&map->s_lock);
++map->res_count;
vm_map_unlock(map);
} else
++map->res_count;
}
void vm_map_reference_swap(register vm_map_t map)
{
assert(map != VM_MAP_NULL);
mutex_lock(&map->s_lock);
assert(map->res_count >= 0);
assert(map->ref_count >= map->res_count);
map->ref_count++;
vm_map_res_reference(map);
mutex_unlock(&map->s_lock);
}
void vm_map_res_deallocate(register vm_map_t map)
{
assert(map->res_count > 0);
if (--map->res_count == 0) {
mutex_unlock(&map->s_lock);
vm_map_lock(map);
vm_map_swapout(map);
vm_map_unlock(map);
mutex_lock(&map->s_lock);
}
assert(map->ref_count >= map->res_count);
}
#endif
void
vm_map_destroy(
register vm_map_t map)
{
vm_map_lock(map);
(void) vm_map_delete(map, map->min_offset,
map->max_offset, VM_MAP_NO_FLAGS);
vm_map_unlock(map);
if(map->pmap)
pmap_destroy(map->pmap);
zfree(vm_map_zone, (vm_offset_t) map);
}
#if TASK_SWAPPER
int vm_map_swap_enable = 1;
void vm_map_swapin (vm_map_t map)
{
register vm_map_entry_t entry;
if (!vm_map_swap_enable)
return;
if (map->sw_state == MAP_SW_IN)
return;
assert(map->res_count == 0);
assert(map->sw_state == MAP_SW_OUT);
entry = vm_map_first_entry(map);
while (entry != vm_map_to_entry(map)) {
if (entry->object.vm_object != VM_OBJECT_NULL) {
if (entry->is_sub_map) {
vm_map_t lmap = entry->object.sub_map;
mutex_lock(&lmap->s_lock);
vm_map_res_reference(lmap);
mutex_unlock(&lmap->s_lock);
} else {
vm_object_t object = entry->object.vm_object;
vm_object_lock(object);
vm_object_res_reference(object);
vm_object_unlock(object);
}
}
entry = entry->vme_next;
}
assert(map->sw_state == MAP_SW_OUT);
map->sw_state = MAP_SW_IN;
}
void vm_map_swapout(vm_map_t map)
{
register vm_map_entry_t entry;
mutex_lock(&map->s_lock);
if (map->res_count != 0) {
mutex_unlock(&map->s_lock);
return;
}
mutex_unlock(&map->s_lock);
assert(map->sw_state == MAP_SW_IN);
if (!vm_map_swap_enable)
return;
entry = vm_map_first_entry(map);
while (entry != vm_map_to_entry(map)) {
if (entry->object.vm_object != VM_OBJECT_NULL) {
if (entry->is_sub_map) {
vm_map_t lmap = entry->object.sub_map;
mutex_lock(&lmap->s_lock);
vm_map_res_deallocate(lmap);
mutex_unlock(&lmap->s_lock);
} else {
vm_object_t object = entry->object.vm_object;
vm_object_lock(object);
vm_object_res_deallocate(object);
vm_object_unlock(object);
}
}
entry = entry->vme_next;
}
assert(map->sw_state == MAP_SW_IN);
map->sw_state = MAP_SW_OUT;
}
#endif
#define SAVE_HINT(map,value) \
mutex_lock(&(map)->s_lock); \
(map)->hint = (value); \
mutex_unlock(&(map)->s_lock);
boolean_t
vm_map_lookup_entry(
register vm_map_t map,
register vm_offset_t address,
vm_map_entry_t *entry)
{
register vm_map_entry_t cur;
register vm_map_entry_t last;
mutex_lock(&map->s_lock);
cur = map->hint;
mutex_unlock(&map->s_lock);
if (cur == vm_map_to_entry(map))
cur = cur->vme_next;
if (address >= cur->vme_start) {
last = vm_map_to_entry(map);
if ((cur != last) && (cur->vme_end > address)) {
*entry = cur;
return(TRUE);
}
}
else {
last = cur->vme_next;
cur = vm_map_first_entry(map);
}
while (cur != last) {
if (cur->vme_end > address) {
if (address >= cur->vme_start) {
*entry = cur;
SAVE_HINT(map, cur);
return(TRUE);
}
break;
}
cur = cur->vme_next;
}
*entry = cur->vme_prev;
SAVE_HINT(map, *entry);
return(FALSE);
}
kern_return_t
vm_map_find_space(
register vm_map_t map,
vm_offset_t *address,
vm_size_t size,
vm_offset_t mask,
vm_map_entry_t *o_entry)
{
register vm_map_entry_t entry, new_entry;
register vm_offset_t start;
register vm_offset_t end;
new_entry = vm_map_entry_create(map);
vm_map_lock(map);
assert(first_free_is_valid(map));
if ((entry = map->first_free) == vm_map_to_entry(map))
start = map->min_offset;
else
start = entry->vme_end;
while (TRUE) {
register vm_map_entry_t next;
end = ((start + mask) & ~mask);
if (end < start) {
vm_map_entry_dispose(map, new_entry);
vm_map_unlock(map);
return(KERN_NO_SPACE);
}
start = end;
end += size;
if ((end > map->max_offset) || (end < start)) {
vm_map_entry_dispose(map, new_entry);
vm_map_unlock(map);
return(KERN_NO_SPACE);
}
next = entry->vme_next;
if (next == vm_map_to_entry(map))
break;
if (next->vme_start >= end)
break;
entry = next;
start = entry->vme_end;
}
*address = start;
new_entry->vme_start = start;
new_entry->vme_end = end;
assert(page_aligned(new_entry->vme_start));
assert(page_aligned(new_entry->vme_end));
new_entry->is_shared = FALSE;
new_entry->is_sub_map = FALSE;
new_entry->use_pmap = FALSE;
new_entry->object.vm_object = VM_OBJECT_NULL;
new_entry->offset = (vm_object_offset_t) 0;
new_entry->needs_copy = FALSE;
new_entry->inheritance = VM_INHERIT_DEFAULT;
new_entry->protection = VM_PROT_DEFAULT;
new_entry->max_protection = VM_PROT_ALL;
new_entry->behavior = VM_BEHAVIOR_DEFAULT;
new_entry->wired_count = 0;
new_entry->user_wired_count = 0;
new_entry->in_transition = FALSE;
new_entry->needs_wakeup = FALSE;
vm_map_entry_link(map, entry, new_entry);
map->size += size;
SAVE_HINT(map, new_entry);
*o_entry = new_entry;
return(KERN_SUCCESS);
}
int vm_map_pmap_enter_print = FALSE;
int vm_map_pmap_enter_enable = FALSE;
void
vm_map_pmap_enter(
vm_map_t map,
register vm_offset_t addr,
register vm_offset_t end_addr,
register vm_object_t object,
vm_object_offset_t offset,
vm_prot_t protection)
{
unsigned int cache_attr;
if(map->pmap == 0)
return;
while (addr < end_addr) {
register vm_page_t m;
vm_object_lock(object);
vm_object_paging_begin(object);
m = vm_page_lookup(object, offset);
if (m == VM_PAGE_NULL || m->busy ||
(m->unusual && ( m->error || m->restart || m->absent ||
protection & m->page_lock))) {
vm_object_paging_end(object);
vm_object_unlock(object);
return;
}
assert(!m->fictitious);
if (vm_map_pmap_enter_print) {
printf("vm_map_pmap_enter:");
printf("map: %x, addr: %x, object: %x, offset: %x\n",
map, addr, object, offset);
}
m->busy = TRUE;
if (m->no_isync == TRUE) {
pmap_sync_caches_phys(m->phys_page);
m->no_isync = FALSE;
}
cache_attr = ((unsigned int)object->wimg_bits) & VM_WIMG_MASK;
vm_object_unlock(object);
PMAP_ENTER(map->pmap, addr, m,
protection, cache_attr, FALSE);
vm_object_lock(object);
PAGE_WAKEUP_DONE(m);
vm_page_lock_queues();
if (!m->active && !m->inactive)
vm_page_activate(m);
vm_page_unlock_queues();
vm_object_paging_end(object);
vm_object_unlock(object);
offset += PAGE_SIZE_64;
addr += PAGE_SIZE;
}
}
kern_return_t
vm_map_enter(
register vm_map_t map,
vm_offset_t *address,
vm_size_t size,
vm_offset_t mask,
int flags,
vm_object_t object,
vm_object_offset_t offset,
boolean_t needs_copy,
vm_prot_t cur_protection,
vm_prot_t max_protection,
vm_inherit_t inheritance)
{
vm_map_entry_t entry;
register vm_offset_t start;
register vm_offset_t end;
kern_return_t result = KERN_SUCCESS;
boolean_t anywhere = VM_FLAGS_ANYWHERE & flags;
char alias;
VM_GET_FLAGS_ALIAS(flags, alias);
#define RETURN(value) { result = value; goto BailOut; }
assert(page_aligned(*address));
assert(page_aligned(size));
StartAgain: ;
start = *address;
if (anywhere) {
vm_map_lock(map);
if (start < map->min_offset)
start = map->min_offset;
if (start > map->max_offset)
RETURN(KERN_NO_SPACE);
assert(first_free_is_valid(map));
if (start == map->min_offset) {
if ((entry = map->first_free) != vm_map_to_entry(map))
start = entry->vme_end;
} else {
vm_map_entry_t tmp_entry;
if (vm_map_lookup_entry(map, start, &tmp_entry))
start = tmp_entry->vme_end;
entry = tmp_entry;
}
while (TRUE) {
register vm_map_entry_t next;
end = ((start + mask) & ~mask);
if (end < start)
RETURN(KERN_NO_SPACE);
start = end;
end += size;
if ((end > map->max_offset) || (end < start)) {
if (map->wait_for_space) {
if (size <= (map->max_offset -
map->min_offset)) {
assert_wait((event_t)map,
THREAD_ABORTSAFE);
vm_map_unlock(map);
thread_block((void (*)(void))0);
goto StartAgain;
}
}
RETURN(KERN_NO_SPACE);
}
next = entry->vme_next;
if (next == vm_map_to_entry(map))
break;
if (next->vme_start >= end)
break;
entry = next;
start = entry->vme_end;
}
*address = start;
} else {
vm_map_entry_t temp_entry;
vm_map_lock(map);
if ((start & mask) != 0)
RETURN(KERN_NO_SPACE);
end = start + size;
if ((start < map->min_offset) ||
(end > map->max_offset) ||
(start >= end)) {
RETURN(KERN_INVALID_ADDRESS);
}
if (vm_map_lookup_entry(map, start, &temp_entry))
RETURN(KERN_NO_SPACE);
entry = temp_entry;
if ((entry->vme_next != vm_map_to_entry(map)) &&
(entry->vme_next->vme_start < end))
RETURN(KERN_NO_SPACE);
}
if ((object == VM_OBJECT_NULL) &&
(entry != vm_map_to_entry(map)) &&
(entry->vme_end == start) &&
(!entry->is_shared) &&
(!entry->is_sub_map) &&
(entry->alias == alias) &&
(entry->inheritance == inheritance) &&
(entry->protection == cur_protection) &&
(entry->max_protection == max_protection) &&
(entry->behavior == VM_BEHAVIOR_DEFAULT) &&
(entry->in_transition == 0) &&
((entry->vme_end - entry->vme_start) + size < NO_COALESCE_LIMIT) &&
(entry->wired_count == 0)) {
if (vm_object_coalesce(entry->object.vm_object,
VM_OBJECT_NULL,
entry->offset,
(vm_object_offset_t) 0,
(vm_size_t)(entry->vme_end - entry->vme_start),
(vm_size_t)(end - entry->vme_end))) {
map->size += (end - entry->vme_end);
entry->vme_end = end;
UPDATE_FIRST_FREE(map, map->first_free);
RETURN(KERN_SUCCESS);
}
}
{
register vm_map_entry_t new_entry;
new_entry = vm_map_entry_insert(map, entry, start, end, object,
offset, needs_copy, FALSE, FALSE,
cur_protection, max_protection,
VM_BEHAVIOR_DEFAULT, inheritance, 0);
new_entry->alias = alias;
vm_map_unlock(map);
if (map->wiring_required) {
result = vm_map_wire(map, start, end,
new_entry->protection, TRUE);
return(result);
}
if ((object != VM_OBJECT_NULL) &&
(vm_map_pmap_enter_enable) &&
(!anywhere) &&
(!needs_copy) &&
(size < (128*1024))) {
vm_map_pmap_enter(map, start, end,
object, offset, cur_protection);
}
return(result);
}
BailOut: ;
vm_map_unlock(map);
return(result);
#undef RETURN
}
#ifndef i386
#define vm_map_clip_start(map, entry, startaddr) \
MACRO_BEGIN \
vm_map_t VMCS_map; \
vm_map_entry_t VMCS_entry; \
vm_offset_t VMCS_startaddr; \
VMCS_map = (map); \
VMCS_entry = (entry); \
VMCS_startaddr = (startaddr); \
if (VMCS_startaddr > VMCS_entry->vme_start) { \
if(entry->use_pmap) { \
vm_offset_t pmap_base_addr; \
\
pmap_base_addr = 0xF0000000 & entry->vme_start; \
pmap_unnest(map->pmap, (addr64_t)pmap_base_addr); \
entry->use_pmap = FALSE; \
} else if(entry->object.vm_object \
&& !entry->is_sub_map \
&& entry->object.vm_object->phys_contiguous) { \
pmap_remove(map->pmap, \
(addr64_t)(entry->vme_start), \
(addr64_t)(entry->vme_end)); \
} \
_vm_map_clip_start(&VMCS_map->hdr,VMCS_entry,VMCS_startaddr);\
} \
UPDATE_FIRST_FREE(VMCS_map, VMCS_map->first_free); \
MACRO_END
#else
#define vm_map_clip_start(map, entry, startaddr) \
MACRO_BEGIN \
vm_map_t VMCS_map; \
vm_map_entry_t VMCS_entry; \
vm_offset_t VMCS_startaddr; \
VMCS_map = (map); \
VMCS_entry = (entry); \
VMCS_startaddr = (startaddr); \
if (VMCS_startaddr > VMCS_entry->vme_start) { \
_vm_map_clip_start(&VMCS_map->hdr,VMCS_entry,VMCS_startaddr);\
} \
UPDATE_FIRST_FREE(VMCS_map, VMCS_map->first_free); \
MACRO_END
#endif
#define vm_map_copy_clip_start(copy, entry, startaddr) \
MACRO_BEGIN \
if ((startaddr) > (entry)->vme_start) \
_vm_map_clip_start(&(copy)->cpy_hdr,(entry),(startaddr)); \
MACRO_END
void
_vm_map_clip_start(
register struct vm_map_header *map_header,
register vm_map_entry_t entry,
register vm_offset_t start)
{
register vm_map_entry_t new_entry;
new_entry = _vm_map_entry_create(map_header);
vm_map_entry_copy_full(new_entry, entry);
new_entry->vme_end = start;
entry->offset += (start - entry->vme_start);
entry->vme_start = start;
_vm_map_entry_link(map_header, entry->vme_prev, new_entry);
if (entry->is_sub_map)
vm_map_reference(new_entry->object.sub_map);
else
vm_object_reference(new_entry->object.vm_object);
}
#ifndef i386
#define vm_map_clip_end(map, entry, endaddr) \
MACRO_BEGIN \
vm_map_t VMCE_map; \
vm_map_entry_t VMCE_entry; \
vm_offset_t VMCE_endaddr; \
VMCE_map = (map); \
VMCE_entry = (entry); \
VMCE_endaddr = (endaddr); \
if (VMCE_endaddr < VMCE_entry->vme_end) { \
if(entry->use_pmap) { \
vm_offset_t pmap_base_addr; \
\
pmap_base_addr = 0xF0000000 & entry->vme_start; \
pmap_unnest(map->pmap, (addr64_t)pmap_base_addr); \
entry->use_pmap = FALSE; \
} else if(entry->object.vm_object \
&& !entry->is_sub_map \
&& entry->object.vm_object->phys_contiguous) { \
pmap_remove(map->pmap, \
(addr64_t)(entry->vme_start), \
(addr64_t)(entry->vme_end)); \
} \
_vm_map_clip_end(&VMCE_map->hdr,VMCE_entry,VMCE_endaddr); \
} \
UPDATE_FIRST_FREE(VMCE_map, VMCE_map->first_free); \
MACRO_END
#else
#define vm_map_clip_end(map, entry, endaddr) \
MACRO_BEGIN \
vm_map_t VMCE_map; \
vm_map_entry_t VMCE_entry; \
vm_offset_t VMCE_endaddr; \
VMCE_map = (map); \
VMCE_entry = (entry); \
VMCE_endaddr = (endaddr); \
if (VMCE_endaddr < VMCE_entry->vme_end) { \
_vm_map_clip_end(&VMCE_map->hdr,VMCE_entry,VMCE_endaddr); \
} \
UPDATE_FIRST_FREE(VMCE_map, VMCE_map->first_free); \
MACRO_END
#endif
#define vm_map_copy_clip_end(copy, entry, endaddr) \
MACRO_BEGIN \
if ((endaddr) < (entry)->vme_end) \
_vm_map_clip_end(&(copy)->cpy_hdr,(entry),(endaddr)); \
MACRO_END
void
_vm_map_clip_end(
register struct vm_map_header *map_header,
register vm_map_entry_t entry,
register vm_offset_t end)
{
register vm_map_entry_t new_entry;
new_entry = _vm_map_entry_create(map_header);
vm_map_entry_copy_full(new_entry, entry);
new_entry->vme_start = entry->vme_end = end;
new_entry->offset += (end - entry->vme_start);
_vm_map_entry_link(map_header, entry, new_entry);
if (entry->is_sub_map)
vm_map_reference(new_entry->object.sub_map);
else
vm_object_reference(new_entry->object.vm_object);
}
#define VM_MAP_RANGE_CHECK(map, start, end) \
{ \
if (start < vm_map_min(map)) \
start = vm_map_min(map); \
if (end > vm_map_max(map)) \
end = vm_map_max(map); \
if (start > end) \
start = end; \
}
boolean_t
vm_map_range_check(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
vm_map_entry_t *entry)
{
vm_map_entry_t cur;
register vm_offset_t prev;
if (start < vm_map_min(map) || end > vm_map_max(map) || start > end)
return (FALSE);
if (!vm_map_lookup_entry(map, start, &cur))
return (FALSE);
if (entry != (vm_map_entry_t *) NULL)
*entry = cur;
if (end <= cur->vme_end)
return (TRUE);
prev = cur->vme_end;
cur = cur->vme_next;
while ((cur != vm_map_to_entry(map)) && (prev == cur->vme_start)) {
if (end <= cur->vme_end)
return (TRUE);
prev = cur->vme_end;
cur = cur->vme_next;
}
return (FALSE);
}
kern_return_t
vm_map_submap(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
vm_map_t submap,
vm_offset_t offset,
boolean_t use_pmap)
{
vm_map_entry_t entry;
register kern_return_t result = KERN_INVALID_ARGUMENT;
register vm_object_t object;
vm_map_lock(map);
submap->mapped = TRUE;
VM_MAP_RANGE_CHECK(map, start, end);
if (vm_map_lookup_entry(map, start, &entry)) {
vm_map_clip_start(map, entry, start);
}
else
entry = entry->vme_next;
if(entry == vm_map_to_entry(map)) {
vm_map_unlock(map);
return KERN_INVALID_ARGUMENT;
}
vm_map_clip_end(map, entry, end);
if ((entry->vme_start == start) && (entry->vme_end == end) &&
(!entry->is_sub_map) &&
((object = entry->object.vm_object) == vm_submap_object) &&
(object->resident_page_count == 0) &&
(object->copy == VM_OBJECT_NULL) &&
(object->shadow == VM_OBJECT_NULL) &&
(!object->pager_created)) {
entry->offset = (vm_object_offset_t)offset;
entry->object.vm_object = VM_OBJECT_NULL;
vm_object_deallocate(object);
entry->is_sub_map = TRUE;
entry->object.sub_map = submap;
vm_map_reference(submap);
#ifndef i386
if ((use_pmap) && (offset == 0)) {
if(submap->pmap == NULL) {
submap->pmap = pmap_create((vm_size_t) 0);
if(submap->pmap == PMAP_NULL) {
return(KERN_NO_SPACE);
}
}
result = pmap_nest(map->pmap, (entry->object.sub_map)->pmap,
(addr64_t)start, (addr64_t)start, (uint64_t)(end - start));
if(result)
panic("vm_map_submap: pmap_nest failed, rc = %08X\n", result);
entry->use_pmap = TRUE;
}
#endif
#ifdef i386
pmap_remove(map->pmap, (addr64_t)start, (addr64_t)end);
#endif
result = KERN_SUCCESS;
}
vm_map_unlock(map);
return(result);
}
kern_return_t
vm_map_protect(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
register vm_prot_t new_prot,
register boolean_t set_max)
{
register vm_map_entry_t current;
register vm_offset_t prev;
vm_map_entry_t entry;
vm_prot_t new_max;
boolean_t clip;
XPR(XPR_VM_MAP,
"vm_map_protect, 0x%X start 0x%X end 0x%X, new 0x%X %d",
(integer_t)map, start, end, new_prot, set_max);
vm_map_lock(map);
if (!(clip = vm_map_lookup_entry(map, start, &entry))) {
vm_map_unlock(map);
return(KERN_INVALID_ADDRESS);
}
current = entry;
prev = current->vme_start;
while ((current != vm_map_to_entry(map)) &&
(current->vme_start < end)) {
if (current->vme_start != prev) {
vm_map_unlock(map);
return(KERN_INVALID_ADDRESS);
}
new_max = current->max_protection;
if(new_prot & VM_PROT_COPY) {
new_max |= VM_PROT_WRITE;
if ((new_prot & (new_max | VM_PROT_COPY)) != new_prot) {
vm_map_unlock(map);
return(KERN_PROTECTION_FAILURE);
}
} else {
if ((new_prot & new_max) != new_prot) {
vm_map_unlock(map);
return(KERN_PROTECTION_FAILURE);
}
}
prev = current->vme_end;
current = current->vme_next;
}
if (end > prev) {
vm_map_unlock(map);
return(KERN_INVALID_ADDRESS);
}
current = entry;
if (clip) {
vm_map_clip_start(map, entry, start);
}
while ((current != vm_map_to_entry(map)) &&
(current->vme_start < end)) {
vm_prot_t old_prot;
vm_map_clip_end(map, current, end);
old_prot = current->protection;
if(new_prot & VM_PROT_COPY) {
current->needs_copy = TRUE;
current->max_protection |= VM_PROT_WRITE;
}
if (set_max)
current->protection =
(current->max_protection =
new_prot & ~VM_PROT_COPY) &
old_prot;
else
current->protection = new_prot & ~VM_PROT_COPY;
if (current->protection != old_prot) {
if(current->is_sub_map && current->use_pmap) {
vm_offset_t pmap_base_addr;
vm_offset_t pmap_end_addr;
vm_map_entry_t local_entry;
pmap_base_addr = 0xF0000000 & current->vme_start;
pmap_end_addr = (pmap_base_addr + 0x10000000) - 1;
#ifndef i386
if(!vm_map_lookup_entry(map,
pmap_base_addr, &local_entry))
panic("vm_map_protect: nested pmap area is missing");
while ((local_entry != vm_map_to_entry(map)) &&
(local_entry->vme_start < pmap_end_addr)) {
local_entry->use_pmap = FALSE;
local_entry = local_entry->vme_next;
}
pmap_unnest(map->pmap, (addr64_t)pmap_base_addr);
#endif
}
if (!(current->protection & VM_PROT_WRITE)) {
if(current->is_sub_map && current->use_pmap) {
pmap_protect(current->object.sub_map->pmap,
current->vme_start,
current->vme_end,
current->protection);
} else {
pmap_protect(map->pmap, current->vme_start,
current->vme_end,
current->protection);
}
}
}
current = current->vme_next;
}
vm_map_unlock(map);
return(KERN_SUCCESS);
}
kern_return_t
vm_map_inherit(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
register vm_inherit_t new_inheritance)
{
register vm_map_entry_t entry;
vm_map_entry_t temp_entry;
vm_map_lock(map);
VM_MAP_RANGE_CHECK(map, start, end);
if (vm_map_lookup_entry(map, start, &temp_entry)) {
entry = temp_entry;
vm_map_clip_start(map, entry, start);
}
else {
temp_entry = temp_entry->vme_next;
entry = temp_entry;
}
while ((entry != vm_map_to_entry(map)) && (entry->vme_start < end)) {
if(entry->is_sub_map) {
if(new_inheritance == VM_INHERIT_COPY)
return(KERN_INVALID_ARGUMENT);
}
entry = entry->vme_next;
}
entry = temp_entry;
while ((entry != vm_map_to_entry(map)) && (entry->vme_start < end)) {
vm_map_clip_end(map, entry, end);
entry->inheritance = new_inheritance;
entry = entry->vme_next;
}
vm_map_unlock(map);
return(KERN_SUCCESS);
}
kern_return_t
vm_map_wire_nested(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
register vm_prot_t access_type,
boolean_t user_wire,
pmap_t map_pmap,
vm_offset_t pmap_addr)
{
register vm_map_entry_t entry;
struct vm_map_entry *first_entry, tmp_entry;
vm_map_t pmap_map;
register vm_offset_t s,e;
kern_return_t rc;
boolean_t need_wakeup;
boolean_t main_map = FALSE;
wait_interrupt_t interruptible_state;
thread_t cur_thread;
unsigned int last_timestamp;
vm_size_t size;
vm_map_lock(map);
if(map_pmap == NULL)
main_map = TRUE;
last_timestamp = map->timestamp;
VM_MAP_RANGE_CHECK(map, start, end);
assert(page_aligned(start));
assert(page_aligned(end));
if (start == end) {
vm_map_unlock(map);
return KERN_SUCCESS;
}
if (vm_map_lookup_entry(map, start, &first_entry)) {
entry = first_entry;
} else {
vm_map_unlock(map);
return(KERN_INVALID_ADDRESS);
}
s=start;
need_wakeup = FALSE;
cur_thread = current_thread();
while ((entry != vm_map_to_entry(map)) && (entry->vme_start < end)) {
if (entry->in_transition) {
wait_result_t wait_result;
s = entry->vme_start < start? start: entry->vme_start;
entry->needs_wakeup = TRUE;
if (need_wakeup) {
vm_map_entry_wakeup(map);
need_wakeup = FALSE;
}
wait_result = vm_map_entry_wait(map,
(user_wire) ? THREAD_ABORTSAFE :
THREAD_UNINT);
if (user_wire && wait_result == THREAD_INTERRUPTED) {
vm_map_unlock(map);
vm_map_unwire(map, start, s, user_wire);
return(KERN_FAILURE);
}
last_timestamp = map->timestamp;
if (!vm_map_lookup_entry(map, s, &first_entry)) {
if (!user_wire)
panic("vm_map_wire: re-lookup failed");
vm_map_unlock(map);
vm_map_unwire(map, start, s, user_wire);
return(KERN_FAILURE);
}
entry = first_entry;
continue;
}
if(entry->is_sub_map) {
vm_offset_t sub_start;
vm_offset_t sub_end;
vm_offset_t local_start;
vm_offset_t local_end;
pmap_t pmap;
vm_map_clip_start(map, entry, start);
vm_map_clip_end(map, entry, end);
sub_start = entry->offset;
sub_end = entry->vme_end - entry->vme_start;
sub_end += entry->offset;
local_end = entry->vme_end;
if(map_pmap == NULL) {
if(entry->use_pmap) {
pmap = entry->object.sub_map->pmap;
#ifdef notdef
pmap_addr = sub_start;
#endif
pmap_addr = start;
} else {
pmap = map->pmap;
pmap_addr = start;
}
if (entry->wired_count) {
if (entry->wired_count
>= MAX_WIRE_COUNT)
panic("vm_map_wire: too many wirings");
if (user_wire &&
entry->user_wired_count
>= MAX_WIRE_COUNT) {
vm_map_unlock(map);
vm_map_unwire(map, start,
entry->vme_start, user_wire);
return(KERN_FAILURE);
}
if(user_wire)
entry->user_wired_count++;
if((!user_wire) ||
(entry->user_wired_count == 0))
entry->wired_count++;
entry = entry->vme_next;
continue;
} else {
vm_object_t object;
vm_object_offset_t offset_hi;
vm_object_offset_t offset_lo;
vm_object_offset_t offset;
vm_prot_t prot;
boolean_t wired;
vm_behavior_t behavior;
vm_map_entry_t local_entry;
vm_map_version_t version;
vm_map_t lookup_map;
local_start = entry->vme_start;
lookup_map = map;
vm_map_lock_write_to_read(map);
if(vm_map_lookup_locked(
&lookup_map, local_start,
access_type,
&version, &object,
&offset, &prot, &wired,
&behavior, &offset_lo,
&offset_hi, &pmap_map)) {
vm_map_unlock(lookup_map);
vm_map_unwire(map, start,
entry->vme_start, user_wire);
return(KERN_FAILURE);
}
if(pmap_map != lookup_map)
vm_map_unlock(pmap_map);
vm_map_unlock_read(lookup_map);
vm_map_lock(map);
vm_object_unlock(object);
if (!vm_map_lookup_entry(map,
local_start, &local_entry)) {
vm_map_unlock(map);
vm_map_unwire(map, start,
entry->vme_start, user_wire);
return(KERN_FAILURE);
}
if (!local_entry->is_sub_map) {
last_timestamp = map->timestamp;
continue;
}
entry = local_entry;
if (user_wire)
entry->user_wired_count++;
if((!user_wire) ||
(entry->user_wired_count == 1))
entry->wired_count++;
entry->in_transition = TRUE;
vm_map_unlock(map);
rc = vm_map_wire_nested(
entry->object.sub_map,
sub_start, sub_end,
access_type,
user_wire, pmap, pmap_addr);
vm_map_lock(map);
}
} else {
local_start = entry->vme_start;
if (user_wire)
entry->user_wired_count++;
if((!user_wire) ||
(entry->user_wired_count == 1))
entry->wired_count++;
vm_map_unlock(map);
rc = vm_map_wire_nested(entry->object.sub_map,
sub_start, sub_end,
access_type,
user_wire, pmap, pmap_addr);
vm_map_lock(map);
}
s = entry->vme_start;
e = entry->vme_end;
if (!vm_map_lookup_entry(map, local_start,
&first_entry))
panic("vm_map_wire: re-lookup failed");
entry = first_entry;
last_timestamp = map->timestamp;
while ((entry != vm_map_to_entry(map)) &&
(entry->vme_start < e)) {
assert(entry->in_transition);
entry->in_transition = FALSE;
if (entry->needs_wakeup) {
entry->needs_wakeup = FALSE;
need_wakeup = TRUE;
}
if (rc != KERN_SUCCESS) {
if (user_wire)
entry->user_wired_count--;
if ((!user_wire) ||
(entry->user_wired_count == 0))
entry->wired_count--;
}
entry = entry->vme_next;
}
if (rc != KERN_SUCCESS) {
vm_map_unlock(map);
if (need_wakeup)
vm_map_entry_wakeup(map);
(void)vm_map_unwire(map, start, s, user_wire);
return rc;
}
continue;
}
if (entry->wired_count) {
if (entry->wired_count >= MAX_WIRE_COUNT)
panic("vm_map_wire: too many wirings");
if (user_wire &&
entry->user_wired_count >= MAX_WIRE_COUNT) {
vm_map_unlock(map);
vm_map_unwire(map, start,
entry->vme_start, user_wire);
return(KERN_FAILURE);
}
vm_map_clip_start(map, entry, start);
vm_map_clip_end(map, entry, end);
if (user_wire)
entry->user_wired_count++;
if ((!user_wire) || (entry->user_wired_count == 1))
entry->wired_count++;
entry = entry->vme_next;
continue;
}
size = entry->vme_end - entry->vme_start;
if (entry->needs_copy) {
vm_object_shadow(&entry->object.vm_object,
&entry->offset, size);
entry->needs_copy = FALSE;
} else if (entry->object.vm_object == VM_OBJECT_NULL) {
entry->object.vm_object = vm_object_allocate(size);
entry->offset = (vm_object_offset_t)0;
}
vm_map_clip_start(map, entry, start);
vm_map_clip_end(map, entry, end);
s = entry->vme_start;
e = entry->vme_end;
if ((((entry->vme_end < end) &&
((entry->vme_next == vm_map_to_entry(map)) ||
(entry->vme_next->vme_start > entry->vme_end))) ||
((entry->protection & access_type) != access_type))) {
if (start != entry->vme_start) {
vm_map_unlock(map);
vm_map_unwire(map, start, s, user_wire);
} else {
vm_map_unlock(map);
}
return((entry->protection&access_type) != access_type?
KERN_PROTECTION_FAILURE: KERN_INVALID_ADDRESS);
}
assert(entry->wired_count == 0 && entry->user_wired_count == 0);
if (user_wire)
entry->user_wired_count++;
if ((!user_wire) || (entry->user_wired_count == 1))
entry->wired_count++;
entry->in_transition = TRUE;
tmp_entry = *entry;
vm_map_unlock(map);
if (!user_wire && cur_thread != THREAD_NULL)
interruptible_state = thread_interrupt_level(THREAD_UNINT);
if(map_pmap)
rc = vm_fault_wire(map,
&tmp_entry, map_pmap, pmap_addr);
else
rc = vm_fault_wire(map,
&tmp_entry, map->pmap,
tmp_entry.vme_start);
if (!user_wire && cur_thread != THREAD_NULL)
thread_interrupt_level(interruptible_state);
vm_map_lock(map);
if (last_timestamp+1 != map->timestamp) {
if (!vm_map_lookup_entry(map, tmp_entry.vme_start,
&first_entry))
panic("vm_map_wire: re-lookup failed");
entry = first_entry;
}
last_timestamp = map->timestamp;
while ((entry != vm_map_to_entry(map)) &&
(entry->vme_start < tmp_entry.vme_end)) {
assert(entry->in_transition);
entry->in_transition = FALSE;
if (entry->needs_wakeup) {
entry->needs_wakeup = FALSE;
need_wakeup = TRUE;
}
if (rc != KERN_SUCCESS) {
if (user_wire)
entry->user_wired_count--;
if ((!user_wire) ||
(entry->user_wired_count == 0))
entry->wired_count--;
}
entry = entry->vme_next;
}
if (rc != KERN_SUCCESS) {
vm_map_unlock(map);
if (need_wakeup)
vm_map_entry_wakeup(map);
(void)vm_map_unwire(map, start, s, user_wire);
return rc;
}
}
vm_map_unlock(map);
if (need_wakeup)
vm_map_entry_wakeup(map);
return(KERN_SUCCESS);
}
kern_return_t
vm_map_wire(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
register vm_prot_t access_type,
boolean_t user_wire)
{
kern_return_t kret;
#ifdef ppc
VM_MAP_RANGE_CHECK(map, start, end);
mapping_prealloc(end - start);
#endif
kret = vm_map_wire_nested(map, start, end, access_type,
user_wire, (pmap_t)NULL, 0);
#ifdef ppc
mapping_relpre();
#endif
return kret;
}
kern_return_t
vm_map_unwire_nested(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
boolean_t user_wire,
pmap_t map_pmap,
vm_offset_t pmap_addr)
{
register vm_map_entry_t entry;
struct vm_map_entry *first_entry, tmp_entry;
boolean_t need_wakeup;
boolean_t main_map = FALSE;
unsigned int last_timestamp;
vm_map_lock(map);
if(map_pmap == NULL)
main_map = TRUE;
last_timestamp = map->timestamp;
VM_MAP_RANGE_CHECK(map, start, end);
assert(page_aligned(start));
assert(page_aligned(end));
if (vm_map_lookup_entry(map, start, &first_entry)) {
entry = first_entry;
}
else {
vm_map_unlock(map);
return(KERN_INVALID_ADDRESS);
}
need_wakeup = FALSE;
while ((entry != vm_map_to_entry(map)) && (entry->vme_start < end)) {
if (entry->in_transition) {
if (!user_wire)
panic("vm_map_unwire: in_transition entry");
entry = entry->vme_next;
continue;
}
if(entry->is_sub_map) {
vm_offset_t sub_start;
vm_offset_t sub_end;
vm_offset_t local_end;
pmap_t pmap;
vm_map_clip_start(map, entry, start);
vm_map_clip_end(map, entry, end);
sub_start = entry->offset;
sub_end = entry->vme_end - entry->vme_start;
sub_end += entry->offset;
local_end = entry->vme_end;
if(map_pmap == NULL) {
if(entry->use_pmap) {
pmap = entry->object.sub_map->pmap;
pmap_addr = sub_start;
} else {
pmap = map->pmap;
pmap_addr = start;
}
if (entry->wired_count == 0 ||
(user_wire && entry->user_wired_count == 0)) {
if (!user_wire)
panic("vm_map_unwire: entry is unwired");
entry = entry->vme_next;
continue;
}
if (((entry->vme_end < end) &&
((entry->vme_next == vm_map_to_entry(map)) ||
(entry->vme_next->vme_start
> entry->vme_end)))) {
if (!user_wire)
panic("vm_map_unwire: non-contiguous region");
}
if (!user_wire || (--entry->user_wired_count == 0))
entry->wired_count--;
if (entry->wired_count != 0) {
entry = entry->vme_next;
continue;
}
entry->in_transition = TRUE;
tmp_entry = *entry;
vm_map_unlock(map);
vm_map_unwire_nested(entry->object.sub_map,
sub_start, sub_end, user_wire, pmap, pmap_addr);
vm_map_lock(map);
if (last_timestamp+1 != map->timestamp) {
if (!vm_map_lookup_entry(map,
tmp_entry.vme_start,
&first_entry)) {
if (!user_wire)
panic("vm_map_unwire: re-lookup failed");
entry = first_entry->vme_next;
} else
entry = first_entry;
}
last_timestamp = map->timestamp;
while ((entry != vm_map_to_entry(map)) &&
(entry->vme_start < tmp_entry.vme_end)) {
assert(entry->in_transition);
entry->in_transition = FALSE;
if (entry->needs_wakeup) {
entry->needs_wakeup = FALSE;
need_wakeup = TRUE;
}
entry = entry->vme_next;
}
continue;
} else {
vm_map_unlock(map);
vm_map_unwire_nested(entry->object.sub_map,
sub_start, sub_end, user_wire, pmap, pmap_addr);
vm_map_lock(map);
if (last_timestamp+1 != map->timestamp) {
if (!vm_map_lookup_entry(map,
tmp_entry.vme_start,
&first_entry)) {
if (!user_wire)
panic("vm_map_unwire: re-lookup failed");
entry = first_entry->vme_next;
} else
entry = first_entry;
}
last_timestamp = map->timestamp;
}
}
if ((entry->wired_count == 0) ||
(user_wire && entry->user_wired_count == 0)) {
if (!user_wire)
panic("vm_map_unwire: entry is unwired");
entry = entry->vme_next;
continue;
}
assert(entry->wired_count > 0 &&
(!user_wire || entry->user_wired_count > 0));
vm_map_clip_start(map, entry, start);
vm_map_clip_end(map, entry, end);
if (((entry->vme_end < end) &&
((entry->vme_next == vm_map_to_entry(map)) ||
(entry->vme_next->vme_start > entry->vme_end)))) {
if (!user_wire)
panic("vm_map_unwire: non-contiguous region");
entry = entry->vme_next;
continue;
}
if (!user_wire || (--entry->user_wired_count == 0))
entry->wired_count--;
if (entry->wired_count != 0) {
entry = entry->vme_next;
continue;
}
entry->in_transition = TRUE;
tmp_entry = *entry;
vm_map_unlock(map);
if(map_pmap) {
vm_fault_unwire(map,
&tmp_entry, FALSE, map_pmap, pmap_addr);
} else {
vm_fault_unwire(map,
&tmp_entry, FALSE, map->pmap,
tmp_entry.vme_start);
}
vm_map_lock(map);
if (last_timestamp+1 != map->timestamp) {
if (!vm_map_lookup_entry(map, tmp_entry.vme_start,
&first_entry)) {
if (!user_wire)
panic("vm_map_unwire: re-lookup failed");
entry = first_entry->vme_next;
} else
entry = first_entry;
}
last_timestamp = map->timestamp;
while ((entry != vm_map_to_entry(map)) &&
(entry->vme_start < tmp_entry.vme_end)) {
assert(entry->in_transition);
entry->in_transition = FALSE;
if (entry->needs_wakeup) {
entry->needs_wakeup = FALSE;
need_wakeup = TRUE;
}
entry = entry->vme_next;
}
}
vm_map_unlock(map);
if (need_wakeup)
vm_map_entry_wakeup(map);
return(KERN_SUCCESS);
}
kern_return_t
vm_map_unwire(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
boolean_t user_wire)
{
return vm_map_unwire_nested(map, start, end,
user_wire, (pmap_t)NULL, 0);
}
void
vm_map_entry_delete(
register vm_map_t map,
register vm_map_entry_t entry)
{
register vm_offset_t s, e;
register vm_object_t object;
register vm_map_t submap;
extern vm_object_t kernel_object;
s = entry->vme_start;
e = entry->vme_end;
assert(page_aligned(s));
assert(page_aligned(e));
assert(entry->wired_count == 0);
assert(entry->user_wired_count == 0);
if (entry->is_sub_map) {
object = NULL;
submap = entry->object.sub_map;
} else {
submap = NULL;
object = entry->object.vm_object;
}
vm_map_entry_unlink(map, entry);
map->size -= e - s;
vm_map_entry_dispose(map, entry);
vm_map_unlock(map);
if (submap)
vm_map_deallocate(submap);
else
vm_object_deallocate(object);
}
void
vm_map_submap_pmap_clean(
vm_map_t map,
vm_offset_t start,
vm_offset_t end,
vm_map_t sub_map,
vm_offset_t offset)
{
vm_offset_t submap_start;
vm_offset_t submap_end;
vm_offset_t addr;
vm_size_t remove_size;
vm_map_entry_t entry;
submap_end = offset + (end - start);
submap_start = offset;
if(vm_map_lookup_entry(sub_map, offset, &entry)) {
remove_size = (entry->vme_end - entry->vme_start);
if(offset > entry->vme_start)
remove_size -= offset - entry->vme_start;
if(submap_end < entry->vme_end) {
remove_size -=
entry->vme_end - submap_end;
}
if(entry->is_sub_map) {
vm_map_submap_pmap_clean(
sub_map,
start,
start + remove_size,
entry->object.sub_map,
entry->offset);
} else {
if((map->mapped) && (map->ref_count)
&& (entry->object.vm_object != NULL)) {
vm_object_pmap_protect(
entry->object.vm_object,
entry->offset,
remove_size,
PMAP_NULL,
entry->vme_start,
VM_PROT_NONE);
} else {
pmap_remove(map->pmap,
(addr64_t)start,
(addr64_t)(start + remove_size));
}
}
}
entry = entry->vme_next;
while((entry != vm_map_to_entry(sub_map))
&& (entry->vme_start < submap_end)) {
remove_size = (entry->vme_end - entry->vme_start);
if(submap_end < entry->vme_end) {
remove_size -= entry->vme_end - submap_end;
}
if(entry->is_sub_map) {
vm_map_submap_pmap_clean(
sub_map,
(start + entry->vme_start) - offset,
((start + entry->vme_start) - offset) + remove_size,
entry->object.sub_map,
entry->offset);
} else {
if((map->mapped) && (map->ref_count)
&& (entry->object.vm_object != NULL)) {
vm_object_pmap_protect(
entry->object.vm_object,
entry->offset,
remove_size,
PMAP_NULL,
entry->vme_start,
VM_PROT_NONE);
} else {
pmap_remove(map->pmap,
(addr64_t)((start + entry->vme_start)
- offset),
(addr64_t)(((start + entry->vme_start)
- offset) + remove_size));
}
}
entry = entry->vme_next;
}
return;
}
kern_return_t
vm_map_delete(
register vm_map_t map,
vm_offset_t start,
register vm_offset_t end,
int flags)
{
vm_map_entry_t entry, next;
struct vm_map_entry *first_entry, tmp_entry;
register vm_offset_t s, e;
register vm_object_t object;
boolean_t need_wakeup;
unsigned int last_timestamp = ~0;
int interruptible;
extern vm_map_t kernel_map;
interruptible = (flags & VM_MAP_REMOVE_INTERRUPTIBLE) ?
THREAD_ABORTSAFE : THREAD_UNINT;
flags |= VM_MAP_REMOVE_WAIT_FOR_KWIRE;
if (vm_map_lookup_entry(map, start, &first_entry)) {
entry = first_entry;
vm_map_clip_start(map, entry, start);
SAVE_HINT(map, entry->vme_prev);
} else {
entry = first_entry->vme_next;
}
need_wakeup = FALSE;
while ((entry != vm_map_to_entry(map)) && (entry->vme_start < end)) {
vm_map_clip_end(map, entry, end);
if (entry->in_transition) {
wait_result_t wait_result;
s = entry->vme_start;
entry->needs_wakeup = TRUE;
if (need_wakeup) {
vm_map_entry_wakeup(map);
need_wakeup = FALSE;
}
wait_result = vm_map_entry_wait(map, interruptible);
if (interruptible &&
wait_result == THREAD_INTERRUPTED) {
vm_map_unlock(map);
return KERN_ABORTED;
}
if (!vm_map_lookup_entry(map, s, &first_entry)) {
assert((map != kernel_map) &&
(!entry->is_sub_map));
entry = first_entry->vme_next;
} else {
entry = first_entry;
SAVE_HINT(map, entry->vme_prev);
}
last_timestamp = map->timestamp;
continue;
}
if (entry->wired_count) {
if ((flags & VM_MAP_REMOVE_KUNWIRE) ||
(entry->user_wired_count > 0))
entry->wired_count--;
entry->user_wired_count = 0;
if (entry->wired_count != 0) {
assert((map != kernel_map) &&
(!entry->is_sub_map));
if (flags & VM_MAP_REMOVE_WAIT_FOR_KWIRE) {
wait_result_t wait_result;
s = entry->vme_start;
entry->needs_wakeup = TRUE;
wait_result = vm_map_entry_wait(map,
interruptible);
if (interruptible &&
wait_result == THREAD_INTERRUPTED) {
vm_map_unlock(map);
return KERN_ABORTED;
}
if (!vm_map_lookup_entry(map, s,
&first_entry)) {
assert((map != kernel_map) &&
(!entry->is_sub_map));
entry = first_entry->vme_next;
} else {
entry = first_entry;
SAVE_HINT(map, entry->vme_prev);
}
last_timestamp = map->timestamp;
continue;
}
else {
return KERN_FAILURE;
}
}
entry->in_transition = TRUE;
tmp_entry = *entry;
s = entry->vme_start;
e = entry->vme_end;
vm_map_unlock(map);
vm_fault_unwire(map, &tmp_entry,
tmp_entry.object.vm_object == kernel_object,
map->pmap, tmp_entry.vme_start);
vm_map_lock(map);
if (last_timestamp+1 != map->timestamp) {
if (!vm_map_lookup_entry(map, s, &first_entry)){
assert((map != kernel_map) &&
(!entry->is_sub_map));
first_entry = first_entry->vme_next;
} else {
SAVE_HINT(map, entry->vme_prev);
}
} else {
SAVE_HINT(map, entry->vme_prev);
first_entry = entry;
}
last_timestamp = map->timestamp;
entry = first_entry;
while ((entry != vm_map_to_entry(map)) &&
(entry->vme_start < tmp_entry.vme_end)) {
assert(entry->in_transition);
entry->in_transition = FALSE;
if (entry->needs_wakeup) {
entry->needs_wakeup = FALSE;
need_wakeup = TRUE;
}
entry = entry->vme_next;
}
entry = first_entry;
continue;
}
assert(entry->wired_count == 0);
assert(entry->user_wired_count == 0);
if ((!entry->is_sub_map &&
entry->object.vm_object != kernel_object) ||
entry->is_sub_map) {
if(entry->is_sub_map) {
if(entry->use_pmap) {
#ifndef i386
pmap_unnest(map->pmap, (addr64_t)entry->vme_start);
#endif
if((map->mapped) && (map->ref_count)) {
vm_map_submap_pmap_clean(
map, entry->vme_start,
entry->vme_end,
entry->object.sub_map,
entry->offset);
}
} else {
vm_map_submap_pmap_clean(
map, entry->vme_start, entry->vme_end,
entry->object.sub_map,
entry->offset);
}
} else {
if((map->mapped) && (map->ref_count)) {
vm_object_pmap_protect(
entry->object.vm_object,
entry->offset,
entry->vme_end - entry->vme_start,
PMAP_NULL,
entry->vme_start,
VM_PROT_NONE);
} else {
pmap_remove(map->pmap,
(addr64_t)(entry->vme_start),
(addr64_t)(entry->vme_end));
}
}
}
next = entry->vme_next;
s = next->vme_start;
last_timestamp = map->timestamp;
vm_map_entry_delete(map, entry);
vm_map_lock(map);
entry = next;
if(entry == vm_map_to_entry(map)) {
break;
}
if (last_timestamp+1 != map->timestamp) {
if (!vm_map_lookup_entry(map, s, &entry)){
entry = entry->vme_next;
} else {
SAVE_HINT(map, entry->vme_prev);
}
if(entry == vm_map_to_entry(map)) {
break;
}
vm_map_clip_start(map, entry, s);
}
last_timestamp = map->timestamp;
}
if (map->wait_for_space)
thread_wakeup((event_t) map);
if (need_wakeup)
vm_map_entry_wakeup(map);
return KERN_SUCCESS;
}
kern_return_t
vm_map_remove(
register vm_map_t map,
register vm_offset_t start,
register vm_offset_t end,
register boolean_t flags)
{
register kern_return_t result;
boolean_t funnel_set = FALSE;
funnel_t *curflock;
thread_t cur_thread;
cur_thread = current_thread();
if ((cur_thread->funnel_state & TH_FN_OWNED) == TH_FN_OWNED) {
funnel_set = TRUE;
curflock = cur_thread->funnel_lock;
thread_funnel_set( curflock , FALSE);
}
vm_map_lock(map);
VM_MAP_RANGE_CHECK(map, start, end);
result = vm_map_delete(map, start, end, flags);
vm_map_unlock(map);
if (funnel_set) {
thread_funnel_set( curflock, TRUE);
funnel_set = FALSE;
}
return(result);
}
void
vm_map_copy_discard(
vm_map_copy_t copy)
{
TR_DECL("vm_map_copy_discard");
free_next_copy:
if (copy == VM_MAP_COPY_NULL)
return;
switch (copy->type) {
case VM_MAP_COPY_ENTRY_LIST:
while (vm_map_copy_first_entry(copy) !=
vm_map_copy_to_entry(copy)) {
vm_map_entry_t entry = vm_map_copy_first_entry(copy);
vm_map_copy_entry_unlink(copy, entry);
vm_object_deallocate(entry->object.vm_object);
vm_map_copy_entry_dispose(copy, entry);
}
break;
case VM_MAP_COPY_OBJECT:
vm_object_deallocate(copy->cpy_object);
break;
case VM_MAP_COPY_KERNEL_BUFFER:
kfree((vm_offset_t) copy, copy->cpy_kalloc_size);
return;
}
zfree(vm_map_copy_zone, (vm_offset_t) copy);
}
vm_map_copy_t
vm_map_copy_copy(
vm_map_copy_t copy)
{
vm_map_copy_t new_copy;
if (copy == VM_MAP_COPY_NULL)
return VM_MAP_COPY_NULL;
new_copy = (vm_map_copy_t) zalloc(vm_map_copy_zone);
*new_copy = *copy;
if (copy->type == VM_MAP_COPY_ENTRY_LIST) {
vm_map_copy_first_entry(copy)->vme_prev
= vm_map_copy_to_entry(new_copy);
vm_map_copy_last_entry(copy)->vme_next
= vm_map_copy_to_entry(new_copy);
}
copy->type = VM_MAP_COPY_OBJECT;
copy->cpy_object = VM_OBJECT_NULL;
return new_copy;
}
kern_return_t
vm_map_overwrite_submap_recurse(
vm_map_t dst_map,
vm_offset_t dst_addr,
vm_size_t dst_size)
{
vm_offset_t dst_end;
vm_map_entry_t tmp_entry;
vm_map_entry_t entry;
kern_return_t result;
boolean_t encountered_sub_map = FALSE;
dst_end = round_page_32(dst_addr + dst_size);
vm_map_lock(dst_map);
start_pass_1:
if (!vm_map_lookup_entry(dst_map, dst_addr, &tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
vm_map_clip_start(dst_map, tmp_entry, trunc_page_32(dst_addr));
for (entry = tmp_entry;;) {
vm_map_entry_t next;
next = entry->vme_next;
while(entry->is_sub_map) {
vm_offset_t sub_start;
vm_offset_t sub_end;
vm_offset_t local_end;
if (entry->in_transition) {
entry->needs_wakeup = TRUE;
vm_map_entry_wait(dst_map, THREAD_UNINT);
goto start_pass_1;
}
encountered_sub_map = TRUE;
sub_start = entry->offset;
if(entry->vme_end < dst_end)
sub_end = entry->vme_end;
else
sub_end = dst_end;
sub_end -= entry->vme_start;
sub_end += entry->offset;
local_end = entry->vme_end;
vm_map_unlock(dst_map);
result = vm_map_overwrite_submap_recurse(
entry->object.sub_map,
sub_start,
sub_end - sub_start);
if(result != KERN_SUCCESS)
return result;
if (dst_end <= entry->vme_end)
return KERN_SUCCESS;
vm_map_lock(dst_map);
if(!vm_map_lookup_entry(dst_map, local_end,
&tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
entry = tmp_entry;
next = entry->vme_next;
}
if ( ! (entry->protection & VM_PROT_WRITE)) {
vm_map_unlock(dst_map);
return(KERN_PROTECTION_FAILURE);
}
if (entry->in_transition) {
entry->needs_wakeup = TRUE;
vm_map_entry_wait(dst_map, THREAD_UNINT);
goto start_pass_1;
}
if (dst_end <= entry->vme_end) {
vm_map_unlock(dst_map);
return KERN_SUCCESS;
}
if ((next == vm_map_to_entry(dst_map)) ||
(next->vme_start != entry->vme_end)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
if ((entry->object.vm_object != VM_OBJECT_NULL) &&
((!entry->object.vm_object->internal) ||
(entry->object.vm_object->true_share))) {
if(encountered_sub_map) {
vm_map_unlock(dst_map);
return(KERN_FAILURE);
}
}
entry = next;
}
vm_map_unlock(dst_map);
return(KERN_SUCCESS);
}
kern_return_t
vm_map_copy_overwrite_nested(
vm_map_t dst_map,
vm_offset_t dst_addr,
vm_map_copy_t copy,
boolean_t interruptible,
pmap_t pmap)
{
vm_offset_t dst_end;
vm_map_entry_t tmp_entry;
vm_map_entry_t entry;
kern_return_t kr;
boolean_t aligned = TRUE;
boolean_t contains_permanent_objects = FALSE;
boolean_t encountered_sub_map = FALSE;
vm_offset_t base_addr;
vm_size_t copy_size;
vm_size_t total_size;
if (copy == VM_MAP_COPY_NULL)
return(KERN_SUCCESS);
if (copy->type == VM_MAP_COPY_KERNEL_BUFFER) {
return(vm_map_copyout_kernel_buffer(
dst_map, &dst_addr,
copy, TRUE));
}
assert(copy->type == VM_MAP_COPY_ENTRY_LIST);
if (copy->size == 0) {
vm_map_copy_discard(copy);
return(KERN_SUCCESS);
}
if (!page_aligned(copy->size) ||
!page_aligned (copy->offset) ||
!page_aligned (dst_addr))
{
aligned = FALSE;
dst_end = round_page_32(dst_addr + copy->size);
} else {
dst_end = dst_addr + copy->size;
}
vm_map_lock(dst_map);
start_pass_1:
if (!vm_map_lookup_entry(dst_map, dst_addr, &tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
vm_map_clip_start(dst_map, tmp_entry, trunc_page_32(dst_addr));
for (entry = tmp_entry;;) {
vm_map_entry_t next = entry->vme_next;
while(entry->is_sub_map) {
vm_offset_t sub_start;
vm_offset_t sub_end;
vm_offset_t local_end;
if (entry->in_transition) {
entry->needs_wakeup = TRUE;
vm_map_entry_wait(dst_map, THREAD_UNINT);
goto start_pass_1;
}
local_end = entry->vme_end;
if (!(entry->needs_copy)) {
encountered_sub_map = TRUE;
sub_start = entry->offset;
if(entry->vme_end < dst_end)
sub_end = entry->vme_end;
else
sub_end = dst_end;
sub_end -= entry->vme_start;
sub_end += entry->offset;
vm_map_unlock(dst_map);
kr = vm_map_overwrite_submap_recurse(
entry->object.sub_map,
sub_start,
sub_end - sub_start);
if(kr != KERN_SUCCESS)
return kr;
vm_map_lock(dst_map);
}
if (dst_end <= entry->vme_end)
goto start_overwrite;
if(!vm_map_lookup_entry(dst_map, local_end,
&entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
next = entry->vme_next;
}
if ( ! (entry->protection & VM_PROT_WRITE)) {
vm_map_unlock(dst_map);
return(KERN_PROTECTION_FAILURE);
}
if (entry->in_transition) {
entry->needs_wakeup = TRUE;
vm_map_entry_wait(dst_map, THREAD_UNINT);
goto start_pass_1;
}
if (dst_end <= entry->vme_end)
break;
if ((next == vm_map_to_entry(dst_map)) ||
(next->vme_start != entry->vme_end)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
if ((entry->object.vm_object != VM_OBJECT_NULL) &&
((!entry->object.vm_object->internal) ||
(entry->object.vm_object->true_share))) {
contains_permanent_objects = TRUE;
}
entry = next;
}
start_overwrite:
if (interruptible && contains_permanent_objects) {
vm_map_unlock(dst_map);
return(KERN_FAILURE);
}
total_size = copy->size;
if(encountered_sub_map) {
copy_size = 0;
if (!vm_map_lookup_entry( dst_map, dst_addr, &tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
} else {
copy_size = copy->size;
}
base_addr = dst_addr;
while(TRUE) {
vm_map_entry_t copy_entry;
vm_map_entry_t previous_prev;
vm_map_entry_t next_copy;
int nentries;
int remaining_entries;
int new_offset;
for (entry = tmp_entry; copy_size == 0;) {
vm_map_entry_t next;
next = entry->vme_next;
if (entry->in_transition) {
entry->needs_wakeup = TRUE;
vm_map_entry_wait(dst_map, THREAD_UNINT);
if(!vm_map_lookup_entry(dst_map, base_addr,
&tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
copy_size = 0;
entry = tmp_entry;
continue;
}
if(entry->is_sub_map) {
vm_offset_t sub_start;
vm_offset_t sub_end;
vm_offset_t local_end;
if (entry->needs_copy) {
if(entry->vme_end < dst_end)
sub_end = entry->vme_end;
else
sub_end = dst_end;
if(entry->vme_start < base_addr)
sub_start = base_addr;
else
sub_start = entry->vme_start;
vm_map_clip_end(
dst_map, entry, sub_end);
vm_map_clip_start(
dst_map, entry, sub_start);
entry->is_sub_map = FALSE;
vm_map_deallocate(
entry->object.sub_map);
entry->object.sub_map = NULL;
entry->is_shared = FALSE;
entry->needs_copy = FALSE;
entry->offset = 0;
entry->protection = VM_PROT_ALL;
entry->max_protection = VM_PROT_ALL;
entry->wired_count = 0;
entry->user_wired_count = 0;
if(entry->inheritance
== VM_INHERIT_SHARE)
entry->inheritance = VM_INHERIT_COPY;
continue;
}
if(base_addr < entry->vme_start) {
copy_size =
entry->vme_start - base_addr;
break;
}
sub_start = entry->offset;
if(entry->vme_end < dst_end)
sub_end = entry->vme_end;
else
sub_end = dst_end;
sub_end -= entry->vme_start;
sub_end += entry->offset;
local_end = entry->vme_end;
vm_map_unlock(dst_map);
copy_size = sub_end - sub_start;
if (total_size > copy_size) {
vm_size_t local_size = 0;
vm_size_t entry_size;
nentries = 1;
new_offset = copy->offset;
copy_entry = vm_map_copy_first_entry(copy);
while(copy_entry !=
vm_map_copy_to_entry(copy)){
entry_size = copy_entry->vme_end -
copy_entry->vme_start;
if((local_size < copy_size) &&
((local_size + entry_size)
>= copy_size)) {
vm_map_copy_clip_end(copy,
copy_entry,
copy_entry->vme_start +
(copy_size - local_size));
entry_size = copy_entry->vme_end -
copy_entry->vme_start;
local_size += entry_size;
new_offset += entry_size;
}
if(local_size >= copy_size) {
next_copy = copy_entry->vme_next;
copy_entry->vme_next =
vm_map_copy_to_entry(copy);
previous_prev =
copy->cpy_hdr.links.prev;
copy->cpy_hdr.links.prev = copy_entry;
copy->size = copy_size;
remaining_entries =
copy->cpy_hdr.nentries;
remaining_entries -= nentries;
copy->cpy_hdr.nentries = nentries;
break;
} else {
local_size += entry_size;
new_offset += entry_size;
nentries++;
}
copy_entry = copy_entry->vme_next;
}
}
if((entry->use_pmap) && (pmap == NULL)) {
kr = vm_map_copy_overwrite_nested(
entry->object.sub_map,
sub_start,
copy,
interruptible,
entry->object.sub_map->pmap);
} else if (pmap != NULL) {
kr = vm_map_copy_overwrite_nested(
entry->object.sub_map,
sub_start,
copy,
interruptible, pmap);
} else {
kr = vm_map_copy_overwrite_nested(
entry->object.sub_map,
sub_start,
copy,
interruptible,
dst_map->pmap);
}
if(kr != KERN_SUCCESS) {
if(next_copy != NULL) {
copy->cpy_hdr.nentries +=
remaining_entries;
copy->cpy_hdr.links.prev->vme_next =
next_copy;
copy->cpy_hdr.links.prev
= previous_prev;
copy->size = total_size;
}
return kr;
}
if (dst_end <= local_end) {
return(KERN_SUCCESS);
}
copy = (vm_map_copy_t)
zalloc(vm_map_copy_zone);
vm_map_copy_first_entry(copy) =
vm_map_copy_last_entry(copy) =
vm_map_copy_to_entry(copy);
copy->type = VM_MAP_COPY_ENTRY_LIST;
copy->offset = new_offset;
total_size -= copy_size;
copy_size = 0;
if(next_copy != NULL) {
copy->cpy_hdr.nentries = remaining_entries;
copy->cpy_hdr.links.next = next_copy;
copy->cpy_hdr.links.prev = previous_prev;
copy->size = total_size;
next_copy->vme_prev =
vm_map_copy_to_entry(copy);
next_copy = NULL;
}
base_addr = local_end;
vm_map_lock(dst_map);
if(!vm_map_lookup_entry(dst_map,
local_end, &tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
entry = tmp_entry;
continue;
}
if (dst_end <= entry->vme_end) {
copy_size = dst_end - base_addr;
break;
}
if ((next == vm_map_to_entry(dst_map)) ||
(next->vme_start != entry->vme_end)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
entry = next;
}
next_copy = NULL;
nentries = 1;
if (total_size > copy_size) {
vm_size_t local_size = 0;
vm_size_t entry_size;
new_offset = copy->offset;
copy_entry = vm_map_copy_first_entry(copy);
while(copy_entry != vm_map_copy_to_entry(copy)) {
entry_size = copy_entry->vme_end -
copy_entry->vme_start;
if((local_size < copy_size) &&
((local_size + entry_size)
>= copy_size)) {
vm_map_copy_clip_end(copy, copy_entry,
copy_entry->vme_start +
(copy_size - local_size));
entry_size = copy_entry->vme_end -
copy_entry->vme_start;
local_size += entry_size;
new_offset += entry_size;
}
if(local_size >= copy_size) {
next_copy = copy_entry->vme_next;
copy_entry->vme_next =
vm_map_copy_to_entry(copy);
previous_prev =
copy->cpy_hdr.links.prev;
copy->cpy_hdr.links.prev = copy_entry;
copy->size = copy_size;
remaining_entries =
copy->cpy_hdr.nentries;
remaining_entries -= nentries;
copy->cpy_hdr.nentries = nentries;
break;
} else {
local_size += entry_size;
new_offset += entry_size;
nentries++;
}
copy_entry = copy_entry->vme_next;
}
}
if (aligned) {
pmap_t local_pmap;
if(pmap)
local_pmap = pmap;
else
local_pmap = dst_map->pmap;
if ((kr = vm_map_copy_overwrite_aligned(
dst_map, tmp_entry, copy,
base_addr, local_pmap)) != KERN_SUCCESS) {
if(next_copy != NULL) {
copy->cpy_hdr.nentries +=
remaining_entries;
copy->cpy_hdr.links.prev->vme_next =
next_copy;
copy->cpy_hdr.links.prev =
previous_prev;
copy->size += copy_size;
}
return kr;
}
vm_map_unlock(dst_map);
} else {
if ((kr = vm_map_copy_overwrite_unaligned( dst_map,
tmp_entry, copy, base_addr)) != KERN_SUCCESS) {
if(next_copy != NULL) {
copy->cpy_hdr.nentries +=
remaining_entries;
copy->cpy_hdr.links.prev->vme_next =
next_copy;
copy->cpy_hdr.links.prev =
previous_prev;
copy->size += copy_size;
}
return kr;
}
}
total_size -= copy_size;
if(total_size == 0)
break;
base_addr += copy_size;
copy_size = 0;
copy->offset = new_offset;
if(next_copy != NULL) {
copy->cpy_hdr.nentries = remaining_entries;
copy->cpy_hdr.links.next = next_copy;
copy->cpy_hdr.links.prev = previous_prev;
next_copy->vme_prev = vm_map_copy_to_entry(copy);
copy->size = total_size;
}
vm_map_lock(dst_map);
while(TRUE) {
if (!vm_map_lookup_entry(dst_map,
base_addr, &tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
if (tmp_entry->in_transition) {
entry->needs_wakeup = TRUE;
vm_map_entry_wait(dst_map, THREAD_UNINT);
} else {
break;
}
}
vm_map_clip_start(dst_map, tmp_entry, trunc_page_32(base_addr));
entry = tmp_entry;
}
vm_map_copy_discard(copy);
return(KERN_SUCCESS);
}
kern_return_t
vm_map_copy_overwrite(
vm_map_t dst_map,
vm_offset_t dst_addr,
vm_map_copy_t copy,
boolean_t interruptible)
{
return vm_map_copy_overwrite_nested(
dst_map, dst_addr, copy, interruptible, (pmap_t) NULL);
}
kern_return_t
vm_map_copy_overwrite_unaligned(
vm_map_t dst_map,
vm_map_entry_t entry,
vm_map_copy_t copy,
vm_offset_t start)
{
vm_map_entry_t copy_entry = vm_map_copy_first_entry(copy);
vm_map_version_t version;
vm_object_t dst_object;
vm_object_offset_t dst_offset;
vm_object_offset_t src_offset;
vm_object_offset_t entry_offset;
vm_offset_t entry_end;
vm_size_t src_size,
dst_size,
copy_size,
amount_left;
kern_return_t kr = KERN_SUCCESS;
vm_map_lock_write_to_read(dst_map);
src_offset = copy->offset - trunc_page_64(copy->offset);
amount_left = copy->size;
while (amount_left > 0) {
if (entry == vm_map_to_entry(dst_map)) {
vm_map_unlock_read(dst_map);
return KERN_INVALID_ADDRESS;
}
assert ((start>=entry->vme_start) && (start<entry->vme_end));
dst_offset = start - entry->vme_start;
dst_size = entry->vme_end - start;
src_size = copy_entry->vme_end -
(copy_entry->vme_start + src_offset);
if (dst_size < src_size) {
copy_size = dst_size;
} else {
copy_size = src_size;
}
if (copy_size > amount_left) {
copy_size = amount_left;
}
if (entry->needs_copy &&
((entry->protection & VM_PROT_WRITE) != 0))
{
if (vm_map_lock_read_to_write(dst_map)) {
vm_map_lock_read(dst_map);
goto RetryLookup;
}
vm_object_shadow(&entry->object.vm_object,
&entry->offset,
(vm_size_t)(entry->vme_end
- entry->vme_start));
entry->needs_copy = FALSE;
vm_map_lock_write_to_read(dst_map);
}
dst_object = entry->object.vm_object;
if (dst_object == VM_OBJECT_NULL) {
if (vm_map_lock_read_to_write(dst_map)) {
vm_map_lock_read(dst_map);
goto RetryLookup;
}
dst_object = vm_object_allocate((vm_size_t)
entry->vme_end - entry->vme_start);
entry->object.vm_object = dst_object;
entry->offset = 0;
vm_map_lock_write_to_read(dst_map);
}
vm_object_reference(dst_object);
version.main_timestamp = dst_map->timestamp;
entry_offset = entry->offset;
entry_end = entry->vme_end;
vm_map_unlock_read(dst_map);
kr = vm_fault_copy(
copy_entry->object.vm_object,
copy_entry->offset + src_offset,
©_size,
dst_object,
entry_offset + dst_offset,
dst_map,
&version,
THREAD_UNINT );
start += copy_size;
src_offset += copy_size;
amount_left -= copy_size;
vm_object_deallocate(dst_object);
if (kr != KERN_SUCCESS)
return kr;
if ((copy_entry->vme_start + src_offset) == copy_entry->vme_end
|| amount_left == 0)
{
vm_map_copy_entry_unlink(copy, copy_entry);
vm_object_deallocate(copy_entry->object.vm_object);
vm_map_copy_entry_dispose(copy, copy_entry);
if ((copy_entry = vm_map_copy_first_entry(copy))
== vm_map_copy_to_entry(copy) && amount_left) {
return KERN_INVALID_ADDRESS;
}
src_offset = 0;
}
if (amount_left == 0)
return KERN_SUCCESS;
vm_map_lock_read(dst_map);
if (version.main_timestamp == dst_map->timestamp) {
if (start == entry_end) {
entry = entry->vme_next;
if (start != entry->vme_start) {
vm_map_unlock_read(dst_map);
return KERN_INVALID_ADDRESS ;
}
}
} else {
RetryLookup:
if (!vm_map_lookup_entry(dst_map, start, &entry))
{
vm_map_unlock_read(dst_map);
return KERN_INVALID_ADDRESS ;
}
}
}
vm_map_unlock_read(dst_map);
return KERN_SUCCESS;
}
kern_return_t
vm_map_copy_overwrite_aligned(
vm_map_t dst_map,
vm_map_entry_t tmp_entry,
vm_map_copy_t copy,
vm_offset_t start,
pmap_t pmap)
{
vm_object_t object;
vm_map_entry_t copy_entry;
vm_size_t copy_size;
vm_size_t size;
vm_map_entry_t entry;
while ((copy_entry = vm_map_copy_first_entry(copy))
!= vm_map_copy_to_entry(copy))
{
copy_size = (copy_entry->vme_end - copy_entry->vme_start);
entry = tmp_entry;
if (entry == vm_map_to_entry(dst_map)) {
vm_map_unlock(dst_map);
return KERN_INVALID_ADDRESS;
}
size = (entry->vme_end - entry->vme_start);
if ((entry->vme_start != start) || ((entry->is_sub_map)
&& !entry->needs_copy)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
assert(entry != vm_map_to_entry(dst_map));
if ( ! (entry->protection & VM_PROT_WRITE)) {
vm_map_unlock(dst_map);
return(KERN_PROTECTION_FAILURE);
}
if (copy_size < size) {
vm_map_clip_end(dst_map, entry, entry->vme_start + copy_size);
size = copy_size;
}
if (size < copy_size) {
vm_map_copy_clip_end(copy, copy_entry,
copy_entry->vme_start + size);
copy_size = size;
}
assert((entry->vme_end - entry->vme_start) == size);
assert((tmp_entry->vme_end - tmp_entry->vme_start) == size);
assert((copy_entry->vme_end - copy_entry->vme_start) == size);
object = entry->object.vm_object;
if ((!entry->is_shared &&
((object == VM_OBJECT_NULL) ||
(object->internal && !object->true_share))) ||
entry->needs_copy) {
vm_object_t old_object = entry->object.vm_object;
vm_object_offset_t old_offset = entry->offset;
vm_object_offset_t offset;
if (old_object == copy_entry->object.vm_object &&
old_offset == copy_entry->offset) {
vm_map_copy_entry_unlink(copy, copy_entry);
vm_map_copy_entry_dispose(copy, copy_entry);
if (old_object != VM_OBJECT_NULL)
vm_object_deallocate(old_object);
start = tmp_entry->vme_end;
tmp_entry = tmp_entry->vme_next;
continue;
}
if (old_object != VM_OBJECT_NULL) {
if(entry->is_sub_map) {
if(entry->use_pmap) {
#ifndef i386
pmap_unnest(dst_map->pmap,
entry->vme_start,
entry->vme_end
- entry->vme_start);
#endif
if(dst_map->mapped) {
vm_map_submap_pmap_clean(
dst_map, entry->vme_start,
entry->vme_end,
entry->object.sub_map,
entry->offset);
}
} else {
vm_map_submap_pmap_clean(
dst_map, entry->vme_start,
entry->vme_end,
entry->object.sub_map,
entry->offset);
}
vm_map_deallocate(
entry->object.sub_map);
} else {
if(dst_map->mapped) {
vm_object_pmap_protect(
entry->object.vm_object,
entry->offset,
entry->vme_end
- entry->vme_start,
PMAP_NULL,
entry->vme_start,
VM_PROT_NONE);
} else {
pmap_remove(dst_map->pmap,
(addr64_t)(entry->vme_start),
(addr64_t)(entry->vme_end));
}
vm_object_deallocate(old_object);
}
}
entry->is_sub_map = FALSE;
entry->object = copy_entry->object;
object = entry->object.vm_object;
entry->needs_copy = copy_entry->needs_copy;
entry->wired_count = 0;
entry->user_wired_count = 0;
offset = entry->offset = copy_entry->offset;
vm_map_copy_entry_unlink(copy, copy_entry);
vm_map_copy_entry_dispose(copy, copy_entry);
#if BAD_OPTIMIZATION
if (object != VM_OBJECT_NULL) {
vm_offset_t va = entry->vme_start;
while (va < entry->vme_end) {
register vm_page_t m;
vm_prot_t prot;
prot = entry->protection;
vm_object_lock(object);
vm_object_paging_begin(object);
if ((m = vm_page_lookup(object,offset)) !=
VM_PAGE_NULL && !m->busy &&
!m->fictitious &&
(!m->unusual || (!m->error &&
!m->restart && !m->absent &&
(prot & m->page_lock) == 0))) {
m->busy = TRUE;
vm_object_unlock(object);
if (entry->needs_copy)
prot &= ~VM_PROT_WRITE;
PMAP_ENTER(pmap, va, m, prot,
((unsigned int)
(m->object->wimg_bits))
& VM_WIMG_MASK,
FALSE);
vm_object_lock(object);
vm_page_lock_queues();
if (!m->active && !m->inactive)
vm_page_activate(m);
vm_page_unlock_queues();
PAGE_WAKEUP_DONE(m);
}
vm_object_paging_end(object);
vm_object_unlock(object);
offset += PAGE_SIZE_64;
va += PAGE_SIZE;
}
}
#endif
start = tmp_entry->vme_end;
tmp_entry = tmp_entry->vme_next;
} else {
vm_map_version_t version;
vm_object_t dst_object = entry->object.vm_object;
vm_object_offset_t dst_offset = entry->offset;
kern_return_t r;
vm_object_reference(dst_object);
version.main_timestamp = dst_map->timestamp + 1;
vm_map_unlock(dst_map);
copy_size = size;
r = vm_fault_copy(
copy_entry->object.vm_object,
copy_entry->offset,
©_size,
dst_object,
dst_offset,
dst_map,
&version,
THREAD_UNINT );
vm_object_deallocate(dst_object);
if (r != KERN_SUCCESS)
return(r);
if (copy_size != 0) {
vm_map_copy_clip_end(copy, copy_entry,
copy_entry->vme_start + copy_size);
vm_map_copy_entry_unlink(copy, copy_entry);
vm_object_deallocate(copy_entry->object.vm_object);
vm_map_copy_entry_dispose(copy, copy_entry);
}
start += copy_size;
vm_map_lock(dst_map);
if (version.main_timestamp == dst_map->timestamp) {
vm_map_clip_end(dst_map, tmp_entry, start);
tmp_entry = tmp_entry->vme_next;
} else {
if (!vm_map_lookup_entry(dst_map, start, &tmp_entry)) {
vm_map_unlock(dst_map);
return(KERN_INVALID_ADDRESS);
}
vm_map_clip_start(dst_map, tmp_entry, start);
}
}
}
return(KERN_SUCCESS);
}
kern_return_t
vm_map_copyin_kernel_buffer(
vm_map_t src_map,
vm_offset_t src_addr,
vm_size_t len,
boolean_t src_destroy,
vm_map_copy_t *copy_result)
{
boolean_t flags;
vm_map_copy_t copy;
vm_size_t kalloc_size = sizeof(struct vm_map_copy) + len;
copy = (vm_map_copy_t) kalloc(kalloc_size);
if (copy == VM_MAP_COPY_NULL) {
return KERN_RESOURCE_SHORTAGE;
}
copy->type = VM_MAP_COPY_KERNEL_BUFFER;
copy->size = len;
copy->offset = 0;
copy->cpy_kdata = (vm_offset_t) (copy + 1);
copy->cpy_kalloc_size = kalloc_size;
if (src_map == kernel_map) {
bcopy((char *)src_addr, (char *)copy->cpy_kdata, len);
flags = VM_MAP_REMOVE_KUNWIRE | VM_MAP_REMOVE_WAIT_FOR_KWIRE |
VM_MAP_REMOVE_INTERRUPTIBLE;
} else {
kern_return_t kr;
kr = copyinmap(src_map, src_addr, copy->cpy_kdata, len);
if (kr != KERN_SUCCESS) {
kfree((vm_offset_t)copy, kalloc_size);
return kr;
}
flags = VM_MAP_REMOVE_WAIT_FOR_KWIRE |
VM_MAP_REMOVE_INTERRUPTIBLE;
}
if (src_destroy) {
(void) vm_map_remove(src_map, trunc_page_32(src_addr),
round_page_32(src_addr + len),
flags);
}
*copy_result = copy;
return KERN_SUCCESS;
}
kern_return_t
vm_map_copyout_kernel_buffer(
vm_map_t map,
vm_offset_t *addr,
vm_map_copy_t copy,
boolean_t overwrite)
{
kern_return_t kr = KERN_SUCCESS;
thread_act_t thr_act = current_act();
if (!overwrite) {
*addr = 0;
kr = vm_map_enter(map,
addr,
round_page_32(copy->size),
(vm_offset_t) 0,
TRUE,
VM_OBJECT_NULL,
(vm_object_offset_t) 0,
FALSE,
VM_PROT_DEFAULT,
VM_PROT_ALL,
VM_INHERIT_DEFAULT);
if (kr != KERN_SUCCESS)
return(kr);
}
if (thr_act->map == map) {
if (copyout((char *)copy->cpy_kdata, (char *)*addr,
copy->size)) {
return(KERN_INVALID_ADDRESS);
}
}
else {
vm_map_t oldmap;
vm_map_reference(map);
oldmap = vm_map_switch(map);
if (copyout((char *)copy->cpy_kdata, (char *)*addr,
copy->size)) {
return(KERN_INVALID_ADDRESS);
}
(void) vm_map_switch(oldmap);
vm_map_deallocate(map);
}
kfree((vm_offset_t)copy, copy->cpy_kalloc_size);
return(kr);
}
#define vm_map_copy_insert(map, where, copy) \
MACRO_BEGIN \
vm_map_t VMCI_map; \
vm_map_entry_t VMCI_where; \
vm_map_copy_t VMCI_copy; \
VMCI_map = (map); \
VMCI_where = (where); \
VMCI_copy = (copy); \
((VMCI_where->vme_next)->vme_prev = vm_map_copy_last_entry(VMCI_copy))\
->vme_next = (VMCI_where->vme_next); \
((VMCI_where)->vme_next = vm_map_copy_first_entry(VMCI_copy)) \
->vme_prev = VMCI_where; \
VMCI_map->hdr.nentries += VMCI_copy->cpy_hdr.nentries; \
UPDATE_FIRST_FREE(VMCI_map, VMCI_map->first_free); \
zfree(vm_map_copy_zone, (vm_offset_t) VMCI_copy); \
MACRO_END
kern_return_t
vm_map_copyout(
register vm_map_t dst_map,
vm_offset_t *dst_addr,
register vm_map_copy_t copy)
{
vm_size_t size;
vm_size_t adjustment;
vm_offset_t start;
vm_object_offset_t vm_copy_start;
vm_map_entry_t last;
register
vm_map_entry_t entry;
if (copy == VM_MAP_COPY_NULL) {
*dst_addr = 0;
return(KERN_SUCCESS);
}
if (copy->type == VM_MAP_COPY_OBJECT) {
vm_object_t object = copy->cpy_object;
kern_return_t kr;
vm_object_offset_t offset;
offset = trunc_page_64(copy->offset);
size = round_page_32(copy->size +
(vm_size_t)(copy->offset - offset));
*dst_addr = 0;
kr = vm_map_enter(dst_map, dst_addr, size,
(vm_offset_t) 0, TRUE,
object, offset, FALSE,
VM_PROT_DEFAULT, VM_PROT_ALL,
VM_INHERIT_DEFAULT);
if (kr != KERN_SUCCESS)
return(kr);
*dst_addr += (vm_offset_t)(copy->offset - offset);
zfree(vm_map_copy_zone, (vm_offset_t) copy);
return(KERN_SUCCESS);
}
if (copy->type == VM_MAP_COPY_KERNEL_BUFFER) {
return(vm_map_copyout_kernel_buffer(dst_map, dst_addr,
copy, FALSE));
}
vm_copy_start = trunc_page_64(copy->offset);
size = round_page_32((vm_size_t)copy->offset + copy->size)
- vm_copy_start;
StartAgain: ;
vm_map_lock(dst_map);
assert(first_free_is_valid(dst_map));
start = ((last = dst_map->first_free) == vm_map_to_entry(dst_map)) ?
vm_map_min(dst_map) : last->vme_end;
while (TRUE) {
vm_map_entry_t next = last->vme_next;
vm_offset_t end = start + size;
if ((end > dst_map->max_offset) || (end < start)) {
if (dst_map->wait_for_space) {
if (size <= (dst_map->max_offset - dst_map->min_offset)) {
assert_wait((event_t) dst_map,
THREAD_INTERRUPTIBLE);
vm_map_unlock(dst_map);
thread_block((void (*)(void))0);
goto StartAgain;
}
}
vm_map_unlock(dst_map);
return(KERN_NO_SPACE);
}
if ((next == vm_map_to_entry(dst_map)) ||
(next->vme_start >= end))
break;
last = next;
start = last->vme_end;
}
if (copy->cpy_hdr.entries_pageable != dst_map->hdr.entries_pageable) {
zone_t old_zone;
vm_map_entry_t next, new;
old_zone = (copy->cpy_hdr.entries_pageable)
? vm_map_entry_zone
: vm_map_kentry_zone;
entry = vm_map_copy_first_entry(copy);
copy->cpy_hdr.nentries = 0;
copy->cpy_hdr.entries_pageable = dst_map->hdr.entries_pageable;
vm_map_copy_first_entry(copy) =
vm_map_copy_last_entry(copy) =
vm_map_copy_to_entry(copy);
while (entry != vm_map_copy_to_entry(copy)) {
new = vm_map_copy_entry_create(copy);
vm_map_entry_copy_full(new, entry);
new->use_pmap = FALSE;
vm_map_copy_entry_link(copy,
vm_map_copy_last_entry(copy),
new);
next = entry->vme_next;
zfree(old_zone, (vm_offset_t) entry);
entry = next;
}
}
adjustment = start - vm_copy_start;
for (entry = vm_map_copy_first_entry(copy);
entry != vm_map_copy_to_entry(copy);
entry = entry->vme_next) {
entry->vme_start += adjustment;
entry->vme_end += adjustment;
entry->inheritance = VM_INHERIT_DEFAULT;
entry->protection = VM_PROT_DEFAULT;
entry->max_protection = VM_PROT_ALL;
entry->behavior = VM_BEHAVIOR_DEFAULT;
if (entry->wired_count != 0) {
register vm_offset_t va;
vm_object_offset_t offset;
register vm_object_t object;
object = entry->object.vm_object;
offset = entry->offset;
va = entry->vme_start;
pmap_pageable(dst_map->pmap,
entry->vme_start,
entry->vme_end,
TRUE);
while (va < entry->vme_end) {
register vm_page_t m;
vm_object_lock(object);
vm_object_paging_begin(object);
m = vm_page_lookup(object, offset);
if (m == VM_PAGE_NULL || m->wire_count == 0 ||
m->absent)
panic("vm_map_copyout: wiring 0x%x", m);
m->busy = TRUE;
vm_object_unlock(object);
PMAP_ENTER(dst_map->pmap, va, m, entry->protection,
((unsigned int)
(m->object->wimg_bits))
& VM_WIMG_MASK,
TRUE);
vm_object_lock(object);
PAGE_WAKEUP_DONE(m);
vm_object_paging_end(object);
vm_object_unlock(object);
offset += PAGE_SIZE_64;
va += PAGE_SIZE;
}
}
else if (size <= vm_map_aggressive_enter_max) {
register vm_offset_t va;
vm_object_offset_t offset;
register vm_object_t object;
vm_prot_t prot;
object = entry->object.vm_object;
if (object != VM_OBJECT_NULL) {
offset = entry->offset;
va = entry->vme_start;
while (va < entry->vme_end) {
register vm_page_t m;
vm_object_lock(object);
vm_object_paging_begin(object);
if (((m = vm_page_lookup(object,
offset))
!= VM_PAGE_NULL) &&
!m->busy && !m->fictitious &&
!m->absent && !m->error) {
m->busy = TRUE;
vm_object_unlock(object);
prot = entry->protection;
if (entry->needs_copy)
prot &= ~VM_PROT_WRITE;
PMAP_ENTER(dst_map->pmap, va,
m, prot,
((unsigned int)
(m->object->wimg_bits))
& VM_WIMG_MASK,
FALSE);
vm_object_lock(object);
vm_page_lock_queues();
if (!m->active && !m->inactive)
vm_page_activate(m);
vm_page_unlock_queues();
PAGE_WAKEUP_DONE(m);
}
vm_object_paging_end(object);
vm_object_unlock(object);
offset += PAGE_SIZE_64;
va += PAGE_SIZE;
}
}
}
}
*dst_addr = start + (copy->offset - vm_copy_start);
SAVE_HINT(dst_map, vm_map_copy_last_entry(copy));
dst_map->size += size;
vm_map_copy_insert(dst_map, last, copy);
vm_map_unlock(dst_map);
return(KERN_SUCCESS);
}
boolean_t vm_map_aggressive_enter;
typedef struct submap_map {
vm_map_t parent_map;
vm_offset_t base_start;
vm_offset_t base_end;
struct submap_map *next;
} submap_map_t;
kern_return_t
vm_map_copyin_common(
vm_map_t src_map,
vm_offset_t src_addr,
vm_size_t len,
boolean_t src_destroy,
boolean_t src_volatile,
vm_map_copy_t *copy_result,
boolean_t use_maxprot)
{
extern int msg_ool_size_small;
vm_map_entry_t tmp_entry;
register
vm_map_entry_t new_entry = VM_MAP_ENTRY_NULL;
vm_offset_t src_start;
vm_offset_t src_end;
vm_offset_t base_start;
vm_offset_t base_end;
vm_map_t base_map=src_map;
vm_map_entry_t base_entry;
boolean_t map_share=FALSE;
submap_map_t *parent_maps = NULL;
register
vm_map_copy_t copy;
vm_offset_t copy_addr;
if (len == 0) {
*copy_result = VM_MAP_COPY_NULL;
return(KERN_SUCCESS);
}
if ((len < msg_ool_size_small) && !use_maxprot)
return vm_map_copyin_kernel_buffer(src_map, src_addr, len,
src_destroy, copy_result);
src_start = trunc_page_32(src_addr);
src_end = round_page_32(src_addr + len);
XPR(XPR_VM_MAP, "vm_map_copyin_common map 0x%x addr 0x%x len 0x%x dest %d\n", (natural_t)src_map, src_addr, len, src_destroy, 0);
if (src_end <= src_start)
if ((src_end < src_start) || (src_start != 0))
return(KERN_INVALID_ADDRESS);
copy = (vm_map_copy_t) zalloc(vm_map_copy_zone);
vm_map_copy_first_entry(copy) =
vm_map_copy_last_entry(copy) = vm_map_copy_to_entry(copy);
copy->type = VM_MAP_COPY_ENTRY_LIST;
copy->cpy_hdr.nentries = 0;
copy->cpy_hdr.entries_pageable = TRUE;
copy->offset = src_addr;
copy->size = len;
new_entry = vm_map_copy_entry_create(copy);
#define RETURN(x) \
MACRO_BEGIN \
vm_map_unlock(src_map); \
if(src_map != base_map) \
vm_map_deallocate(src_map); \
if (new_entry != VM_MAP_ENTRY_NULL) \
vm_map_copy_entry_dispose(copy,new_entry); \
vm_map_copy_discard(copy); \
{ \
submap_map_t *ptr; \
\
for(ptr = parent_maps; ptr != NULL; ptr = parent_maps) { \
parent_maps=parent_maps->next; \
if (ptr->parent_map != base_map) \
vm_map_deallocate(ptr->parent_map); \
kfree((vm_offset_t)ptr, sizeof(submap_map_t)); \
} \
} \
MACRO_RETURN(x); \
MACRO_END
vm_map_lock(src_map);
if (!vm_map_lookup_entry(src_map, src_start, &tmp_entry))
RETURN(KERN_INVALID_ADDRESS);
if(!tmp_entry->is_sub_map) {
vm_map_clip_start(src_map, tmp_entry, src_start);
}
copy_addr = src_start;
while (TRUE) {
register
vm_map_entry_t src_entry = tmp_entry;
vm_size_t src_size;
register
vm_object_t src_object;
vm_object_offset_t src_offset;
boolean_t src_needs_copy;
boolean_t new_entry_needs_copy;
boolean_t was_wired;
vm_map_version_t version;
kern_return_t result;
while(tmp_entry->is_sub_map) {
vm_size_t submap_len;
submap_map_t *ptr;
ptr = (submap_map_t *)kalloc(sizeof(submap_map_t));
ptr->next = parent_maps;
parent_maps = ptr;
ptr->parent_map = src_map;
ptr->base_start = src_start;
ptr->base_end = src_end;
submap_len = tmp_entry->vme_end - src_start;
if(submap_len > (src_end-src_start))
submap_len = src_end-src_start;
ptr->base_start += submap_len;
src_start -= tmp_entry->vme_start;
src_start += tmp_entry->offset;
src_end = src_start + submap_len;
src_map = tmp_entry->object.sub_map;
vm_map_lock(src_map);
vm_map_reference(src_map);
vm_map_unlock(ptr->parent_map);
if (!vm_map_lookup_entry(
src_map, src_start, &tmp_entry))
RETURN(KERN_INVALID_ADDRESS);
map_share = TRUE;
if(!tmp_entry->is_sub_map)
vm_map_clip_start(src_map, tmp_entry, src_start);
src_entry = tmp_entry;
}
if ((tmp_entry->object.vm_object != VM_OBJECT_NULL) &&
(tmp_entry->object.vm_object->phys_contiguous)) {
RETURN(KERN_PROTECTION_FAILURE);
}
if (new_entry == VM_MAP_ENTRY_NULL) {
version.main_timestamp = src_map->timestamp;
vm_map_unlock(src_map);
new_entry = vm_map_copy_entry_create(copy);
vm_map_lock(src_map);
if ((version.main_timestamp + 1) != src_map->timestamp) {
if (!vm_map_lookup_entry(src_map, src_start,
&tmp_entry)) {
RETURN(KERN_INVALID_ADDRESS);
}
vm_map_clip_start(src_map, tmp_entry, src_start);
continue;
}
}
if (((src_entry->protection & VM_PROT_READ) == VM_PROT_NONE &&
!use_maxprot) ||
(src_entry->max_protection & VM_PROT_READ) == 0)
RETURN(KERN_PROTECTION_FAILURE);
vm_map_clip_end(src_map, src_entry, src_end);
src_size = src_entry->vme_end - src_start;
src_object = src_entry->object.vm_object;
src_offset = src_entry->offset;
was_wired = (src_entry->wired_count != 0);
vm_map_entry_copy(new_entry, src_entry);
new_entry->use_pmap = FALSE;
if (src_destroy &&
(src_object == VM_OBJECT_NULL ||
(src_object->internal && !src_object->true_share
&& !map_share))) {
vm_object_reference(src_object);
goto CopySuccessful;
}
RestartCopy:
XPR(XPR_VM_MAP, "vm_map_copyin_common src_obj 0x%x ent 0x%x obj 0x%x was_wired %d\n",
src_object, new_entry, new_entry->object.vm_object,
was_wired, 0);
if ((src_object == VM_OBJECT_NULL ||
(!was_wired && !map_share && !tmp_entry->is_shared)) &&
vm_object_copy_quickly(
&new_entry->object.vm_object,
src_offset,
src_size,
&src_needs_copy,
&new_entry_needs_copy)) {
new_entry->needs_copy = new_entry_needs_copy;
if (src_needs_copy && !tmp_entry->needs_copy) {
vm_object_pmap_protect(
src_object,
src_offset,
src_size,
(src_entry->is_shared ?
PMAP_NULL
: src_map->pmap),
src_entry->vme_start,
src_entry->protection &
~VM_PROT_WRITE);
tmp_entry->needs_copy = TRUE;
}
goto CopySuccessful;
}
assert(src_object != VM_OBJECT_NULL);
vm_object_reference(src_object);
version.main_timestamp = src_map->timestamp;
vm_map_unlock(src_map);
if (was_wired) {
CopySlowly:
vm_object_lock(src_object);
result = vm_object_copy_slowly(
src_object,
src_offset,
src_size,
THREAD_UNINT,
&new_entry->object.vm_object);
new_entry->offset = 0;
new_entry->needs_copy = FALSE;
}
else if (src_object->copy_strategy == MEMORY_OBJECT_COPY_SYMMETRIC &&
(tmp_entry->is_shared || map_share)) {
vm_object_t new_object;
vm_object_lock(src_object);
new_object = vm_object_copy_delayed(
src_object,
src_offset,
src_size);
if (new_object == VM_OBJECT_NULL)
goto CopySlowly;
new_entry->object.vm_object = new_object;
new_entry->needs_copy = TRUE;
result = KERN_SUCCESS;
} else {
result = vm_object_copy_strategically(src_object,
src_offset,
src_size,
&new_entry->object.vm_object,
&new_entry->offset,
&new_entry_needs_copy);
new_entry->needs_copy = new_entry_needs_copy;
}
if (result != KERN_SUCCESS &&
result != KERN_MEMORY_RESTART_COPY) {
vm_map_lock(src_map);
RETURN(result);
}
vm_object_deallocate(src_object);
vm_map_lock(src_map);
if ((version.main_timestamp + 1) == src_map->timestamp)
goto VerificationSuccessful;
if (!vm_map_lookup_entry(src_map, src_start, &tmp_entry)) {
RETURN(KERN_INVALID_ADDRESS);
}
src_entry = tmp_entry;
vm_map_clip_start(src_map, src_entry, src_start);
if ((src_entry->protection & VM_PROT_READ == VM_PROT_NONE &&
!use_maxprot) ||
src_entry->max_protection & VM_PROT_READ == 0)
goto VerificationFailed;
if (src_entry->vme_end < new_entry->vme_end)
src_size = (new_entry->vme_end = src_entry->vme_end) - src_start;
if ((src_entry->object.vm_object != src_object) ||
(src_entry->offset != src_offset) ) {
VerificationFailed: ;
vm_object_deallocate(new_entry->object.vm_object);
tmp_entry = src_entry;
continue;
}
VerificationSuccessful: ;
if (result == KERN_MEMORY_RESTART_COPY)
goto RestartCopy;
CopySuccessful: ;
vm_map_copy_entry_link(copy, vm_map_copy_last_entry(copy),
new_entry);
src_start = new_entry->vme_end;
new_entry = VM_MAP_ENTRY_NULL;
while ((src_start >= src_end) && (src_end != 0)) {
if (src_map != base_map) {
submap_map_t *ptr;
ptr = parent_maps;
assert(ptr != NULL);
parent_maps = parent_maps->next;
vm_map_unlock(src_map);
vm_map_deallocate(src_map);
vm_map_lock(ptr->parent_map);
src_map = ptr->parent_map;
src_start = ptr->base_start;
src_end = ptr->base_end;
if ((src_end > src_start) &&
!vm_map_lookup_entry(
src_map, src_start, &tmp_entry))
RETURN(KERN_INVALID_ADDRESS);
kfree((vm_offset_t)ptr, sizeof(submap_map_t));
if(parent_maps == NULL)
map_share = FALSE;
src_entry = tmp_entry->vme_prev;
} else
break;
}
if ((src_start >= src_end) && (src_end != 0))
break;
tmp_entry = src_entry->vme_next;
if ((tmp_entry->vme_start != src_start) ||
(tmp_entry == vm_map_to_entry(src_map)))
RETURN(KERN_INVALID_ADDRESS);
}
if (src_destroy) {
(void) vm_map_delete(src_map,
trunc_page_32(src_addr),
src_end,
(src_map == kernel_map) ?
VM_MAP_REMOVE_KUNWIRE :
VM_MAP_NO_FLAGS);
}
vm_map_unlock(src_map);
tmp_entry = vm_map_copy_first_entry(copy);
while (tmp_entry != vm_map_copy_to_entry(copy)) {
tmp_entry->vme_end = copy_addr +
(tmp_entry->vme_end - tmp_entry->vme_start);
tmp_entry->vme_start = copy_addr;
copy_addr += tmp_entry->vme_end - tmp_entry->vme_start;
tmp_entry = (struct vm_map_entry *)tmp_entry->vme_next;
}
*copy_result = copy;
return(KERN_SUCCESS);
#undef RETURN
}
kern_return_t
vm_map_copyin_object(
vm_object_t object,
vm_object_offset_t offset,
vm_object_size_t size,
vm_map_copy_t *copy_result)
{
vm_map_copy_t copy;
copy = (vm_map_copy_t) zalloc(vm_map_copy_zone);
copy->type = VM_MAP_COPY_OBJECT;
copy->cpy_object = object;
copy->cpy_index = 0;
copy->offset = offset;
copy->size = size;
*copy_result = copy;
return(KERN_SUCCESS);
}
void
vm_map_fork_share(
vm_map_t old_map,
vm_map_entry_t old_entry,
vm_map_t new_map)
{
vm_object_t object;
vm_map_entry_t new_entry;
kern_return_t result;
object = old_entry->object.vm_object;
if (old_entry->is_sub_map) {
assert(old_entry->wired_count == 0);
#ifndef i386
if(old_entry->use_pmap) {
result = pmap_nest(new_map->pmap,
(old_entry->object.sub_map)->pmap,
(addr64_t)old_entry->vme_start,
(addr64_t)old_entry->vme_start,
(uint64_t)(old_entry->vme_end - old_entry->vme_start));
if(result)
panic("vm_map_fork_share: pmap_nest failed!");
}
#endif
} else if (object == VM_OBJECT_NULL) {
object = vm_object_allocate((vm_size_t)(old_entry->vme_end -
old_entry->vme_start));
old_entry->offset = 0;
old_entry->object.vm_object = object;
assert(!old_entry->needs_copy);
} else if (object->copy_strategy !=
MEMORY_OBJECT_COPY_SYMMETRIC) {
assert(! old_entry->needs_copy);
}
else if (old_entry->needs_copy ||
object->shadowed ||
(!object->true_share &&
!old_entry->is_shared &&
(object->size >
(vm_size_t)(old_entry->vme_end -
old_entry->vme_start)))) {
assert(!(object->shadowed && old_entry->is_shared));
vm_object_shadow(&old_entry->object.vm_object,
&old_entry->offset,
(vm_size_t) (old_entry->vme_end -
old_entry->vme_start));
if (!old_entry->needs_copy &&
(old_entry->protection & VM_PROT_WRITE)) {
if(old_map->mapped) {
vm_object_pmap_protect(
old_entry->object.vm_object,
old_entry->offset,
(old_entry->vme_end -
old_entry->vme_start),
PMAP_NULL,
old_entry->vme_start,
old_entry->protection & ~VM_PROT_WRITE);
} else {
pmap_protect(old_map->pmap,
old_entry->vme_start,
old_entry->vme_end,
old_entry->protection & ~VM_PROT_WRITE);
}
}
old_entry->needs_copy = FALSE;
object = old_entry->object.vm_object;
}
if(old_entry->is_sub_map) {
vm_map_lock(old_entry->object.sub_map);
vm_map_reference(old_entry->object.sub_map);
vm_map_unlock(old_entry->object.sub_map);
} else {
vm_object_lock(object);
object->ref_count++;
vm_object_res_reference(object);
if (object->copy_strategy == MEMORY_OBJECT_COPY_SYMMETRIC) {
object->copy_strategy = MEMORY_OBJECT_COPY_DELAY;
}
vm_object_unlock(object);
}
new_entry = vm_map_entry_create(new_map);
vm_map_entry_copy(new_entry, old_entry);
old_entry->is_shared = TRUE;
new_entry->is_shared = TRUE;
vm_map_entry_link(new_map, vm_map_last_entry(new_map), new_entry);
if (old_entry->is_sub_map) {
} else {
pmap_copy(new_map->pmap, old_map->pmap, new_entry->vme_start,
old_entry->vme_end - old_entry->vme_start,
old_entry->vme_start);
}
}
boolean_t
vm_map_fork_copy(
vm_map_t old_map,
vm_map_entry_t *old_entry_p,
vm_map_t new_map)
{
vm_map_entry_t old_entry = *old_entry_p;
vm_size_t entry_size = old_entry->vme_end - old_entry->vme_start;
vm_offset_t start = old_entry->vme_start;
vm_map_copy_t copy;
vm_map_entry_t last = vm_map_last_entry(new_map);
vm_map_unlock(old_map);
if (vm_map_copyin_maxprot(old_map, start, entry_size, FALSE, ©)
!= KERN_SUCCESS) {
vm_map_lock(old_map);
if (!vm_map_lookup_entry(old_map, start, &last) ||
last->max_protection & VM_PROT_READ ==
VM_PROT_NONE) {
last = last->vme_next;
}
*old_entry_p = last;
return FALSE;
}
vm_map_copy_insert(new_map, last, copy);
vm_map_lock(old_map);
start += entry_size;
if (! vm_map_lookup_entry(old_map, start, &last)) {
last = last->vme_next;
} else {
vm_map_clip_start(old_map, last, start);
}
*old_entry_p = last;
return TRUE;
}
vm_map_t
vm_map_fork(
vm_map_t old_map)
{
pmap_t new_pmap = pmap_create((vm_size_t) 0);
vm_map_t new_map;
vm_map_entry_t old_entry;
vm_size_t new_size = 0, entry_size;
vm_map_entry_t new_entry;
boolean_t src_needs_copy;
boolean_t new_entry_needs_copy;
vm_map_reference_swap(old_map);
vm_map_lock(old_map);
new_map = vm_map_create(new_pmap,
old_map->min_offset,
old_map->max_offset,
old_map->hdr.entries_pageable);
for (
old_entry = vm_map_first_entry(old_map);
old_entry != vm_map_to_entry(old_map);
) {
entry_size = old_entry->vme_end - old_entry->vme_start;
switch (old_entry->inheritance) {
case VM_INHERIT_NONE:
break;
case VM_INHERIT_SHARE:
vm_map_fork_share(old_map, old_entry, new_map);
new_size += entry_size;
break;
case VM_INHERIT_COPY:
if(old_entry->is_sub_map)
break;
if ((old_entry->wired_count != 0) ||
((old_entry->object.vm_object != NULL) &&
(old_entry->object.vm_object->true_share))) {
goto slow_vm_map_fork_copy;
}
new_entry = vm_map_entry_create(new_map);
vm_map_entry_copy(new_entry, old_entry);
new_entry->use_pmap = FALSE;
if (! vm_object_copy_quickly(
&new_entry->object.vm_object,
old_entry->offset,
(old_entry->vme_end -
old_entry->vme_start),
&src_needs_copy,
&new_entry_needs_copy)) {
vm_map_entry_dispose(new_map, new_entry);
goto slow_vm_map_fork_copy;
}
if (src_needs_copy && !old_entry->needs_copy) {
vm_object_pmap_protect(
old_entry->object.vm_object,
old_entry->offset,
(old_entry->vme_end -
old_entry->vme_start),
((old_entry->is_shared
|| old_map->mapped)
? PMAP_NULL :
old_map->pmap),
old_entry->vme_start,
old_entry->protection & ~VM_PROT_WRITE);
old_entry->needs_copy = TRUE;
}
new_entry->needs_copy = new_entry_needs_copy;
vm_map_entry_link(new_map, vm_map_last_entry(new_map),
new_entry);
new_size += entry_size;
break;
slow_vm_map_fork_copy:
if (vm_map_fork_copy(old_map, &old_entry, new_map)) {
new_size += entry_size;
}
continue;
}
old_entry = old_entry->vme_next;
}
new_map->size = new_size;
vm_map_unlock(old_map);
vm_map_deallocate(old_map);
return(new_map);
}
kern_return_t
vm_map_lookup_locked(
vm_map_t *var_map,
register vm_offset_t vaddr,
register vm_prot_t fault_type,
vm_map_version_t *out_version,
vm_object_t *object,
vm_object_offset_t *offset,
vm_prot_t *out_prot,
boolean_t *wired,
int *behavior,
vm_object_offset_t *lo_offset,
vm_object_offset_t *hi_offset,
vm_map_t *pmap_map)
{
vm_map_entry_t entry;
register vm_map_t map = *var_map;
vm_map_t old_map = *var_map;
vm_map_t cow_sub_map_parent = VM_MAP_NULL;
vm_offset_t cow_parent_vaddr;
vm_offset_t old_start;
vm_offset_t old_end;
register vm_prot_t prot;
*pmap_map = map;
RetryLookup: ;
mutex_lock(&map->s_lock);
entry = map->hint;
mutex_unlock(&map->s_lock);
if ((entry == vm_map_to_entry(map)) ||
(vaddr < entry->vme_start) || (vaddr >= entry->vme_end)) {
vm_map_entry_t tmp_entry;
if (!vm_map_lookup_entry(map, vaddr, &tmp_entry)) {
if((cow_sub_map_parent) && (cow_sub_map_parent != map))
vm_map_unlock(cow_sub_map_parent);
if((*pmap_map != map)
&& (*pmap_map != cow_sub_map_parent))
vm_map_unlock(*pmap_map);
return KERN_INVALID_ADDRESS;
}
entry = tmp_entry;
}
if(map == old_map) {
old_start = entry->vme_start;
old_end = entry->vme_end;
}
submap_recurse:
if (entry->is_sub_map) {
vm_offset_t local_vaddr;
vm_offset_t end_delta;
vm_offset_t start_delta;
vm_offset_t object_start_delta;
vm_map_entry_t submap_entry;
boolean_t mapped_needs_copy=FALSE;
local_vaddr = vaddr;
if ((!entry->needs_copy) && (entry->use_pmap)) {
if ((*pmap_map != map) &&
(*pmap_map != cow_sub_map_parent))
vm_map_unlock(*pmap_map);
*pmap_map = entry->object.sub_map;
}
if(entry->needs_copy) {
if (!mapped_needs_copy) {
if (vm_map_lock_read_to_write(map)) {
vm_map_lock_read(map);
if(*pmap_map == entry->object.sub_map)
*pmap_map = map;
goto RetryLookup;
}
vm_map_lock_read(entry->object.sub_map);
cow_sub_map_parent = map;
old_start = entry->vme_start;
old_end = entry->vme_end;
cow_parent_vaddr = vaddr;
mapped_needs_copy = TRUE;
} else {
vm_map_lock_read(entry->object.sub_map);
if((cow_sub_map_parent != map) &&
(*pmap_map != map))
vm_map_unlock(map);
}
} else {
vm_map_lock_read(entry->object.sub_map);
if((*pmap_map != map) && (map != cow_sub_map_parent))
vm_map_unlock_read(map);
}
*var_map = map = entry->object.sub_map;
local_vaddr = (local_vaddr - entry->vme_start) + entry->offset;
RetrySubMap:
if(!vm_map_lookup_entry(map, local_vaddr, &submap_entry)) {
if((cow_sub_map_parent) && (cow_sub_map_parent != map)){
vm_map_unlock(cow_sub_map_parent);
}
if((*pmap_map != map)
&& (*pmap_map != cow_sub_map_parent)) {
vm_map_unlock(*pmap_map);
}
*pmap_map = map;
return KERN_INVALID_ADDRESS;
}
start_delta = submap_entry->vme_start > entry->offset ?
submap_entry->vme_start - entry->offset : 0;
end_delta =
(entry->offset + start_delta + (old_end - old_start)) <=
submap_entry->vme_end ?
0 : (entry->offset +
(old_end - old_start))
- submap_entry->vme_end;
old_start += start_delta;
old_end -= end_delta;
if(submap_entry->is_sub_map) {
entry = submap_entry;
vaddr = local_vaddr;
goto submap_recurse;
}
if(((fault_type & VM_PROT_WRITE) && cow_sub_map_parent)) {
vm_object_t copy_object;
vm_offset_t local_start;
vm_offset_t local_end;
boolean_t copied_slowly = FALSE;
if (vm_map_lock_read_to_write(map)) {
vm_map_lock_read(map);
old_start -= start_delta;
old_end += end_delta;
goto RetrySubMap;
}
if (submap_entry->object.vm_object == VM_OBJECT_NULL) {
submap_entry->object.vm_object =
vm_object_allocate(
(vm_size_t)
(submap_entry->vme_end
- submap_entry->vme_start));
submap_entry->offset = 0;
}
local_start = local_vaddr -
(cow_parent_vaddr - old_start);
local_end = local_vaddr +
(old_end - cow_parent_vaddr);
vm_map_clip_start(map, submap_entry, local_start);
vm_map_clip_end(map, submap_entry, local_end);
if(submap_entry->wired_count != 0) {
vm_object_lock(
submap_entry->object.vm_object);
vm_object_copy_slowly(
submap_entry->object.vm_object,
submap_entry->offset,
submap_entry->vme_end -
submap_entry->vme_start,
FALSE,
©_object);
copied_slowly = TRUE;
} else {
copy_object = submap_entry->object.vm_object;
vm_object_reference(copy_object);
submap_entry->object.vm_object->shadowed = TRUE;
submap_entry->needs_copy = TRUE;
vm_object_pmap_protect(
submap_entry->object.vm_object,
submap_entry->offset,
submap_entry->vme_end -
submap_entry->vme_start,
(submap_entry->is_shared
|| map->mapped) ?
PMAP_NULL : map->pmap,
submap_entry->vme_start,
submap_entry->protection &
~VM_PROT_WRITE);
}
vm_map_unlock(map);
local_start = old_start;
local_end = old_end;
map = cow_sub_map_parent;
*var_map = cow_sub_map_parent;
vaddr = cow_parent_vaddr;
cow_sub_map_parent = NULL;
if(!vm_map_lookup_entry(map,
vaddr, &entry)) {
vm_object_deallocate(
copy_object);
vm_map_lock_write_to_read(map);
return KERN_INVALID_ADDRESS;
}
vm_map_clip_start(map, entry, local_start);
vm_map_clip_end(map, entry, local_end);
vm_map_deallocate(entry->object.sub_map);
entry->is_sub_map = FALSE;
entry->object.vm_object = copy_object;
entry->protection |= VM_PROT_WRITE;
entry->max_protection |= VM_PROT_WRITE;
if(copied_slowly) {
entry->offset = 0;
entry->needs_copy = FALSE;
entry->is_shared = FALSE;
} else {
entry->offset = submap_entry->offset;
entry->needs_copy = TRUE;
if(entry->inheritance == VM_INHERIT_SHARE)
entry->inheritance = VM_INHERIT_COPY;
if (map != old_map)
entry->is_shared = TRUE;
}
if(entry->inheritance == VM_INHERIT_SHARE)
entry->inheritance = VM_INHERIT_COPY;
vm_map_lock_write_to_read(map);
} else {
if((cow_sub_map_parent)
&& (cow_sub_map_parent != *pmap_map)
&& (cow_sub_map_parent != map)) {
vm_map_unlock(cow_sub_map_parent);
}
entry = submap_entry;
vaddr = local_vaddr;
}
}
prot = entry->protection;
if ((fault_type & (prot)) != fault_type) {
if (*pmap_map != map) {
vm_map_unlock(*pmap_map);
}
*pmap_map = map;
return KERN_PROTECTION_FAILURE;
}
if (*wired = (entry->wired_count != 0))
prot = fault_type = entry->protection;
if (entry->needs_copy) {
if (fault_type & VM_PROT_WRITE || *wired) {
if (vm_map_lock_read_to_write(map)) {
vm_map_lock_read(map);
goto RetryLookup;
}
vm_object_shadow(&entry->object.vm_object,
&entry->offset,
(vm_size_t) (entry->vme_end -
entry->vme_start));
entry->object.vm_object->shadowed = TRUE;
entry->needs_copy = FALSE;
vm_map_lock_write_to_read(map);
}
else {
prot &= (~VM_PROT_WRITE);
}
}
if (entry->object.vm_object == VM_OBJECT_NULL) {
if (vm_map_lock_read_to_write(map)) {
vm_map_lock_read(map);
goto RetryLookup;
}
entry->object.vm_object = vm_object_allocate(
(vm_size_t)(entry->vme_end - entry->vme_start));
entry->offset = 0;
vm_map_lock_write_to_read(map);
}
*offset = (vaddr - entry->vme_start) + entry->offset;
*object = entry->object.vm_object;
*out_prot = prot;
*behavior = entry->behavior;
*lo_offset = entry->offset;
*hi_offset = (entry->vme_end - entry->vme_start) + entry->offset;
vm_object_lock(*object);
out_version->main_timestamp = map->timestamp;
return KERN_SUCCESS;
}
boolean_t
vm_map_verify(
register vm_map_t map,
register vm_map_version_t *version)
{
boolean_t result;
vm_map_lock_read(map);
result = (map->timestamp == version->main_timestamp);
if (!result)
vm_map_unlock_read(map);
return(result);
}
kern_return_t
vm_region(
vm_map_t map,
vm_offset_t *address,
vm_size_t *size,
vm_region_flavor_t flavor,
vm_region_info_t info,
mach_msg_type_number_t *count,
ipc_port_t *object_name)
{
vm_map_entry_t tmp_entry;
register
vm_map_entry_t entry;
register
vm_offset_t start;
vm_region_basic_info_t basic;
vm_region_extended_info_t extended;
vm_region_top_info_t top;
if (map == VM_MAP_NULL)
return(KERN_INVALID_ARGUMENT);
switch (flavor) {
case VM_REGION_BASIC_INFO:
{
if (*count < VM_REGION_BASIC_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
basic = (vm_region_basic_info_t) info;
*count = VM_REGION_BASIC_INFO_COUNT;
vm_map_lock_read(map);
start = *address;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
start = entry->vme_start;
basic->offset = entry->offset;
basic->protection = entry->protection;
basic->inheritance = entry->inheritance;
basic->max_protection = entry->max_protection;
basic->behavior = entry->behavior;
basic->user_wired_count = entry->user_wired_count;
basic->reserved = entry->is_sub_map;
*address = start;
*size = (entry->vme_end - start);
if (object_name) *object_name = IP_NULL;
if (entry->is_sub_map) {
basic->shared = FALSE;
} else {
basic->shared = entry->is_shared;
}
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
case VM_REGION_EXTENDED_INFO:
{
if (*count < VM_REGION_EXTENDED_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
extended = (vm_region_extended_info_t) info;
*count = VM_REGION_EXTENDED_INFO_COUNT;
vm_map_lock_read(map);
start = *address;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
start = entry->vme_start;
extended->protection = entry->protection;
extended->user_tag = entry->alias;
extended->pages_resident = 0;
extended->pages_swapped_out = 0;
extended->pages_shared_now_private = 0;
extended->pages_dirtied = 0;
extended->external_pager = 0;
extended->shadow_depth = 0;
vm_region_walk(entry, extended, entry->offset, entry->vme_end - start, map, start);
if (extended->external_pager && extended->ref_count == 2 && extended->share_mode == SM_SHARED)
extended->share_mode = SM_PRIVATE;
if (object_name)
*object_name = IP_NULL;
*address = start;
*size = (entry->vme_end - start);
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
case VM_REGION_TOP_INFO:
{
if (*count < VM_REGION_TOP_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
top = (vm_region_top_info_t) info;
*count = VM_REGION_TOP_INFO_COUNT;
vm_map_lock_read(map);
start = *address;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
start = entry->vme_start;
top->private_pages_resident = 0;
top->shared_pages_resident = 0;
vm_region_top_walk(entry, top);
if (object_name)
*object_name = IP_NULL;
*address = start;
*size = (entry->vme_end - start);
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
default:
return(KERN_INVALID_ARGUMENT);
}
}
kern_return_t
vm_region_recurse(
vm_map_t map,
vm_offset_t *address,
vm_size_t *size,
natural_t *nesting_depth,
vm_region_recurse_info_t info,
mach_msg_type_number_t *count)
{
vm_map_entry_t tmp_entry;
register
vm_map_entry_t entry;
register
vm_offset_t start;
unsigned int recurse_count;
vm_map_t submap;
vm_map_t base_map;
vm_map_entry_t base_entry;
vm_offset_t base_next;
vm_offset_t base_addr;
vm_offset_t baddr_start_delta;
vm_region_submap_info_t submap_info;
vm_region_extended_info_data_t extended;
if (map == VM_MAP_NULL)
return(KERN_INVALID_ARGUMENT);
submap_info = (vm_region_submap_info_t) info;
*count = VM_REGION_SUBMAP_INFO_COUNT;
if (*count < VM_REGION_SUBMAP_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
start = *address;
base_map = map;
recurse_count = *nesting_depth;
LOOKUP_NEXT_BASE_ENTRY:
vm_map_lock_read(map);
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
*size = entry->vme_end - entry->vme_start;
start = entry->vme_start;
base_addr = start;
baddr_start_delta = *address - start;
base_next = entry->vme_end;
base_entry = entry;
while(entry->is_sub_map && recurse_count) {
recurse_count--;
vm_map_lock_read(entry->object.sub_map);
if(entry == base_entry) {
start = entry->offset;
start += *address - entry->vme_start;
}
submap = entry->object.sub_map;
vm_map_unlock_read(map);
map = submap;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next)
== vm_map_to_entry(map)) {
vm_map_unlock_read(map);
map = base_map;
start = base_next;
recurse_count = 0;
*nesting_depth = 0;
goto LOOKUP_NEXT_BASE_ENTRY;
}
} else {
entry = tmp_entry;
}
if(start <= entry->vme_start) {
vm_offset_t old_start = start;
if(baddr_start_delta) {
base_addr += (baddr_start_delta);
*size -= baddr_start_delta;
baddr_start_delta = 0;
}
if(base_next <=
(base_addr += (entry->vme_start - start))) {
vm_map_unlock_read(map);
map = base_map;
start = base_next;
recurse_count = 0;
*nesting_depth = 0;
goto LOOKUP_NEXT_BASE_ENTRY;
}
*size -= entry->vme_start - start;
if (*size > (entry->vme_end - entry->vme_start)) {
*size = entry->vme_end - entry->vme_start;
}
start = 0;
} else {
if(baddr_start_delta) {
if((start - entry->vme_start)
< baddr_start_delta) {
base_addr += start - entry->vme_start;
*size -= start - entry->vme_start;
} else {
base_addr += baddr_start_delta;
*size += baddr_start_delta;
}
baddr_start_delta = 0;
}
base_addr += entry->vme_start;
if(base_addr >= base_next) {
vm_map_unlock_read(map);
map = base_map;
start = base_next;
recurse_count = 0;
*nesting_depth = 0;
goto LOOKUP_NEXT_BASE_ENTRY;
}
if (*size > (entry->vme_end - start))
*size = entry->vme_end - start;
start = entry->vme_start - start;
}
start += entry->offset;
}
*nesting_depth -= recurse_count;
if(entry != base_entry) {
start = entry->vme_start + (start - entry->offset);
}
submap_info->user_tag = entry->alias;
submap_info->offset = entry->offset;
submap_info->protection = entry->protection;
submap_info->inheritance = entry->inheritance;
submap_info->max_protection = entry->max_protection;
submap_info->behavior = entry->behavior;
submap_info->user_wired_count = entry->user_wired_count;
submap_info->is_submap = entry->is_sub_map;
submap_info->object_id = (vm_offset_t)entry->object.vm_object;
*address = base_addr;
extended.pages_resident = 0;
extended.pages_swapped_out = 0;
extended.pages_shared_now_private = 0;
extended.pages_dirtied = 0;
extended.external_pager = 0;
extended.shadow_depth = 0;
if(!entry->is_sub_map) {
vm_region_walk(entry, &extended, entry->offset,
entry->vme_end - start, map, start);
submap_info->share_mode = extended.share_mode;
if (extended.external_pager && extended.ref_count == 2
&& extended.share_mode == SM_SHARED)
submap_info->share_mode = SM_PRIVATE;
submap_info->ref_count = extended.ref_count;
} else {
if(entry->use_pmap)
submap_info->share_mode = SM_TRUESHARED;
else
submap_info->share_mode = SM_PRIVATE;
submap_info->ref_count = entry->object.sub_map->ref_count;
}
submap_info->pages_resident = extended.pages_resident;
submap_info->pages_swapped_out = extended.pages_swapped_out;
submap_info->pages_shared_now_private =
extended.pages_shared_now_private;
submap_info->pages_dirtied = extended.pages_dirtied;
submap_info->external_pager = extended.external_pager;
submap_info->shadow_depth = extended.shadow_depth;
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
kern_return_t
vm_region_recurse_64(
vm_map_t map,
vm_offset_t *address,
vm_size_t *size,
natural_t *nesting_depth,
vm_region_recurse_info_t info,
mach_msg_type_number_t *count)
{
vm_map_entry_t tmp_entry;
register
vm_map_entry_t entry;
register
vm_offset_t start;
unsigned int recurse_count;
vm_map_t submap;
vm_map_t base_map;
vm_map_entry_t base_entry;
vm_offset_t base_next;
vm_offset_t base_addr;
vm_offset_t baddr_start_delta;
vm_region_submap_info_64_t submap_info;
vm_region_extended_info_data_t extended;
if (map == VM_MAP_NULL)
return(KERN_INVALID_ARGUMENT);
submap_info = (vm_region_submap_info_64_t) info;
*count = VM_REGION_SUBMAP_INFO_COUNT;
if (*count < VM_REGION_SUBMAP_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
start = *address;
base_map = map;
recurse_count = *nesting_depth;
LOOKUP_NEXT_BASE_ENTRY:
vm_map_lock_read(map);
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
*size = entry->vme_end - entry->vme_start;
start = entry->vme_start;
base_addr = start;
baddr_start_delta = *address - start;
base_next = entry->vme_end;
base_entry = entry;
while(entry->is_sub_map && recurse_count) {
recurse_count--;
vm_map_lock_read(entry->object.sub_map);
if(entry == base_entry) {
start = entry->offset;
start += *address - entry->vme_start;
}
submap = entry->object.sub_map;
vm_map_unlock_read(map);
map = submap;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next)
== vm_map_to_entry(map)) {
vm_map_unlock_read(map);
map = base_map;
start = base_next;
recurse_count = 0;
*nesting_depth = 0;
goto LOOKUP_NEXT_BASE_ENTRY;
}
} else {
entry = tmp_entry;
}
if(start <= entry->vme_start) {
vm_offset_t old_start = start;
if(baddr_start_delta) {
base_addr += (baddr_start_delta);
*size -= baddr_start_delta;
baddr_start_delta = 0;
}
if(base_next <=
(base_addr += (entry->vme_start - start))) {
vm_map_unlock_read(map);
map = base_map;
start = base_next;
recurse_count = 0;
*nesting_depth = 0;
goto LOOKUP_NEXT_BASE_ENTRY;
}
*size -= entry->vme_start - start;
if (*size > (entry->vme_end - entry->vme_start)) {
*size = entry->vme_end - entry->vme_start;
}
start = 0;
} else {
if(baddr_start_delta) {
if((start - entry->vme_start)
< baddr_start_delta) {
base_addr += start - entry->vme_start;
*size -= start - entry->vme_start;
} else {
base_addr += baddr_start_delta;
*size += baddr_start_delta;
}
baddr_start_delta = 0;
}
base_addr += entry->vme_start;
if(base_addr >= base_next) {
vm_map_unlock_read(map);
map = base_map;
start = base_next;
recurse_count = 0;
*nesting_depth = 0;
goto LOOKUP_NEXT_BASE_ENTRY;
}
if (*size > (entry->vme_end - start))
*size = entry->vme_end - start;
start = entry->vme_start - start;
}
start += entry->offset;
}
*nesting_depth -= recurse_count;
if(entry != base_entry) {
start = entry->vme_start + (start - entry->offset);
}
submap_info->user_tag = entry->alias;
submap_info->offset = entry->offset;
submap_info->protection = entry->protection;
submap_info->inheritance = entry->inheritance;
submap_info->max_protection = entry->max_protection;
submap_info->behavior = entry->behavior;
submap_info->user_wired_count = entry->user_wired_count;
submap_info->is_submap = entry->is_sub_map;
submap_info->object_id = (vm_offset_t)entry->object.vm_object;
*address = base_addr;
extended.pages_resident = 0;
extended.pages_swapped_out = 0;
extended.pages_shared_now_private = 0;
extended.pages_dirtied = 0;
extended.external_pager = 0;
extended.shadow_depth = 0;
if(!entry->is_sub_map) {
vm_region_walk(entry, &extended, entry->offset,
entry->vme_end - start, map, start);
submap_info->share_mode = extended.share_mode;
if (extended.external_pager && extended.ref_count == 2
&& extended.share_mode == SM_SHARED)
submap_info->share_mode = SM_PRIVATE;
submap_info->ref_count = extended.ref_count;
} else {
if(entry->use_pmap)
submap_info->share_mode = SM_TRUESHARED;
else
submap_info->share_mode = SM_PRIVATE;
submap_info->ref_count = entry->object.sub_map->ref_count;
}
submap_info->pages_resident = extended.pages_resident;
submap_info->pages_swapped_out = extended.pages_swapped_out;
submap_info->pages_shared_now_private =
extended.pages_shared_now_private;
submap_info->pages_dirtied = extended.pages_dirtied;
submap_info->external_pager = extended.external_pager;
submap_info->shadow_depth = extended.shadow_depth;
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
kern_return_t
vm_region_64(
vm_map_t map,
vm_offset_t *address,
vm_size_t *size,
vm_region_flavor_t flavor,
vm_region_info_t info,
mach_msg_type_number_t *count,
ipc_port_t *object_name)
{
vm_map_entry_t tmp_entry;
register
vm_map_entry_t entry;
register
vm_offset_t start;
vm_region_basic_info_64_t basic;
vm_region_extended_info_t extended;
vm_region_top_info_t top;
if (map == VM_MAP_NULL)
return(KERN_INVALID_ARGUMENT);
switch (flavor) {
case VM_REGION_BASIC_INFO:
{
if (*count < VM_REGION_BASIC_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
basic = (vm_region_basic_info_64_t) info;
*count = VM_REGION_BASIC_INFO_COUNT;
vm_map_lock_read(map);
start = *address;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
start = entry->vme_start;
basic->offset = entry->offset;
basic->protection = entry->protection;
basic->inheritance = entry->inheritance;
basic->max_protection = entry->max_protection;
basic->behavior = entry->behavior;
basic->user_wired_count = entry->user_wired_count;
basic->reserved = entry->is_sub_map;
*address = start;
*size = (entry->vme_end - start);
if (object_name) *object_name = IP_NULL;
if (entry->is_sub_map) {
basic->shared = FALSE;
} else {
basic->shared = entry->is_shared;
}
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
case VM_REGION_EXTENDED_INFO:
{
if (*count < VM_REGION_EXTENDED_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
extended = (vm_region_extended_info_t) info;
*count = VM_REGION_EXTENDED_INFO_COUNT;
vm_map_lock_read(map);
start = *address;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
start = entry->vme_start;
extended->protection = entry->protection;
extended->user_tag = entry->alias;
extended->pages_resident = 0;
extended->pages_swapped_out = 0;
extended->pages_shared_now_private = 0;
extended->pages_dirtied = 0;
extended->external_pager = 0;
extended->shadow_depth = 0;
vm_region_walk(entry, extended, entry->offset, entry->vme_end - start, map, start);
if (extended->external_pager && extended->ref_count == 2 && extended->share_mode == SM_SHARED)
extended->share_mode = SM_PRIVATE;
if (object_name)
*object_name = IP_NULL;
*address = start;
*size = (entry->vme_end - start);
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
case VM_REGION_TOP_INFO:
{
if (*count < VM_REGION_TOP_INFO_COUNT)
return(KERN_INVALID_ARGUMENT);
top = (vm_region_top_info_t) info;
*count = VM_REGION_TOP_INFO_COUNT;
vm_map_lock_read(map);
start = *address;
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
if ((entry = tmp_entry->vme_next) == vm_map_to_entry(map)) {
vm_map_unlock_read(map);
return(KERN_INVALID_ADDRESS);
}
} else {
entry = tmp_entry;
}
start = entry->vme_start;
top->private_pages_resident = 0;
top->shared_pages_resident = 0;
vm_region_top_walk(entry, top);
if (object_name)
*object_name = IP_NULL;
*address = start;
*size = (entry->vme_end - start);
vm_map_unlock_read(map);
return(KERN_SUCCESS);
}
default:
return(KERN_INVALID_ARGUMENT);
}
}
void
vm_region_top_walk(
vm_map_entry_t entry,
vm_region_top_info_t top)
{
register struct vm_object *obj, *tmp_obj;
register int ref_count;
if (entry->object.vm_object == 0 || entry->is_sub_map) {
top->share_mode = SM_EMPTY;
top->ref_count = 0;
top->obj_id = 0;
return;
}
{
obj = entry->object.vm_object;
vm_object_lock(obj);
if ((ref_count = obj->ref_count) > 1 && obj->paging_in_progress)
ref_count--;
if (obj->shadow) {
if (ref_count == 1)
top->private_pages_resident = obj->resident_page_count;
else
top->shared_pages_resident = obj->resident_page_count;
top->ref_count = ref_count;
top->share_mode = SM_COW;
while (tmp_obj = obj->shadow) {
vm_object_lock(tmp_obj);
vm_object_unlock(obj);
obj = tmp_obj;
if ((ref_count = obj->ref_count) > 1 && obj->paging_in_progress)
ref_count--;
top->shared_pages_resident += obj->resident_page_count;
top->ref_count += ref_count - 1;
}
} else {
if (entry->needs_copy) {
top->share_mode = SM_COW;
top->shared_pages_resident = obj->resident_page_count;
} else {
if (ref_count == 1 ||
(ref_count == 2 && !(obj->pager_trusted) && !(obj->internal))) {
top->share_mode = SM_PRIVATE;
top->private_pages_resident = obj->resident_page_count;
} else {
top->share_mode = SM_SHARED;
top->shared_pages_resident = obj->resident_page_count;
}
}
top->ref_count = ref_count;
}
top->obj_id = (int)obj;
vm_object_unlock(obj);
}
}
void
vm_region_walk(
vm_map_entry_t entry,
vm_region_extended_info_t extended,
vm_object_offset_t offset,
vm_offset_t range,
vm_map_t map,
vm_offset_t va)
{
register struct vm_object *obj, *tmp_obj;
register vm_offset_t last_offset;
register int i;
register int ref_count;
void vm_region_look_for_page();
if ((entry->object.vm_object == 0) ||
(entry->is_sub_map) ||
(entry->object.vm_object->phys_contiguous)) {
extended->share_mode = SM_EMPTY;
extended->ref_count = 0;
return;
}
{
obj = entry->object.vm_object;
vm_object_lock(obj);
if ((ref_count = obj->ref_count) > 1 && obj->paging_in_progress)
ref_count--;
for (last_offset = offset + range; offset < last_offset; offset += PAGE_SIZE_64, va += PAGE_SIZE)
vm_region_look_for_page(obj, extended, offset, ref_count, 0, map, va);
if (extended->shadow_depth || entry->needs_copy)
extended->share_mode = SM_COW;
else {
if (ref_count == 1)
extended->share_mode = SM_PRIVATE;
else {
if (obj->true_share)
extended->share_mode = SM_TRUESHARED;
else
extended->share_mode = SM_SHARED;
}
}
extended->ref_count = ref_count - extended->shadow_depth;
for (i = 0; i < extended->shadow_depth; i++) {
if ((tmp_obj = obj->shadow) == 0)
break;
vm_object_lock(tmp_obj);
vm_object_unlock(obj);
if ((ref_count = tmp_obj->ref_count) > 1 && tmp_obj->paging_in_progress)
ref_count--;
extended->ref_count += ref_count;
obj = tmp_obj;
}
vm_object_unlock(obj);
if (extended->share_mode == SM_SHARED) {
register vm_map_entry_t cur;
register vm_map_entry_t last;
int my_refs;
obj = entry->object.vm_object;
last = vm_map_to_entry(map);
my_refs = 0;
if ((ref_count = obj->ref_count) > 1 && obj->paging_in_progress)
ref_count--;
for (cur = vm_map_first_entry(map); cur != last; cur = cur->vme_next)
my_refs += vm_region_count_obj_refs(cur, obj);
if (my_refs == ref_count)
extended->share_mode = SM_PRIVATE_ALIASED;
else if (my_refs > 1)
extended->share_mode = SM_SHARED_ALIASED;
}
}
}
void
vm_region_look_for_page(
vm_object_t object,
vm_region_extended_info_t extended,
vm_object_offset_t offset,
int max_refcnt,
int depth,
vm_map_t map,
vm_offset_t va)
{
register vm_page_t p;
register vm_object_t shadow;
register int ref_count;
vm_object_t caller_object;
shadow = object->shadow;
caller_object = object;
while (TRUE) {
if ( !(object->pager_trusted) && !(object->internal))
extended->external_pager = 1;
if ((p = vm_page_lookup(object, offset)) != VM_PAGE_NULL) {
if (shadow && (max_refcnt == 1))
extended->pages_shared_now_private++;
if (!p->fictitious &&
(p->dirty || pmap_is_modified(p->phys_page)))
extended->pages_dirtied++;
extended->pages_resident++;
if(object != caller_object)
vm_object_unlock(object);
return;
}
if (object->existence_map) {
if (vm_external_state_get(object->existence_map, offset) == VM_EXTERNAL_STATE_EXISTS) {
extended->pages_swapped_out++;
if(object != caller_object)
vm_object_unlock(object);
return;
}
}
if (shadow) {
vm_object_lock(shadow);
if ((ref_count = shadow->ref_count) > 1 && shadow->paging_in_progress)
ref_count--;
if (++depth > extended->shadow_depth)
extended->shadow_depth = depth;
if (ref_count > max_refcnt)
max_refcnt = ref_count;
if(object != caller_object)
vm_object_unlock(object);
object = shadow;
shadow = object->shadow;
offset = offset + object->shadow_offset;
continue;
}
if(object != caller_object)
vm_object_unlock(object);
break;
}
}
vm_region_count_obj_refs(
vm_map_entry_t entry,
vm_object_t object)
{
register int ref_count;
register vm_object_t chk_obj;
register vm_object_t tmp_obj;
if (entry->object.vm_object == 0)
return(0);
if (entry->is_sub_map)
return(0);
else {
ref_count = 0;
chk_obj = entry->object.vm_object;
vm_object_lock(chk_obj);
while (chk_obj) {
if (chk_obj == object)
ref_count++;
if (tmp_obj = chk_obj->shadow)
vm_object_lock(tmp_obj);
vm_object_unlock(chk_obj);
chk_obj = tmp_obj;
}
}
return(ref_count);
}
void
vm_map_simplify(
vm_map_t map,
vm_offset_t start)
{
vm_map_entry_t this_entry;
vm_map_entry_t prev_entry;
vm_map_entry_t next_entry;
vm_map_lock(map);
if (
(vm_map_lookup_entry(map, start, &this_entry)) &&
((prev_entry = this_entry->vme_prev) != vm_map_to_entry(map)) &&
(prev_entry->vme_end == this_entry->vme_start) &&
(prev_entry->is_shared == FALSE) &&
(prev_entry->is_sub_map == FALSE) &&
(this_entry->is_shared == FALSE) &&
(this_entry->is_sub_map == FALSE) &&
(prev_entry->inheritance == this_entry->inheritance) &&
(prev_entry->protection == this_entry->protection) &&
(prev_entry->max_protection == this_entry->max_protection) &&
(prev_entry->behavior == this_entry->behavior) &&
(prev_entry->wired_count == this_entry->wired_count) &&
(prev_entry->user_wired_count == this_entry->user_wired_count)&&
(prev_entry->in_transition == FALSE) &&
(this_entry->in_transition == FALSE) &&
(prev_entry->needs_copy == this_entry->needs_copy) &&
(prev_entry->object.vm_object == this_entry->object.vm_object)&&
((prev_entry->offset +
(prev_entry->vme_end - prev_entry->vme_start))
== this_entry->offset)
) {
SAVE_HINT(map, prev_entry);
vm_map_entry_unlink(map, this_entry);
prev_entry->vme_end = this_entry->vme_end;
UPDATE_FIRST_FREE(map, map->first_free);
vm_object_deallocate(this_entry->object.vm_object);
vm_map_entry_dispose(map, this_entry);
counter(c_vm_map_simplified_lower++);
}
if (
(vm_map_lookup_entry(map, start, &this_entry)) &&
((next_entry = this_entry->vme_next) != vm_map_to_entry(map)) &&
(next_entry->vme_start == this_entry->vme_end) &&
(next_entry->is_shared == FALSE) &&
(next_entry->is_sub_map == FALSE) &&
(next_entry->is_shared == FALSE) &&
(next_entry->is_sub_map == FALSE) &&
(next_entry->inheritance == this_entry->inheritance) &&
(next_entry->protection == this_entry->protection) &&
(next_entry->max_protection == this_entry->max_protection) &&
(next_entry->behavior == this_entry->behavior) &&
(next_entry->wired_count == this_entry->wired_count) &&
(next_entry->user_wired_count == this_entry->user_wired_count)&&
(this_entry->in_transition == FALSE) &&
(next_entry->in_transition == FALSE) &&
(next_entry->needs_copy == this_entry->needs_copy) &&
(next_entry->object.vm_object == this_entry->object.vm_object)&&
((this_entry->offset +
(this_entry->vme_end - this_entry->vme_start))
== next_entry->offset)
) {
vm_map_entry_unlink(map, next_entry);
this_entry->vme_end = next_entry->vme_end;
UPDATE_FIRST_FREE(map, map->first_free);
vm_object_deallocate(next_entry->object.vm_object);
vm_map_entry_dispose(map, next_entry);
counter(c_vm_map_simplified_upper++);
}
counter(c_vm_map_simplify_called++);
vm_map_unlock(map);
}
kern_return_t
vm_map_machine_attribute(
vm_map_t map,
vm_offset_t address,
vm_size_t size,
vm_machine_attribute_t attribute,
vm_machine_attribute_val_t* value)
{
kern_return_t ret;
vm_size_t sync_size;
vm_offset_t start;
vm_map_entry_t entry;
if (address < vm_map_min(map) ||
(address + size) > vm_map_max(map))
return KERN_INVALID_ADDRESS;
vm_map_lock(map);
if (attribute != MATTR_CACHE) {
ret = pmap_attribute(map->pmap,
address, size, attribute, value);
vm_map_unlock(map);
return ret;
}
start = trunc_page_32(address);
sync_size = round_page_32(start + size) - start;
ret = KERN_SUCCESS;
while(sync_size) {
if (vm_map_lookup_entry(map, start, &entry)) {
vm_size_t sub_size;
if((entry->vme_end - start) > sync_size) {
sub_size = sync_size;
sync_size = 0;
} else {
sub_size = entry->vme_end - start;
sync_size -= sub_size;
}
if(entry->is_sub_map) {
vm_map_machine_attribute(
entry->object.sub_map,
(start - entry->vme_start)
+ entry->offset,
sub_size,
attribute, value);
} else {
if(entry->object.vm_object) {
vm_page_t m;
vm_object_t object;
vm_object_t base_object;
vm_object_offset_t offset;
vm_object_offset_t base_offset;
vm_size_t range;
range = sub_size;
offset = (start - entry->vme_start)
+ entry->offset;
base_offset = offset;
object = entry->object.vm_object;
base_object = object;
while(range) {
m = vm_page_lookup(
object, offset);
if(m && !m->fictitious) {
ret =
pmap_attribute_cache_sync(
m->phys_page,
PAGE_SIZE,
attribute, value);
} else if (object->shadow) {
offset = offset +
object->shadow_offset;
object = object->shadow;
continue;
}
range -= PAGE_SIZE;
base_offset += PAGE_SIZE;
offset = base_offset;
object = base_object;
}
}
}
start += sub_size;
} else {
vm_map_unlock(map);
return KERN_FAILURE;
}
}
vm_map_unlock(map);
return ret;
}
kern_return_t
vm_map_behavior_set(
vm_map_t map,
vm_offset_t start,
vm_offset_t end,
vm_behavior_t new_behavior)
{
register vm_map_entry_t entry;
vm_map_entry_t temp_entry;
XPR(XPR_VM_MAP,
"vm_map_behavior_set, 0x%X start 0x%X end 0x%X behavior %d",
(integer_t)map, start, end, new_behavior, 0);
switch (new_behavior) {
case VM_BEHAVIOR_DEFAULT:
case VM_BEHAVIOR_RANDOM:
case VM_BEHAVIOR_SEQUENTIAL:
case VM_BEHAVIOR_RSEQNTL:
break;
case VM_BEHAVIOR_WILLNEED:
case VM_BEHAVIOR_DONTNEED:
new_behavior = VM_BEHAVIOR_DEFAULT;
break;
default:
return(KERN_INVALID_ARGUMENT);
}
vm_map_lock(map);
if (vm_map_range_check(map, start, end, &temp_entry)) {
entry = temp_entry;
vm_map_clip_start(map, entry, start);
}
else {
vm_map_unlock(map);
return(KERN_INVALID_ADDRESS);
}
while ((entry != vm_map_to_entry(map)) && (entry->vme_start < end)) {
vm_map_clip_end(map, entry, end);
entry->behavior = new_behavior;
entry = entry->vme_next;
}
vm_map_unlock(map);
return(KERN_SUCCESS);
}
#include <mach_kdb.h>
#if MACH_KDB
#include <ddb/db_output.h>
#include <vm/vm_print.h>
#define printf db_printf
extern void vm_map_links_print(
struct vm_map_links *links);
extern void vm_map_header_print(
struct vm_map_header *header);
extern void vm_map_entry_print(
vm_map_entry_t entry);
extern void vm_follow_entry(
vm_map_entry_t entry);
extern void vm_follow_map(
vm_map_t map);
void
vm_map_links_print(
struct vm_map_links *links)
{
iprintf("prev = %08X next = %08X start = %08X end = %08X\n",
links->prev,
links->next,
links->start,
links->end);
}
void
vm_map_header_print(
struct vm_map_header *header)
{
vm_map_links_print(&header->links);
iprintf("nentries = %08X, %sentries_pageable\n",
header->nentries,
(header->entries_pageable ? "" : "!"));
}
void
vm_follow_entry(
vm_map_entry_t entry)
{
extern int db_indent;
int shadows;
iprintf("map entry %08X\n", entry);
db_indent += 2;
shadows = vm_follow_object(entry->object.vm_object);
iprintf("Total objects : %d\n",shadows);
db_indent -= 2;
}
void
vm_map_entry_print(
register vm_map_entry_t entry)
{
extern int db_indent;
static char *inheritance_name[4] = { "share", "copy", "none", "?"};
static char *behavior_name[4] = { "dflt", "rand", "seqtl", "rseqntl" };
iprintf("map entry %08X n", entry);
db_indent += 2;
vm_map_links_print(&entry->links);
iprintf("start = %08X end = %08X, prot=%x/%x/%s\n",
entry->vme_start,
entry->vme_end,
entry->protection,
entry->max_protection,
inheritance_name[(entry->inheritance & 0x3)]);
iprintf("behavior = %s, wired_count = %d, user_wired_count = %d\n",
behavior_name[(entry->behavior & 0x3)],
entry->wired_count,
entry->user_wired_count);
iprintf("%sin_transition, %sneeds_wakeup\n",
(entry->in_transition ? "" : "!"),
(entry->needs_wakeup ? "" : "!"));
if (entry->is_sub_map) {
iprintf("submap = %08X - offset=%08X\n",
entry->object.sub_map,
entry->offset);
} else {
iprintf("object=%08X, offset=%08X, ",
entry->object.vm_object,
entry->offset);
printf("%sis_shared, %sneeds_copy\n",
(entry->is_shared ? "" : "!"),
(entry->needs_copy ? "" : "!"));
}
db_indent -= 2;
}
void
vm_follow_map(
vm_map_t map)
{
register vm_map_entry_t entry;
extern int db_indent;
iprintf("task map %08X\n", map);
db_indent += 2;
for (entry = vm_map_first_entry(map);
entry && entry != vm_map_to_entry(map);
entry = entry->vme_next) {
vm_follow_entry(entry);
}
db_indent -= 2;
}
void
vm_map_print(
db_addr_t inmap)
{
register vm_map_entry_t entry;
vm_map_t map;
extern int db_indent;
char *swstate;
map = (vm_map_t)inmap;
iprintf("task map %08X\n", map);
db_indent += 2;
vm_map_header_print(&map->hdr);
iprintf("pmap = %08X, size = %08X, ref = %d, hint = %08X, first_free = %08X\n",
map->pmap,
map->size,
map->ref_count,
map->hint,
map->first_free);
iprintf("%swait_for_space, %swiring_required, timestamp = %d\n",
(map->wait_for_space ? "" : "!"),
(map->wiring_required ? "" : "!"),
map->timestamp);
#if TASK_SWAPPER
switch (map->sw_state) {
case MAP_SW_IN:
swstate = "SW_IN";
break;
case MAP_SW_OUT:
swstate = "SW_OUT";
break;
default:
swstate = "????";
break;
}
iprintf("res = %d, sw_state = %s\n", map->res_count, swstate);
#endif
for (entry = vm_map_first_entry(map);
entry && entry != vm_map_to_entry(map);
entry = entry->vme_next) {
vm_map_entry_print(entry);
}
db_indent -= 2;
}
void
vm_map_copy_print(
db_addr_t incopy)
{
extern int db_indent;
vm_map_copy_t copy;
int i, npages;
vm_map_entry_t entry;
copy = (vm_map_copy_t)incopy;
printf("copy object 0x%x\n", copy);
db_indent += 2;
iprintf("type=%d", copy->type);
switch (copy->type) {
case VM_MAP_COPY_ENTRY_LIST:
printf("[entry_list]");
break;
case VM_MAP_COPY_OBJECT:
printf("[object]");
break;
case VM_MAP_COPY_KERNEL_BUFFER:
printf("[kernel_buffer]");
break;
default:
printf("[bad type]");
break;
}
printf(", offset=0x%x", copy->offset);
printf(", size=0x%x\n", copy->size);
switch (copy->type) {
case VM_MAP_COPY_ENTRY_LIST:
vm_map_header_print(©->cpy_hdr);
for (entry = vm_map_copy_first_entry(copy);
entry && entry != vm_map_copy_to_entry(copy);
entry = entry->vme_next) {
vm_map_entry_print(entry);
}
break;
case VM_MAP_COPY_OBJECT:
iprintf("object=0x%x\n", copy->cpy_object);
break;
case VM_MAP_COPY_KERNEL_BUFFER:
iprintf("kernel buffer=0x%x", copy->cpy_kdata);
printf(", kalloc_size=0x%x\n", copy->cpy_kalloc_size);
break;
}
db_indent -=2;
}
vm_size_t
db_vm_map_total_size(
db_addr_t inmap)
{
vm_map_entry_t entry;
vm_size_t total;
vm_map_t map;
map = (vm_map_t)inmap;
total = 0;
for (entry = vm_map_first_entry(map);
entry != vm_map_to_entry(map);
entry = entry->vme_next) {
total += entry->vme_end - entry->vme_start;
}
return total;
}
#endif
vm_map_entry_t
vm_map_entry_insert(
vm_map_t map,
vm_map_entry_t insp_entry,
vm_offset_t start,
vm_offset_t end,
vm_object_t object,
vm_object_offset_t offset,
boolean_t needs_copy,
boolean_t is_shared,
boolean_t in_transition,
vm_prot_t cur_protection,
vm_prot_t max_protection,
vm_behavior_t behavior,
vm_inherit_t inheritance,
unsigned wired_count)
{
vm_map_entry_t new_entry;
assert(insp_entry != (vm_map_entry_t)0);
new_entry = vm_map_entry_create(map);
new_entry->vme_start = start;
new_entry->vme_end = end;
assert(page_aligned(new_entry->vme_start));
assert(page_aligned(new_entry->vme_end));
new_entry->object.vm_object = object;
new_entry->offset = offset;
new_entry->is_shared = is_shared;
new_entry->is_sub_map = FALSE;
new_entry->needs_copy = needs_copy;
new_entry->in_transition = in_transition;
new_entry->needs_wakeup = FALSE;
new_entry->inheritance = inheritance;
new_entry->protection = cur_protection;
new_entry->max_protection = max_protection;
new_entry->behavior = behavior;
new_entry->wired_count = wired_count;
new_entry->user_wired_count = 0;
new_entry->use_pmap = FALSE;
vm_map_entry_link(map, insp_entry, new_entry);
map->size += end - start;
SAVE_HINT(map, new_entry);
return new_entry;
}
kern_return_t
vm_remap_extract(
vm_map_t map,
vm_offset_t addr,
vm_size_t size,
boolean_t copy,
struct vm_map_header *map_header,
vm_prot_t *cur_protection,
vm_prot_t *max_protection,
vm_inherit_t inheritance,
boolean_t pageable)
{
kern_return_t result;
vm_size_t mapped_size;
vm_size_t tmp_size;
vm_map_entry_t src_entry;
vm_map_entry_t new_entry;
vm_object_offset_t offset;
vm_offset_t map_address;
vm_offset_t src_start;
vm_offset_t src_end;
vm_object_t object;
vm_map_version_t version;
boolean_t src_needs_copy;
boolean_t new_entry_needs_copy;
assert(map != VM_MAP_NULL);
assert(size != 0 && size == round_page_32(size));
assert(inheritance == VM_INHERIT_NONE ||
inheritance == VM_INHERIT_COPY ||
inheritance == VM_INHERIT_SHARE);
src_start = trunc_page_32(addr);
src_end = round_page_32(src_start + size);
map_header->links.next = (struct vm_map_entry *)&map_header->links;
map_header->links.prev = (struct vm_map_entry *)&map_header->links;
map_header->nentries = 0;
map_header->entries_pageable = pageable;
*cur_protection = VM_PROT_ALL;
*max_protection = VM_PROT_ALL;
map_address = 0;
mapped_size = 0;
result = KERN_SUCCESS;
vm_map_lock(map);
while (mapped_size != size) {
vm_size_t entry_size;
if (! vm_map_lookup_entry(map, src_start, &src_entry)) {
result = KERN_INVALID_ADDRESS;
break;
}
if (src_start < src_entry->vme_start ||
(mapped_size && src_start != src_entry->vme_start)) {
result = KERN_INVALID_ADDRESS;
break;
}
if(src_entry->is_sub_map) {
result = KERN_INVALID_ADDRESS;
break;
}
tmp_size = size - mapped_size;
if (src_end > src_entry->vme_end)
tmp_size -= (src_end - src_entry->vme_end);
entry_size = (vm_size_t)(src_entry->vme_end -
src_entry->vme_start);
if(src_entry->is_sub_map) {
vm_map_reference(src_entry->object.sub_map);
} else {
object = src_entry->object.vm_object;
if (object == VM_OBJECT_NULL) {
object = vm_object_allocate(entry_size);
src_entry->offset = 0;
src_entry->object.vm_object = object;
} else if (object->copy_strategy !=
MEMORY_OBJECT_COPY_SYMMETRIC) {
assert(!src_entry->needs_copy);
} else if (src_entry->needs_copy || object->shadowed ||
(object->internal && !object->true_share &&
!src_entry->is_shared &&
object->size > entry_size)) {
vm_object_shadow(&src_entry->object.vm_object,
&src_entry->offset,
entry_size);
if (!src_entry->needs_copy &&
(src_entry->protection & VM_PROT_WRITE)) {
if(map->mapped) {
vm_object_pmap_protect(
src_entry->object.vm_object,
src_entry->offset,
entry_size,
PMAP_NULL,
src_entry->vme_start,
src_entry->protection &
~VM_PROT_WRITE);
} else {
pmap_protect(vm_map_pmap(map),
src_entry->vme_start,
src_entry->vme_end,
src_entry->protection &
~VM_PROT_WRITE);
}
}
object = src_entry->object.vm_object;
src_entry->needs_copy = FALSE;
}
vm_object_lock(object);
object->ref_count++;
VM_OBJ_RES_INCR(object);
if (object->copy_strategy ==
MEMORY_OBJECT_COPY_SYMMETRIC) {
object->copy_strategy =
MEMORY_OBJECT_COPY_DELAY;
}
vm_object_unlock(object);
}
offset = src_entry->offset + (src_start - src_entry->vme_start);
new_entry = _vm_map_entry_create(map_header);
vm_map_entry_copy(new_entry, src_entry);
new_entry->use_pmap = FALSE;
new_entry->vme_start = map_address;
new_entry->vme_end = map_address + tmp_size;
new_entry->inheritance = inheritance;
new_entry->offset = offset;
RestartCopy:
if (!copy) {
src_entry->is_shared = TRUE;
new_entry->is_shared = TRUE;
if (!(new_entry->is_sub_map))
new_entry->needs_copy = FALSE;
} else if (src_entry->is_sub_map) {
new_entry->needs_copy = TRUE;
} else if (src_entry->wired_count == 0 &&
vm_object_copy_quickly(&new_entry->object.vm_object,
new_entry->offset,
(new_entry->vme_end -
new_entry->vme_start),
&src_needs_copy,
&new_entry_needs_copy)) {
new_entry->needs_copy = new_entry_needs_copy;
new_entry->is_shared = FALSE;
if (src_needs_copy && !src_entry->needs_copy) {
vm_object_pmap_protect(object,
offset,
entry_size,
((src_entry->is_shared
|| map->mapped) ?
PMAP_NULL : map->pmap),
src_entry->vme_start,
src_entry->protection &
~VM_PROT_WRITE);
src_entry->needs_copy = TRUE;
}
vm_object_deallocate(object);
} else {
new_entry->is_shared = FALSE;
version.main_timestamp = map->timestamp;
vm_map_unlock(map);
if (src_entry->wired_count > 0) {
vm_object_lock(object);
result = vm_object_copy_slowly(
object,
offset,
entry_size,
THREAD_UNINT,
&new_entry->object.vm_object);
new_entry->offset = 0;
new_entry->needs_copy = FALSE;
} else {
result = vm_object_copy_strategically(
object,
offset,
entry_size,
&new_entry->object.vm_object,
&new_entry->offset,
&new_entry_needs_copy);
new_entry->needs_copy = new_entry_needs_copy;
}
vm_object_deallocate(object);
if (result != KERN_SUCCESS &&
result != KERN_MEMORY_RESTART_COPY) {
_vm_map_entry_dispose(map_header, new_entry);
break;
}
vm_map_lock(map);
if (version.main_timestamp + 1 != map->timestamp) {
vm_object_deallocate(new_entry->
object.vm_object);
_vm_map_entry_dispose(map_header, new_entry);
if (result == KERN_MEMORY_RESTART_COPY)
result = KERN_SUCCESS;
continue;
}
if (result == KERN_MEMORY_RESTART_COPY) {
vm_object_reference(object);
goto RestartCopy;
}
}
_vm_map_entry_link(map_header,
map_header->links.prev, new_entry);
*cur_protection &= src_entry->protection;
*max_protection &= src_entry->max_protection;
map_address += tmp_size;
mapped_size += tmp_size;
src_start += tmp_size;
}
vm_map_unlock(map);
if (result != KERN_SUCCESS) {
for (src_entry = map_header->links.next;
src_entry != (struct vm_map_entry *)&map_header->links;
src_entry = new_entry) {
new_entry = src_entry->vme_next;
_vm_map_entry_unlink(map_header, src_entry);
vm_object_deallocate(src_entry->object.vm_object);
_vm_map_entry_dispose(map_header, src_entry);
}
}
return result;
}
kern_return_t
vm_remap(
vm_map_t target_map,
vm_offset_t *address,
vm_size_t size,
vm_offset_t mask,
boolean_t anywhere,
vm_map_t src_map,
vm_offset_t memory_address,
boolean_t copy,
vm_prot_t *cur_protection,
vm_prot_t *max_protection,
vm_inherit_t inheritance)
{
kern_return_t result;
vm_map_entry_t entry;
vm_map_entry_t insp_entry;
vm_map_entry_t new_entry;
struct vm_map_header map_header;
if (target_map == VM_MAP_NULL)
return KERN_INVALID_ARGUMENT;
switch (inheritance) {
case VM_INHERIT_NONE:
case VM_INHERIT_COPY:
case VM_INHERIT_SHARE:
if (size != 0 && src_map != VM_MAP_NULL)
break;
default:
return KERN_INVALID_ARGUMENT;
}
size = round_page_32(size);
result = vm_remap_extract(src_map, memory_address,
size, copy, &map_header,
cur_protection,
max_protection,
inheritance,
target_map->hdr.
entries_pageable);
if (result != KERN_SUCCESS) {
return result;
}
*address = trunc_page_32(*address);
vm_map_lock(target_map);
result = vm_remap_range_allocate(target_map, address, size,
mask, anywhere, &insp_entry);
for (entry = map_header.links.next;
entry != (struct vm_map_entry *)&map_header.links;
entry = new_entry) {
new_entry = entry->vme_next;
_vm_map_entry_unlink(&map_header, entry);
if (result == KERN_SUCCESS) {
entry->vme_start += *address;
entry->vme_end += *address;
vm_map_entry_link(target_map, insp_entry, entry);
insp_entry = entry;
} else {
if (!entry->is_sub_map) {
vm_object_deallocate(entry->object.vm_object);
} else {
vm_map_deallocate(entry->object.sub_map);
}
_vm_map_entry_dispose(&map_header, entry);
}
}
if (result == KERN_SUCCESS) {
target_map->size += size;
SAVE_HINT(target_map, insp_entry);
}
vm_map_unlock(target_map);
if (result == KERN_SUCCESS && target_map->wiring_required)
result = vm_map_wire(target_map, *address,
*address + size, *cur_protection, TRUE);
return result;
}
kern_return_t
vm_remap_range_allocate(
vm_map_t map,
vm_offset_t *address,
vm_size_t size,
vm_offset_t mask,
boolean_t anywhere,
vm_map_entry_t *map_entry)
{
register vm_map_entry_t entry;
register vm_offset_t start;
register vm_offset_t end;
kern_return_t result = KERN_SUCCESS;
StartAgain: ;
start = *address;
if (anywhere)
{
if (start < map->min_offset)
start = map->min_offset;
if (start > map->max_offset)
return(KERN_NO_SPACE);
assert(first_free_is_valid(map));
if (start == map->min_offset) {
if ((entry = map->first_free) != vm_map_to_entry(map))
start = entry->vme_end;
} else {
vm_map_entry_t tmp_entry;
if (vm_map_lookup_entry(map, start, &tmp_entry))
start = tmp_entry->vme_end;
entry = tmp_entry;
}
while (TRUE) {
register vm_map_entry_t next;
end = ((start + mask) & ~mask);
if (end < start)
return(KERN_NO_SPACE);
start = end;
end += size;
if ((end > map->max_offset) || (end < start)) {
if (map->wait_for_space) {
if (size <= (map->max_offset -
map->min_offset)) {
assert_wait((event_t) map, THREAD_INTERRUPTIBLE);
vm_map_unlock(map);
thread_block((void (*)(void))0);
vm_map_lock(map);
goto StartAgain;
}
}
return(KERN_NO_SPACE);
}
next = entry->vme_next;
if (next == vm_map_to_entry(map))
break;
if (next->vme_start >= end)
break;
entry = next;
start = entry->vme_end;
}
*address = start;
} else {
vm_map_entry_t temp_entry;
if ((start & mask) != 0)
return(KERN_NO_SPACE);
end = start + size;
if ((start < map->min_offset) ||
(end > map->max_offset) ||
(start >= end)) {
return(KERN_INVALID_ADDRESS);
}
if (vm_map_lookup_entry(map, start, &temp_entry))
return(KERN_NO_SPACE);
entry = temp_entry;
if ((entry->vme_next != vm_map_to_entry(map)) &&
(entry->vme_next->vme_start < end))
return(KERN_NO_SPACE);
}
*map_entry = entry;
return(KERN_SUCCESS);
}
vm_map_t
vm_map_switch(
vm_map_t map)
{
int mycpu;
thread_act_t thr_act = current_act();
vm_map_t oldmap = thr_act->map;
mp_disable_preemption();
mycpu = cpu_number();
PMAP_SWITCH_USER(thr_act, map, mycpu);
mp_enable_preemption();
return(oldmap);
}
kern_return_t
vm_map_write_user(
vm_map_t map,
vm_offset_t src_addr,
vm_offset_t dst_addr,
vm_size_t size)
{
thread_act_t thr_act = current_act();
kern_return_t kr = KERN_SUCCESS;
if(thr_act->map == map) {
if (copyout((char *)src_addr, (char *)dst_addr, size)) {
kr = KERN_INVALID_ADDRESS;
}
} else {
vm_map_t oldmap;
vm_map_reference(map);
oldmap = vm_map_switch(map);
if (copyout((char *)src_addr, (char *)dst_addr, size)) {
kr = KERN_INVALID_ADDRESS;
}
vm_map_switch(oldmap);
vm_map_deallocate(map);
}
return kr;
}
kern_return_t
vm_map_read_user(
vm_map_t map,
vm_offset_t src_addr,
vm_offset_t dst_addr,
vm_size_t size)
{
thread_act_t thr_act = current_act();
kern_return_t kr = KERN_SUCCESS;
if(thr_act->map == map) {
if (copyin((char *)src_addr, (char *)dst_addr, size)) {
kr = KERN_INVALID_ADDRESS;
}
} else {
vm_map_t oldmap;
vm_map_reference(map);
oldmap = vm_map_switch(map);
if (copyin((char *)src_addr, (char *)dst_addr, size)) {
kr = KERN_INVALID_ADDRESS;
}
vm_map_switch(oldmap);
vm_map_deallocate(map);
}
return kr;
}
kern_return_t
vm_region_clone(
ipc_port_t src_region,
ipc_port_t dst_region)
{
vm_named_entry_t src_object;
vm_named_entry_t dst_object;
vm_map_t src_map;
vm_map_t dst_map;
vm_offset_t addr;
vm_offset_t max_off;
vm_map_entry_t entry;
vm_map_entry_t new_entry;
vm_map_entry_t insert_point;
src_object = (vm_named_entry_t)src_region->ip_kobject;
dst_object = (vm_named_entry_t)dst_region->ip_kobject;
if((!src_object->is_sub_map) || (!dst_object->is_sub_map)) {
return KERN_INVALID_ARGUMENT;
}
src_map = (vm_map_t)src_object->backing.map;
dst_map = (vm_map_t)dst_object->backing.map;
vm_map_lock(src_map);
if((src_map->min_offset != dst_map->min_offset)
|| (src_map->max_offset != dst_map->max_offset)) {
vm_map_unlock(src_map);
return KERN_INVALID_ARGUMENT;
}
addr = src_map->min_offset;
vm_map_lookup_entry(dst_map, addr, &entry);
if(entry == vm_map_to_entry(dst_map)) {
entry = entry->vme_next;
}
if(entry == vm_map_to_entry(dst_map)) {
max_off = src_map->max_offset;
} else {
max_off = entry->vme_start;
}
vm_map_lookup_entry(src_map, addr, &entry);
if(entry == vm_map_to_entry(src_map)) {
entry = entry->vme_next;
}
vm_map_lookup_entry(dst_map, addr, &insert_point);
while((entry != vm_map_to_entry(src_map)) &&
(entry->vme_end <= max_off)) {
addr = entry->vme_start;
new_entry = vm_map_entry_create(dst_map);
vm_map_entry_copy(new_entry, entry);
vm_map_entry_link(dst_map, insert_point, new_entry);
insert_point = new_entry;
if (entry->object.vm_object != VM_OBJECT_NULL) {
if (new_entry->is_sub_map) {
vm_map_reference(new_entry->object.sub_map);
} else {
vm_object_reference(
new_entry->object.vm_object);
}
}
dst_map->size += new_entry->vme_end - new_entry->vme_start;
entry = entry->vme_next;
}
vm_map_unlock(src_map);
return KERN_SUCCESS;
}
#undef current_map
vm_map_t
current_map(void)
{
return (current_map_fast());
}
boolean_t vm_map_check_protection(map, start, end, protection)
register vm_map_t map;
register vm_offset_t start;
register vm_offset_t end;
register vm_prot_t protection;
{
register vm_map_entry_t entry;
vm_map_entry_t tmp_entry;
vm_map_lock(map);
if (start < vm_map_min(map) || end > vm_map_max(map) || start > end)
{
vm_map_unlock(map);
return (FALSE);
}
if (!vm_map_lookup_entry(map, start, &tmp_entry)) {
vm_map_unlock(map);
return(FALSE);
}
entry = tmp_entry;
while (start < end) {
if (entry == vm_map_to_entry(map)) {
vm_map_unlock(map);
return(FALSE);
}
if (start < entry->vme_start) {
vm_map_unlock(map);
return(FALSE);
}
if ((entry->protection & protection) != protection) {
vm_map_unlock(map);
return(FALSE);
}
start = entry->vme_end;
entry = entry->vme_next;
}
vm_map_unlock(map);
return(TRUE);
}
void
kernel_vm_map_reference(
vm_map_t map)
{
vm_map_reference(map);
}
#undef vm_map_reference
void
vm_map_reference(
register vm_map_t map)
{
if (map == VM_MAP_NULL)
return;
mutex_lock(&map->s_lock);
#if TASK_SWAPPER
assert(map->res_count > 0);
assert(map->ref_count >= map->res_count);
map->res_count++;
#endif
map->ref_count++;
mutex_unlock(&map->s_lock);
}
void
vm_map_deallocate(
register vm_map_t map)
{
unsigned int ref;
if (map == VM_MAP_NULL)
return;
mutex_lock(&map->s_lock);
ref = --map->ref_count;
if (ref > 0) {
vm_map_res_deallocate(map);
mutex_unlock(&map->s_lock);
return;
}
assert(map->ref_count == 0);
mutex_unlock(&map->s_lock);
#if TASK_SWAPPER
#endif
vm_map_destroy(map);
}