int
get_vmmap_entries(
vm_map_t map)
{
int total_entries = 0;
vm_map_entry_t entry;
if (not_in_kdp)
vm_map_lock(map);
entry = vm_map_first_entry(map);
while(entry != vm_map_to_entry(map)) {
if(entry->is_sub_map) {
total_entries +=
get_vmsubmap_entries(entry->object.sub_map,
entry->offset,
entry->offset +
(entry->vme_end - entry->vme_start));
} else {
total_entries += 1;
}
entry = entry->vme_next;
}
if (not_in_kdp)
vm_map_unlock(map);
return(total_entries);
}
static void
check_map_sanity(vm_map_t map, vm_map_entry_t old_hole_entry)
{
vm_map_entry_t hole_entry, next_hole_entry;
vm_map_entry_t map_entry, next_map_entry;
if (map->holes_list == NULL) {
return;
}
hole_entry = (vm_map_entry_t) map->holes_list;
next_hole_entry = hole_entry->vme_next;
map_entry = vm_map_first_entry(map);
next_map_entry = map_entry->vme_next;
while(map_entry->vme_start > hole_entry->vme_start) {
hole_entry = next_hole_entry;
next_hole_entry = hole_entry->vme_next;
if (hole_entry == (vm_map_entry_t)map->holes_list)
break;
}
while (map_entry != vm_map_to_entry(map)) {
if (map_entry->vme_start >= map->max_offset)
break;
if (map_entry->vme_end != map_entry->vme_next->vme_start) {
if (map_entry->vme_next == vm_map_to_entry(map))
break;
if (hole_entry->vme_start != map_entry->vme_end) {
panic("hole_entry not aligned %p(0x%llx), %p (0x%llx), %p", hole_entry, (unsigned long long)hole_entry->vme_start, map_entry->vme_next, (unsigned long long)map_entry->vme_end, old_hole_entry);
assert(hole_entry->vme_start == map_entry->vme_end);
}
if (hole_entry->vme_end != map_entry->vme_next->vme_start) {
panic("hole_entry not next aligned %p(0x%llx), %p (0x%llx), %p", hole_entry, (unsigned long long)hole_entry->vme_end, map_entry->vme_next, (unsigned long long)map_entry->vme_next->vme_start, old_hole_entry);
assert(hole_entry->vme_end == map_entry->vme_next->vme_start);
}
hole_entry = next_hole_entry;
next_hole_entry = hole_entry->vme_next;
if (hole_entry == (vm_map_entry_t)map->holes_list)
break;
}
map_entry = map_entry->vme_next;
}
}
kern_return_t
projected_buffer_collect(vm_map_t map)
{
vm_map_entry_t entry, next;
if (map == VM_MAP_NULL || map == kernel_map)
return(KERN_INVALID_ARGUMENT);
for (entry = vm_map_first_entry(map);
entry != vm_map_to_entry(map);
entry = next) {
next = entry->vme_next;
if (entry->projected_on != 0)
projected_buffer_deallocate(map, entry->vme_start, entry->vme_end);
}
return(KERN_SUCCESS);
}
mach_vm_offset_t
mach_get_vm_start(vm_map_t map)
{
return( vm_map_first_entry(map)->vme_start);
}
/*
* Legacy routines to get the start and end for a vm_map_t. They
* return them in the vm_offset_t format. So, they should only be
* called on maps that are the same size as the kernel map for
* accurate results.
*/
vm_offset_t
get_vm_start(
vm_map_t map)
{
return(CAST_DOWN(vm_offset_t, vm_map_first_entry(map)->vme_start));
}
/*
* vm_map_lookup_entry_ll: [ internal use only ]
* Use the linked list to find the map entry containing (or
* immediately preceding) the specified address
* in the given map; the entry is returned
* in the "entry" parameter. The boolean
* result indicates whether the address is
* actually contained in the map.
*/
boolean_t
vm_map_store_lookup_entry_ll(
register vm_map_t map,
register vm_map_offset_t address,
vm_map_entry_t *entry) /* OUT */
{
register vm_map_entry_t cur;
register vm_map_entry_t last;
/*
* Start looking either from the head of the
* list, or from the hint.
*/
cur = map->hint;
if (cur == vm_map_to_entry(map))
cur = cur->vme_next;
if (address >= cur->vme_start) {
/*
* Go from hint to end of list.
*
* But first, make a quick check to see if
* we are already looking at the entry we
* want (which is usually the case).
* Note also that we don't need to save the hint
* here... it is the same hint (unless we are
* at the header, in which case the hint didn't
* buy us anything anyway).
*/
last = vm_map_to_entry(map);
if ((cur != last) && (cur->vme_end > address)) {
*entry = cur;
return(TRUE);
}
}
else {
/*
* Go from start to hint, *inclusively*
*/
last = cur->vme_next;
cur = vm_map_first_entry(map);
}
/*
* Search linearly
*/
while (cur != last) {
if (cur->vme_end > address) {
if (address >= cur->vme_start) {
/*
* Save this lookup for future
* hints, and return
*/
*entry = cur;
SAVE_HINT_MAP_READ(map, cur);
return(TRUE);
}
break;
}
cur = cur->vme_next;
}
*entry = cur->vme_prev;
SAVE_HINT_MAP_READ(map, *entry);
return(FALSE);
}
