Changeset View
Changeset View
Standalone View
Standalone View
sys/vm/vm_map.c
Context not available. | |||||
child = entry->left; | child = entry->left; | ||||
max_left = (child != NULL) ? child->max_free : | max_left = (child != NULL) ? child->max_free : | ||||
alc: These functions operate on entries. Why has "entry_" been removed from the function name? | |||||
Done Inline ActionsBecause 80-character line limits and 8-space tabs make people desperate to avoid long names and nested loops. Neverthless, at the cost of wrapping 2 long lines, this has been changed. dougm: Because 80-character line limits and 8-space tabs make people desperate to avoid long names and… | |||||
entry->start - entry->prev->end; | entry->start - entry->prev->end; | ||||
child = entry->right; | child = entry->right; | ||||
Done Inline ActionsBlank line between functions definitions. kib: Blank line between functions definitions. | |||||
max_right = (child != NULL) ? child->max_free : | max_right = (child != NULL) ? child->max_free : | ||||
Done Inline Actionsnamespace. kib: namespace. | |||||
entry->next->start - entry->end; | entry->next->start - entry->end; | ||||
entry->max_free = MAX(max_left, max_right); | entry->max_free = MAX(max_left, max_right); | ||||
} | } | ||||
Done Inline Actionsvm_size_t, not size_t. alc: vm_size_t, not size_t. | |||||
#define SPLAY_LEFT_STEP(root, y, rlist, test) do { \ | #define SPLAY_LEFT_STEP(root, y, rlist, test) do { \ | ||||
y = root->left; \ | y = root->left; \ | ||||
if (y != NULL && (test)) { \ | if (y != NULL && (test)) { \ | ||||
Done Inline ActionsInsert blank line. alc: Insert blank line. | |||||
/* Rotate right and make y root. */ \ | /* Rotate right and make y root. */ \ | ||||
root->left = y->right; \ | root->left = y->right; \ | ||||
y->right = root; \ | y->right = root; \ | ||||
vm_map_entry_set_max_free(root); \ | if (root->max_free == y->max_free) \ | ||||
Done Inline ActionsDitto. alc: Ditto. | |||||
vm_map_entry_set_max_free(root);\ | |||||
root = y; \ | root = y; \ | ||||
y = root->left; \ | y = root->left; \ | ||||
Done Inline ActionsInsert blank line. alc: Insert blank line. | |||||
} \ | } \ | ||||
root->max_free = root->right ? root->right->max_free : root->next->start - root->end;\ | |||||
/* Put root on rlist. */ \ | /* Put root on rlist. */ \ | ||||
root->left = rlist; \ | root->left = rlist; \ | ||||
rlist = root; \ | rlist = root; \ | ||||
root = y; \ | root = y; \ | ||||
} while (0) | } while (0) | ||||
#define SPLAY_RIGHT_STEP(root, y, llist, test) do { \ | #define SPLAY_RIGHT_STEP(root, y, llist, test) do { \ | ||||
y = root->right; \ | y = root->right; \ | ||||
if (y != NULL && (test)) { \ | if (y != NULL && (test)) { \ | ||||
/* Rotate left and make y root. */ \ | /* Rotate left and make y root. */ \ | ||||
root->right = y->left; \ | root->right = y->left; \ | ||||
y->left = root; \ | y->left = root; \ | ||||
vm_map_entry_set_max_free(root); \ | if (root->max_free == y->max_free) \ | ||||
vm_map_entry_set_max_free(root);\ | |||||
root = y; \ | root = y; \ | ||||
y = root->right; \ | y = root->right; \ | ||||
} \ | } \ | ||||
root->max_free = root->left ? root->left->max_free : root->start - root->prev->end;\ | |||||
/* Put root on llist. */ \ | /* Put root on llist. */ \ | ||||
root->right = llist; \ | root->right = llist; \ | ||||
llist = root; \ | llist = root; \ | ||||
root = y; \ | root = y; \ | ||||
} while (0) | } while (0) | ||||
/* | /* | ||||
* Walk down the tree until we find addr or a NULL pointer where addr would go, | * Walk down the tree until we find addr or a NULL pointer where addr would go, | ||||
* breaking off left and right subtrees of nodes less than, or greater than | * breaking off left and right subtrees of nodes less than, or greater than | ||||
* addr. Treat pointers to nodes with max_free < length as NULL pointers. | * addr. Treat pointers to nodes with max_free < length as NULL pointers. | ||||
* llist and rlist are the two sides in reverse order (bottom-up), with llist | * llist and rlist are the two sides in reverse order (bottom-up), with llist | ||||
* linked by the right pointer and rlist linked by the left pointer in the | * linked by the right pointer and rlist linked by the left pointer in the | ||||
* vm_map_entry. | * vm_map_entry. | ||||
*/ | */ | ||||
static vm_map_entry_t | static vm_map_entry_t | ||||
vm_map_splay_split(vm_offset_t addr, vm_size_t length, | vm_map_splay_split(vm_offset_t addr, vm_size_t length, | ||||
vm_map_entry_t root, vm_map_entry_t *out_llist, vm_map_entry_t *out_rlist) | vm_map_entry_t root, vm_map_entry_t *io_llist, vm_map_entry_t *io_rlist) | ||||
{ | { | ||||
vm_map_entry_t llist, rlist; | vm_map_entry_t llist, rlist; | ||||
vm_map_entry_t y; | vm_map_entry_t y; | ||||
llist = NULL; | llist = *io_llist; | ||||
rlist = NULL; | rlist = *io_rlist; | ||||
while (root != NULL && root->max_free >= length) { | while (root != NULL && root->max_free >= length) { | ||||
if (addr < root->start) { | if (addr < root->start) { | ||||
SPLAY_LEFT_STEP(root, y, rlist, | SPLAY_LEFT_STEP(root, y, rlist, | ||||
y->max_free >= length && addr < y->start); | y->max_free >= length && addr < y->start); | ||||
} else if (addr >= root->end) { | } else if (addr >= root->end) { | ||||
SPLAY_RIGHT_STEP(root, y, llist, | SPLAY_RIGHT_STEP(root, y, llist, | ||||
y->max_free >= length && addr >= y->end); | y->max_free >= length && addr >= y->end); | ||||
} else | } else | ||||
break; | break; | ||||
} | } | ||||
*out_llist = llist; | *io_llist = llist; | ||||
*out_rlist = rlist; | *io_rlist = rlist; | ||||
return (root); | return (root); | ||||
} | } | ||||
static void | static void | ||||
vm_map_splay_findnext(vm_map_entry_t root, vm_map_entry_t *iolist) | vm_map_splay_findnext(vm_map_entry_t root, vm_map_entry_t *iolist) | ||||
{ | { | ||||
vm_map_entry_t rlist, y; | vm_map_entry_t rlist, y; | ||||
Show All 14 Lines | |||||
* subtrees of the root go at the bottom of llist and rlist. | * subtrees of the root go at the bottom of llist and rlist. | ||||
*/ | */ | ||||
static vm_map_entry_t | static vm_map_entry_t | ||||
vm_map_splay_merge(vm_map_entry_t root, | vm_map_splay_merge(vm_map_entry_t root, | ||||
vm_map_entry_t llist, vm_map_entry_t rlist, | vm_map_entry_t llist, vm_map_entry_t rlist, | ||||
vm_map_entry_t ltree, vm_map_entry_t rtree) | vm_map_entry_t ltree, vm_map_entry_t rtree) | ||||
{ | { | ||||
vm_map_entry_t y; | vm_map_entry_t y; | ||||
vm_size_t max_free; | |||||
if (llist != NULL) | |||||
max_free = (ltree != NULL) ? ltree->max_free : | |||||
llist->next->start - llist->end; | |||||
while (llist != NULL) { | while (llist != NULL) { | ||||
y = llist->right; | y = llist->right; | ||||
llist->right = ltree; | llist->right = ltree; | ||||
vm_map_entry_set_max_free(llist); | if (llist->max_free < max_free) | ||||
llist->max_free = max_free; | |||||
else | |||||
max_free = llist->max_free; | |||||
ltree = llist; | ltree = llist; | ||||
llist = y; | llist = y; | ||||
} | } | ||||
if (rlist != NULL) | |||||
max_free = (rtree != NULL) ? rtree->max_free : | |||||
rlist->start - rlist->prev->end; | |||||
while (rlist != NULL) { | while (rlist != NULL) { | ||||
y = rlist->left; | y = rlist->left; | ||||
rlist->left = rtree; | rlist->left = rtree; | ||||
vm_map_entry_set_max_free(rlist); | if (rlist->max_free < max_free) | ||||
rlist->max_free = max_free; | |||||
else | |||||
max_free = rlist->max_free; | |||||
rtree = rlist; | rtree = rlist; | ||||
rlist = y; | rlist = y; | ||||
} | } | ||||
/* | /* | ||||
* Final assembly: add ltree and rtree as subtrees of root. | * Final assembly: add ltree and rtree as subtrees of root. | ||||
*/ | */ | ||||
root->left = ltree; | root->left = ltree; | ||||
Show All 14 Lines | |||||
* The new root is the vm_map_entry containing "addr", or else an | * The new root is the vm_map_entry containing "addr", or else an | ||||
* adjacent entry (lower if possible) if addr is not in the tree. | * adjacent entry (lower if possible) if addr is not in the tree. | ||||
* | * | ||||
* The map must be locked, and leaves it so. | * The map must be locked, and leaves it so. | ||||
* | * | ||||
* Returns: the new root. | * Returns: the new root. | ||||
*/ | */ | ||||
static vm_map_entry_t | static vm_map_entry_t | ||||
vm_map_entry_splay(vm_offset_t addr, vm_map_entry_t root) | vm_map_entry_splay(vm_offset_t addr, vm_map_t map) | ||||
{ | { | ||||
vm_map_entry_t llist, rlist; | vm_map_entry_t llist, rlist, root; | ||||
root = vm_map_splay_split(addr, 0, root, &llist, &rlist); | llist = rlist = NULL; | ||||
root = vm_map_splay_split(addr, 0, map->root, &llist, &rlist); | |||||
if (root != NULL) { | if (root != NULL) { | ||||
/* do nothing */ | /* do nothing */ | ||||
} else if (llist != NULL) { | } else if (llist != NULL) { | ||||
/* | /* | ||||
* Recover the greatest node in the left | * Recover the greatest node in the left | ||||
* subtree and make it the root. | * subtree and make it the root. | ||||
*/ | */ | ||||
root = llist; | root = llist; | ||||
llist = root->right; | llist = root->right; | ||||
root->right = NULL; | root->right = NULL; | ||||
} else if (rlist != NULL) { | } else if (rlist != NULL) { | ||||
Done Inline ActionsWith this change, I would have expected the removal of entry_ from the function's name. In general, there is increasing inconsistency in the use of vm_map_entry_ versus vm_map_. alc: With this change, I would have expected the removal of entry_ from the function's name. In… | |||||
/* | /* | ||||
* Recover the least node in the right | * Recover the least node in the right | ||||
* subtree and make it the root. | * subtree and make it the root. | ||||
*/ | */ | ||||
Context not available. | |||||
return (NULL); | return (NULL); | ||||
} | } | ||||
return (vm_map_splay_merge(root, llist, rlist, | return (vm_map_splay_merge(root, llist, rlist, | ||||
root->left, root->right)); | root->left, root->right)); | ||||
} | } | ||||
/* | /* | ||||
* vm_map_entry_{un,}link: | * vm_map_entry_{un,}link: | ||||
* | * | ||||
* Insert/remove entries from maps. | * Insert/remove entries from maps. | ||||
*/ | */ | ||||
static void | static void | ||||
vm_map_entry_link(vm_map_t map, | vm_map_entry_link(vm_map_t map, | ||||
vm_map_entry_t entry) | vm_map_entry_t entry) | ||||
{ | { | ||||
vm_map_entry_t llist, rlist, root; | vm_map_entry_t llist, rlist, root, y; | ||||
CTR3(KTR_VM, | CTR3(KTR_VM, | ||||
"vm_map_entry_link: map %p, nentries %d, entry %p", map, | "vm_map_entry_link: map %p, nentries %d, entry %p", map, | ||||
map->nentries, entry); | map->nentries, entry); | ||||
VM_MAP_ASSERT_LOCKED(map); | VM_MAP_ASSERT_LOCKED(map); | ||||
map->nentries++; | map->nentries++; | ||||
root = map->root; | llist = rlist = NULL; | ||||
root = vm_map_splay_split(entry->start, 0, root, &llist, &rlist); | root = vm_map_splay_split(entry->start, 0, map->root, &llist, &rlist); | ||||
KASSERT(root == NULL, | if (root == NULL) | ||||
("vm_map_entry_link: link object already mapped")); | entry->left = entry->right = NULL; | ||||
else if (entry->start == root->start) { | |||||
KASSERT(entry->end < root->end, | |||||
("vm_map_entry_link: new entry overflows")); | |||||
root->offset += entry->end - root->start; | |||||
root->start = entry->end; | |||||
entry->right = NULL; | |||||
entry->left = root->left; | |||||
root->left = NULL; | |||||
SPLAY_LEFT_STEP(root, y, rlist, false); | |||||
} else if (root->end == entry->end) { | |||||
KASSERT(entry->start > root->start, | |||||
("vm_map_entry_link: new entry overflows")); | |||||
root->end = entry->start; | |||||
entry->left = NULL; | |||||
entry->right = root->right; | |||||
root->right = NULL; | |||||
SPLAY_RIGHT_STEP(root, y, llist, false); | |||||
} else | |||||
KASSERT(true, | |||||
("vm_map_entry_link: mismatched endpoints")); | |||||
entry->prev = (llist == NULL) ? &map->header : llist; | entry->prev = (llist == NULL) ? &map->header : llist; | ||||
entry->next = (rlist == NULL) ? &map->header : rlist; | entry->next = (rlist == NULL) ? &map->header : rlist; | ||||
entry->prev->next = entry->next->prev = entry; | entry->prev->next = entry->next->prev = entry; | ||||
root = vm_map_splay_merge(entry, llist, rlist, NULL, NULL); | root = vm_map_splay_merge(entry, llist, rlist, entry->left, entry->right); | ||||
map->root = entry; | map->root = entry; | ||||
VM_MAP_ASSERT_CONSISTENT(map); | VM_MAP_ASSERT_CONSISTENT(map); | ||||
} | } | ||||
Done Inline ActionsUnnecessary parentheses. alc: Unnecessary parentheses. | |||||
enum unlink_merge_type { | enum unlink_merge_type { | ||||
UNLINK_MERGE_PREV, | UNLINK_MERGE_PREV, | ||||
Done Inline ActionsIncorrect indentation. alc: Incorrect indentation. | |||||
UNLINK_MERGE_NONE, | UNLINK_MERGE_NONE, | ||||
UNLINK_MERGE_NEXT | UNLINK_MERGE_NEXT | ||||
}; | }; | ||||
static void | static void | ||||
vm_map_entry_unlink(vm_map_t map, | vm_map_entry_unlink(vm_map_t map, | ||||
vm_map_entry_t entry, | vm_map_entry_t entry, | ||||
enum unlink_merge_type op) | enum unlink_merge_type op) | ||||
{ | { | ||||
vm_map_entry_t llist, rlist, root, y; | vm_map_entry_t llist, rlist, root, y; | ||||
VM_MAP_ASSERT_LOCKED(map); | VM_MAP_ASSERT_LOCKED(map); | ||||
llist = entry->prev; | llist = rlist = NULL; | ||||
rlist = entry->next; | root = vm_map_splay_split(entry->start, 0, map->root, &llist, &rlist); | ||||
llist->next = rlist; | |||||
rlist->prev = llist; | |||||
root = map->root; | |||||
root = vm_map_splay_split(entry->start, 0, root, &llist, &rlist); | |||||
KASSERT(root != NULL, | KASSERT(root != NULL, | ||||
("vm_map_entry_unlink: unlink object not mapped")); | ("vm_map_entry_unlink: unlink object not mapped")); | ||||
switch (op) { | switch (op) { | ||||
case UNLINK_MERGE_PREV: | case UNLINK_MERGE_PREV: | ||||
vm_map_splay_findprev(root, &llist); | vm_map_splay_findprev(root, &llist); | ||||
llist->end = root->end; | llist->end = root->end; | ||||
y = root->right; | y = root->right; | ||||
Show All 14 Lines | |||||
} else if (rlist != NULL) { | } else if (rlist != NULL) { | ||||
root = rlist; | root = rlist; | ||||
rlist = root->left; | rlist = root->left; | ||||
root->left = NULL; | root->left = NULL; | ||||
} else | } else | ||||
root = NULL; | root = NULL; | ||||
break; | break; | ||||
} | } | ||||
y = entry->next; | |||||
y->prev = entry->prev; | |||||
y->prev->next = y; | |||||
if (root != NULL) | if (root != NULL) | ||||
root = vm_map_splay_merge(root, llist, rlist, | root = vm_map_splay_merge(root, llist, rlist, | ||||
root->left, root->right); | root->left, root->right); | ||||
map->root = root; | map->root = root; | ||||
VM_MAP_ASSERT_CONSISTENT(map); | VM_MAP_ASSERT_CONSISTENT(map); | ||||
map->nentries--; | map->nentries--; | ||||
CTR3(KTR_VM, "vm_map_entry_unlink: map %p, nentries %d, entry %p", map, | CTR3(KTR_VM, "vm_map_entry_unlink: map %p, nentries %d, entry %p", map, | ||||
map->nentries, entry); | map->nentries, entry); | ||||
Show All 10 Lines | |||||
* The map must be locked, and leaves it so. | * The map must be locked, and leaves it so. | ||||
*/ | */ | ||||
static void | static void | ||||
vm_map_entry_resize_free(vm_map_t map, vm_map_entry_t entry) | vm_map_entry_resize_free(vm_map_t map, vm_map_entry_t entry) | ||||
{ | { | ||||
vm_map_entry_t llist, rlist, root; | vm_map_entry_t llist, rlist, root; | ||||
VM_MAP_ASSERT_LOCKED(map); | VM_MAP_ASSERT_LOCKED(map); | ||||
root = map->root; | llist = rlist = NULL; | ||||
root = vm_map_splay_split(entry->start, 0, root, &llist, &rlist); | root = vm_map_splay_split(entry->start, 0, map->root, &llist, &rlist); | ||||
KASSERT(root != NULL, | KASSERT(root != NULL, | ||||
("vm_map_entry_resize_free: resize_free object not mapped")); | ("vm_map_entry_resize_free: resize_free object not mapped")); | ||||
vm_map_splay_findnext(root, &rlist); | vm_map_splay_findnext(root, &rlist); | ||||
root->right = NULL; | root->right = NULL; | ||||
map->root = vm_map_splay_merge(root, llist, rlist, | map->root = vm_map_splay_merge(root, llist, rlist, | ||||
root->left, root->right); | root->left, root->right); | ||||
VM_MAP_ASSERT_CONSISTENT(map); | VM_MAP_ASSERT_CONSISTENT(map); | ||||
CTR3(KTR_VM, "vm_map_entry_resize_free: map %p, nentries %d, entry %p", map, | CTR3(KTR_VM, "vm_map_entry_resize_free: map %p, nentries %d, entry %p", map, | ||||
Show All 14 Lines | |||||
if ((locked = vm_map_locked(map)) || | if ((locked = vm_map_locked(map)) || | ||||
sx_try_upgrade(&map->lock)) { | sx_try_upgrade(&map->lock)) { | ||||
/* | /* | ||||
* Splay requires a write lock on the map. However, it only | * Splay requires a write lock on the map. However, it only | ||||
* restructures the binary search tree; it does not otherwise | * restructures the binary search tree; it does not otherwise | ||||
* change the map. Thus, the map's timestamp need not change | * change the map. Thus, the map's timestamp need not change | ||||
* on a temporary upgrade. | * on a temporary upgrade. | ||||
*/ | */ | ||||
map->root = cur = vm_map_entry_splay(address, cur); | VM_MAP_ASSERT_CONSISTENT(map); | ||||
map->root = cur = vm_map_entry_splay(address, map); | |||||
VM_MAP_ASSERT_CONSISTENT(map); | VM_MAP_ASSERT_CONSISTENT(map); | ||||
if (!locked) | if (!locked) | ||||
sx_downgrade(&map->lock); | sx_downgrade(&map->lock); | ||||
/* | /* | ||||
* If "address" is contained within a map entry, the new root | * If "address" is contained within a map entry, the new root | ||||
* is that map entry. Otherwise, the new root is a map entry | * is that map entry. Otherwise, the new root is a map entry | ||||
* immediately before or after "address". | * immediately before or after "address". | ||||
Show All 14 Lines | |||||
/* Empty tree means wide open address space. */ | /* Empty tree means wide open address space. */ | ||||
if (map->root == NULL) | if (map->root == NULL) | ||||
return (start); | return (start); | ||||
/* | /* | ||||
* After splay, if start comes before root node, then there | * After splay, if start comes before root node, then there | ||||
* must be a gap from start to the root. | * must be a gap from start to the root. | ||||
*/ | */ | ||||
root = vm_map_splay_split(start, length, map->root, | llist = rlist = NULL; | ||||
&llist, &rlist); | root = vm_map_splay_split(start, length, map->root, &llist, &rlist); | ||||
if (root != NULL) | if (root != NULL) | ||||
start = root->end; | start = root->end; | ||||
else if (rlist != NULL) { | else if (rlist != NULL) { | ||||
root = rlist; | root = rlist; | ||||
rlist = root->left; | rlist = root->left; | ||||
root->left = NULL; | root->left = NULL; | ||||
} else { | } else { | ||||
root = llist; | root = llist; | ||||
Show All 14 Lines | |||||
/* With max_free, can immediately tell if no solution. */ | /* With max_free, can immediately tell if no solution. */ | ||||
if (root->right == NULL || length > root->right->max_free) | if (root->right == NULL || length > root->right->max_free) | ||||
return (vm_map_max(map) - length + 1); | return (vm_map_max(map) - length + 1); | ||||
/* | /* | ||||
* Splay for the least large-enough gap in the right subtree. | * Splay for the least large-enough gap in the right subtree. | ||||
*/ | */ | ||||
llist = NULL; | llist = rlist = NULL; | ||||
rlist = NULL; | |||||
for (left_length = 0; ; | for (left_length = 0; ; | ||||
left_length = root->left != NULL ? | left_length = root->left != NULL ? | ||||
root->left->max_free : root->start - llist->end) { | root->left->max_free : root->start - llist->end) { | ||||
if (length <= left_length) | if (length <= left_length) | ||||
SPLAY_LEFT_STEP(root, y, rlist, | SPLAY_LEFT_STEP(root, y, rlist, | ||||
length <= (y->left != NULL ? | length <= (y->left != NULL ? | ||||
y->left->max_free : y->start - llist->end)); | y->left->max_free : y->start - llist->end)); | ||||
else | else | ||||
Show All 14 Lines | |||||
VM_OBJECT_WUNLOCK(entry->object.vm_object); | VM_OBJECT_WUNLOCK(entry->object.vm_object); | ||||
entry->cred = NULL; | entry->cred = NULL; | ||||
} | } | ||||
new_entry = vm_map_entry_create(map); | new_entry = vm_map_entry_create(map); | ||||
*new_entry = *entry; | *new_entry = *entry; | ||||
new_entry->end = start; | new_entry->end = start; | ||||
entry->offset += (start - entry->start); | |||||
entry->start = start; | |||||
if (new_entry->cred != NULL) | if (new_entry->cred != NULL) | ||||
crhold(entry->cred); | crhold(entry->cred); | ||||
vm_map_entry_link(map, new_entry); | vm_map_entry_link(map, new_entry); | ||||
if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) == 0) { | if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) == 0) { | ||||
vm_object_reference(new_entry->object.vm_object); | vm_object_reference(new_entry->object.vm_object); | ||||
/* | /* | ||||
Show All 14 Lines | |||||
} | } | ||||
/* | /* | ||||
* Create a new entry and insert it AFTER the specified entry | * Create a new entry and insert it AFTER the specified entry | ||||
*/ | */ | ||||
new_entry = vm_map_entry_create(map); | new_entry = vm_map_entry_create(map); | ||||
*new_entry = *entry; | *new_entry = *entry; | ||||
new_entry->start = entry->end = end; | new_entry->start = end; | ||||
new_entry->offset += (end - entry->start); | new_entry->offset += (end - entry->start); | ||||
if (new_entry->cred != NULL) | if (new_entry->cred != NULL) | ||||
crhold(entry->cred); | crhold(entry->cred); | ||||
vm_map_entry_link(map, new_entry); | vm_map_entry_link(map, new_entry); | ||||
if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) == 0) { | if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) == 0) { | ||||
vm_object_reference(new_entry->object.vm_object); | vm_object_reference(new_entry->object.vm_object); | ||||
} | } | ||||
} | } | ||||
/* | /* | ||||
* vm_map_submap: [ kernel use only ] | * vm_map_submap: [ kernel use only ] | ||||
* | * | ||||
* Mark the given range as handled by a subordinate map. | * Mark the given range as handled by a subordinate map. | ||||
Context not available. |
These functions operate on entries. Why has "entry_" been removed from the function name?