Lines Matching full:start
110 * Since portions of maps are specified by start/end addresses,
112 * routines merely "clip" entries to these start/end values.
114 * start or end value.] Note that these clippings may not
165 #define VM_MAP_RANGE_CHECK(map, start, end) \
167 if (start < vm_map_min(map)) \
168 start = vm_map_min(map); \
171 if (start > end) \
172 start = end; \
603 vm_pager_release_writecount(object, entry->start,
891 map->header.start = max;
996 root->left->max_free : root->start - left_ancestor->end);
1004 root->right->max_free : right_ancestor->start - root->end);
1020 if (prior->right->start < entry->start) {
1063 vm_size_max(max_free, root->start - y->end);\
1104 vm_size_max(max_free, y->start - root->end);\
1124 * vm_map_splay_merge_{left,right,pred,succ}, rely on the start and end address
1136 KASSERT(left->end <= root->start &&
1137 root->end <= right->start,
1139 if (addr < root->start) {
1141 y->max_free >= length && addr < y->start);
1225 max_free = root->start - llist->end;
1282 max_free = rlist->start - root->end;
1396 root = vm_map_splay_split(map, entry->start, 0, &llist, &rlist);
1404 } else if (entry->start == root->start) {
1415 root->offset += entry->end - root->start;
1416 root->start = entry->end;
1423 * The new entry is a clone of root, with only the start field
1432 entry->offset += entry->start - root->start;
1433 root->end = entry->start;
1458 root = vm_map_splay_split(map, entry->start, 0, &llist, &rlist);
1465 rlist->start = root->start;
1507 root = vm_map_splay_split(map, entry->start, 0, &llist, &rlist);
1549 if (address >= cur->start && cur->end > address) {
1572 if (address < cur->start) {
1585 if (address < cur->start) {
1613 vm_offset_t start, vm_offset_t end, vm_prot_t prot, vm_prot_t max, int cow,
1635 * Check that the start and end points are not bogus.
1637 if (start == end || !vm_map_range_valid(map, start, end))
1648 if (vm_map_lookup_entry(map, start, &prev_entry))
1655 if (next_entry->start < end)
1692 if ((start & bdry) != 0 || (end & bdry) != 0)
1702 if (!(cow & MAP_ACC_CHARGED) && !swap_reserve(end - start))
1732 prev_entry->end == start && (prev_entry->cred == cred ||
1737 (vm_size_t)(prev_entry->end - prev_entry->start),
1769 (prev_entry->end - prev_entry->start);
1784 new_entry->start = start;
1798 new_entry->next_read = start;
1809 map->size += new_entry->end - new_entry->start;
1821 vm_map_pmap_enter(map, start, prot, object, OFF_TO_IDX(offset),
1822 end - start, cow & MAP_PREFAULT_PARTIAL);
1841 vm_offset_t start, vm_offset_t end, vm_prot_t prot, vm_prot_t max, int cow)
1845 return (vm_map_insert1(map, object, offset, start, end, prot, max,
1853 * beginning at address >= start in the given map.
1867 vm_map_findspace(vm_map_t map, vm_offset_t start, vm_size_t length)
1879 start = MAX(start, vm_map_min(map));
1880 if (start >= vm_map_max(map) || length > vm_map_max(map) - start)
1885 return (start);
1888 * After splay_split, if start is within an entry, push it to the start
1890 * start, save the end of that gap in gap_end to see if the gap is big
1891 * enough; otherwise set gap_end to start skip gap-checking and move
1895 root = vm_map_splay_split(map, start, length, &llist, &rlist);
1896 gap_end = rlist->start;
1898 start = root->end;
1900 gap_end = start;
1917 if (length <= gap_end - start)
1918 return (start);
1960 vm_offset_t start, vm_size_t length, vm_prot_t prot,
1966 end = start + length;
1970 VM_MAP_RANGE_CHECK(map, start, end);
1972 result = vm_map_delete(map, start, end);
1977 result = vm_map_stack_locked(map, start, length, sgrowsiz,
1980 result = vm_map_insert(map, object, offset, start, end,
2049 * At the start of every iteration, the free space at address
2230 /* And randomize the start address. */
2336 return (prev->end == entry->start &&
2339 prev->offset + (prev->end - prev->start) == entry->offset) &&
2408 object = vm_object_allocate_anon(atop(entry->end - entry->start), NULL,
2409 entry->cred, entry->end - entry->start);
2438 entry->object.vm_object->charge = entry->end - entry->start;
2495 "%s: map %p entry %p start 0x%jx", __func__, map, entry,
2498 if (startaddr <= entry->start)
2502 KASSERT(entry->end > startaddr && entry->start < startaddr,
2525 * Find the entry at or just after 'start', and clip it if 'start' is in
2526 * the interior of the entry. Return entry after 'start', and in
2527 * prev_entry set the entry before 'start'.
2530 vm_map_lookup_clip_start(vm_map_t map, vm_offset_t start,
2538 "%s: map %p start 0x%jx prev %p", __func__, map,
2539 (uintmax_t)start, prev_entry);
2541 if (vm_map_lookup_entry(map, start, prev_entry)) {
2543 rv = vm_map_clip_start(map, entry, start);
2575 KASSERT(entry->start < endaddr && entry->end > endaddr,
2590 new_entry->start = endaddr;
2617 vm_offset_t start,
2631 VM_MAP_RANGE_CHECK(map, start, end);
2632 if (vm_map_lookup_entry(map, start, &entry) && entry->end >= end &&
2635 result = vm_map_clip_start(map, entry, start);
2677 vm_offset_t start;
2705 start = 0;
2731 start = addr + ptoa(tmpidx);
2749 pmap_enter_object(map->pmap, start, addr +
2755 pmap_enter_object(map->pmap, start, addr + ptoa(psize),
2788 vm_map_protect(vm_map_t map, vm_offset_t start, vm_offset_t end,
2798 if (start == end)
2806 orig_start = start;
2809 start = orig_start;
2827 VM_MAP_RANGE_CHECK(map, start, end);
2829 if (!vm_map_lookup_entry(map, start, &first_entry))
2845 start = first_entry->start;
2856 for (entry = first_entry; entry->start < end;
2895 rv = vm_map_clip_start(map, first_entry, start);
2900 for (entry = first_entry; entry->start < end;
2919 if (!swap_reserve(entry->end - entry->start)) {
2962 entry->start < end;
3001 pmap_protect(map->pmap, entry->start,
3023 vm_offset_t start,
3045 if (start == end)
3053 if (start == end)
3065 VM_MAP_RANGE_CHECK(map, start, end);
3074 rv = vm_map_lookup_clip_start(map, start, &entry, &prev_entry);
3080 for (; entry->start < end; prev_entry = entry,
3133 if (!vm_map_lookup_entry(map, start, &entry))
3135 for (; entry->start < end;
3156 pend = pstart + atop(entry->end - entry->start);
3157 useStart = entry->start;
3160 if (entry->start < start) {
3161 pstart += atop(start - entry->start);
3162 useStart = start;
3220 vm_map_inherit(vm_map_t map, vm_offset_t start, vm_offset_t end,
3235 if (start == end)
3238 VM_MAP_RANGE_CHECK(map, start, end);
3239 rv = vm_map_lookup_clip_start(map, start, &start_entry, &prev_entry);
3248 for (entry = start_entry; entry->start < end;
3257 for (entry = start_entry; entry->start < end; prev_entry = entry,
3278 * 'start' position of the old entry.
3285 vm_offset_t start;
3294 start = MAX(in_start, in_entry->start);
3311 if (!vm_map_lookup_entry(map, start, &entry)) {
3313 *io_end = start;
3327 vm_map_unwire(vm_map_t map, vm_offset_t start, vm_offset_t end,
3334 if (start == end)
3339 VM_MAP_RANGE_CHECK(map, start, end);
3340 if (!vm_map_lookup_entry(map, start, &first_entry)) {
3349 for (entry = first_entry; entry->start < end; entry = next_entry) {
3354 next_entry = vm_map_entry_in_transition(map, start,
3368 rv = vm_map_clip_start(map, entry, start);
3390 entry->end < end && next_entry->start > entry->end) {
3407 !vm_map_lookup_entry(map, start, &first_entry)) {
3415 for (; entry->start < end;
3503 * If any pages at the start of this entry were successfully wired,
3506 if (failed_addr > entry->start) {
3507 pmap_unwire(map->pmap, entry->start, failed_addr);
3509 failed_addr - entry->start, PQ_ACTIVE);
3520 vm_map_wire(vm_map_t map, vm_offset_t start, vm_offset_t end, int flags)
3525 rv = vm_map_wire_locked(map, start, end, flags);
3537 vm_map_wire_locked(vm_map_t map, vm_offset_t start, vm_offset_t end, int flags)
3549 if (start == end)
3556 VM_MAP_RANGE_CHECK(map, start, end);
3557 if (!vm_map_lookup_entry(map, start, &first_entry)) {
3563 for (entry = first_entry; entry->start < end; entry = next_entry) {
3568 next_entry = vm_map_entry_in_transition(map, start,
3580 rv = vm_map_clip_start(map, entry, start);
3607 npages = atop(entry->end - entry->start);
3610 entry->start);
3620 saved_start = entry->start;
3685 entry->end < end && next_entry->start > entry->end) {
3695 !vm_map_lookup_entry(map, start, &first_entry)) {
3703 for (; entry->start < end;
3746 atop(entry->end - entry->start));
3776 * If the size of the region from start to end is zero, we are
3778 * start. Unfortunately, a region can be split or coalesced with
3781 * flushing the current region containing start.
3788 vm_offset_t start,
3802 VM_MAP_RANGE_CHECK(map, start, end);
3803 if (!vm_map_lookup_entry(map, start, &first_entry)) {
3806 } else if (start == end) {
3807 start = first_entry->start;
3815 for (entry = first_entry; entry->start < end; entry = next_entry) {
3823 ((start & (pagesizes[bdry_idx] - 1)) != 0 ||
3831 entry->end != next_entry->start) {
3838 pmap_remove(map->pmap, start, end);
3845 for (entry = first_entry; entry->start < end;) {
3846 offset = entry->offset + (start - entry->start);
3847 size = (end <= entry->end ? end : entry->end) - start;
3860 offset = tentry->offset + (offset - tentry->start);
3870 start += size;
3874 !vm_map_lookup_entry(map, start, &entry))
3899 size = entry->end - entry->start;
3902 pmap_unwire(map->pmap, entry->start, entry->end);
3940 size = entry->end - entry->start;
4002 vm_map_delete(vm_map_t map, vm_offset_t start, vm_offset_t end)
4009 if (start == end)
4013 * Find the start of the region, and clip it.
4016 rv = vm_map_lookup_clip_start(map, start, &entry, &scratch_entry);
4019 for (; entry->start < end; entry = next_entry) {
4031 saved_start = entry->start;
4072 pmap_map_delete(map->pmap, entry->start, entry->end);
4092 vm_map_remove(vm_map_t map, vm_offset_t start, vm_offset_t end)
4097 VM_MAP_RANGE_CHECK(map, start, end);
4098 result = vm_map_delete(map, start, end);
4118 vm_map_check_protection(vm_map_t map, vm_offset_t start, vm_offset_t end,
4124 if (!vm_map_lookup_entry(map, start, &tmp_entry))
4128 while (start < end) {
4132 if (start < entry->start)
4140 start = entry->end;
4230 src_entry->start,
4238 size = src_entry->end - src_entry->start;
4270 fake_entry->start = src_entry->start;
4278 dst_entry->start, dst_entry->end - dst_entry->start,
4279 src_entry->start);
4316 entrysize = entry->end - entry->start;
4320 } else if (entry->start >= (vm_offset_t)vm1->vm_daddr &&
4321 entry->start < (vm_offset_t)vm1->vm_daddr + ctob(vm1->vm_dsize)) {
4324 vm2->vm_dsize += btoc(newend - entry->start);
4325 } else if (entry->start >= (vm_offset_t)vm1->vm_taddr &&
4326 entry->start < (vm_offset_t)vm1->vm_taddr + ctob(vm1->vm_tsize)) {
4329 vm2->vm_tsize += btoc(newend - entry->start);
4418 old_entry->end - old_entry->start,
4440 old_entry->start;
4475 new_entry->start, new_entry->end);
4490 new_entry->start,
4491 (old_entry->end - old_entry->start),
4492 old_entry->start);
4525 new_entry->start = old_entry->start;
4540 *fork_charge += (new_entry->end - new_entry->start);
4623 if (vm_map_entry_succ(prev_entry)->start < addrbos + max_ssize)
4642 KASSERT(new_entry->end == top || new_entry->start == bot,
4643 ("Bad entry start/end for new stack entry"));
4724 stack_entry->start != gap_entry->end)
4726 grow_amount = round_page(stack_entry->start - addr);
4733 max_grow = gap_entry->end - gap_entry->start;
4828 if (gap_entry->start + grow_amount == gap_entry->end) {
4829 gap_start = gap_entry->start;
4834 MPASS(gap_entry->start < gap_entry->end - grow_amount);
5054 size = entry->end - entry->start;
5132 *pindex = OFF_TO_IDX((vaddr - entry->start) + entry->offset);
5213 *pindex = OFF_TO_IDX((vaddr - entry->start) + entry->offset);
5257 vm_map_range_valid_KBI(vm_map_t map, vm_offset_t start, vm_offset_t end)
5260 return (vm_map_range_valid(map, start, end));
5279 KASSERT(prev->end <= entry->start,
5280 ("map %p prev->end = %jx, start = %jx", map,
5281 (uintmax_t)prev->end, (uintmax_t)entry->start));
5282 KASSERT(entry->start < entry->end,
5283 ("map %p start = %jx, end = %jx", map,
5284 (uintmax_t)entry->start, (uintmax_t)entry->end));
5286 entry->left->start < entry->start,
5287 ("map %p left->start = %jx, start = %jx", map,
5288 (uintmax_t)entry->left->start, (uintmax_t)entry->start));
5290 entry->start < entry->right->start,
5291 ("map %p start = %jx, right->start = %jx", map,
5292 (uintmax_t)entry->start, (uintmax_t)entry->right->start));
5296 if (entry->start < cur->start) {
5301 map, (uintmax_t)entry->start));
5302 } else if (cur->end <= entry->start) {
5307 map, (uintmax_t)entry->start));
5311 map, (uintmax_t)entry->start));
5323 KASSERT(prev->end <= entry->start,
5324 ("map %p prev->end = %jx, start = %jx", map,
5325 (uintmax_t)prev->end, (uintmax_t)entry->start));
5347 db_iprintf("map entry %p: start=%p, end=%p, eflags=%#x, \n",
5348 (void *)entry, (void *)entry->start, (void *)entry->end,