Rev 1070 | Rev 1108 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
703 | jermar | 1 | /* |
2 | * Copyright (C) 2001-2006 Jakub Jermar |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without |
||
6 | * modification, are permitted provided that the following conditions |
||
7 | * are met: |
||
8 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - Redistributions in binary form must reproduce the above copyright |
||
12 | * notice, this list of conditions and the following disclaimer in the |
||
13 | * documentation and/or other materials provided with the distribution. |
||
14 | * - The name of the author may not be used to endorse or promote products |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
29 | /* |
||
30 | * This file contains address space manipulation functions. |
||
31 | * Roughly speaking, this is a higher-level client of |
||
32 | * Virtual Address Translation (VAT) subsystem. |
||
33 | */ |
||
34 | |||
35 | #include <mm/as.h> |
||
756 | jermar | 36 | #include <arch/mm/as.h> |
703 | jermar | 37 | #include <mm/page.h> |
38 | #include <mm/frame.h> |
||
814 | palkovsky | 39 | #include <mm/slab.h> |
703 | jermar | 40 | #include <mm/tlb.h> |
41 | #include <arch/mm/page.h> |
||
42 | #include <genarch/mm/page_pt.h> |
||
727 | jermar | 43 | #include <mm/asid.h> |
703 | jermar | 44 | #include <arch/mm/asid.h> |
45 | #include <arch/types.h> |
||
46 | #include <typedefs.h> |
||
47 | #include <synch/spinlock.h> |
||
48 | #include <config.h> |
||
788 | jermar | 49 | #include <adt/list.h> |
703 | jermar | 50 | #include <panic.h> |
51 | #include <arch/asm.h> |
||
52 | #include <debug.h> |
||
53 | #include <memstr.h> |
||
1070 | jermar | 54 | #include <macros.h> |
703 | jermar | 55 | #include <arch.h> |
56 | #include <print.h> |
||
57 | |||
756 | jermar | 58 | as_operations_t *as_operations = NULL; |
703 | jermar | 59 | |
823 | jermar | 60 | /** Address space lock. It protects inactive_as_with_asid_head. */ |
61 | SPINLOCK_INITIALIZE(as_lock); |
||
62 | |||
63 | /** |
||
64 | * This list contains address spaces that are not active on any |
||
65 | * processor and that have valid ASID. |
||
66 | */ |
||
67 | LIST_INITIALIZE(inactive_as_with_asid_head); |
||
68 | |||
757 | jermar | 69 | /** Kernel address space. */ |
70 | as_t *AS_KERNEL = NULL; |
||
71 | |||
754 | jermar | 72 | static int get_area_flags(as_area_t *a); |
977 | jermar | 73 | static as_area_t *find_area_and_lock(as_t *as, __address va); |
1048 | jermar | 74 | static bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area); |
703 | jermar | 75 | |
756 | jermar | 76 | /** Initialize address space subsystem. */ |
77 | void as_init(void) |
||
78 | { |
||
79 | as_arch_init(); |
||
789 | palkovsky | 80 | AS_KERNEL = as_create(FLAG_AS_KERNEL); |
756 | jermar | 81 | if (!AS_KERNEL) |
82 | panic("can't create kernel address space\n"); |
||
83 | } |
||
84 | |||
757 | jermar | 85 | /** Create address space. |
86 | * |
||
87 | * @param flags Flags that influence way in wich the address space is created. |
||
88 | */ |
||
756 | jermar | 89 | as_t *as_create(int flags) |
703 | jermar | 90 | { |
91 | as_t *as; |
||
92 | |||
822 | palkovsky | 93 | as = (as_t *) malloc(sizeof(as_t), 0); |
823 | jermar | 94 | link_initialize(&as->inactive_as_with_asid_link); |
822 | palkovsky | 95 | spinlock_initialize(&as->lock, "as_lock"); |
96 | list_initialize(&as->as_area_head); |
||
97 | |||
98 | if (flags & FLAG_AS_KERNEL) |
||
99 | as->asid = ASID_KERNEL; |
||
100 | else |
||
101 | as->asid = ASID_INVALID; |
||
102 | |||
823 | jermar | 103 | as->refcount = 0; |
822 | palkovsky | 104 | as->page_table = page_table_create(flags); |
703 | jermar | 105 | |
106 | return as; |
||
107 | } |
||
108 | |||
973 | palkovsky | 109 | /** Free Adress space */ |
110 | void as_free(as_t *as) |
||
111 | { |
||
112 | ASSERT(as->refcount == 0); |
||
113 | |||
114 | /* TODO: free as_areas and other resources held by as */ |
||
115 | /* TODO: free page table */ |
||
116 | free(as); |
||
117 | } |
||
118 | |||
703 | jermar | 119 | /** Create address space area of common attributes. |
120 | * |
||
121 | * The created address space area is added to the target address space. |
||
122 | * |
||
123 | * @param as Target address space. |
||
1026 | jermar | 124 | * @param flags Flags of the area. |
1048 | jermar | 125 | * @param size Size of area. |
703 | jermar | 126 | * @param base Base address of area. |
127 | * |
||
128 | * @return Address space area on success or NULL on failure. |
||
129 | */ |
||
1026 | jermar | 130 | as_area_t *as_area_create(as_t *as, int flags, size_t size, __address base) |
703 | jermar | 131 | { |
132 | ipl_t ipl; |
||
133 | as_area_t *a; |
||
134 | |||
135 | if (base % PAGE_SIZE) |
||
1048 | jermar | 136 | return NULL; |
137 | |||
138 | /* Writeable executable areas are not supported. */ |
||
139 | if ((flags & AS_AREA_EXEC) && (flags & AS_AREA_WRITE)) |
||
140 | return NULL; |
||
703 | jermar | 141 | |
142 | ipl = interrupts_disable(); |
||
143 | spinlock_lock(&as->lock); |
||
144 | |||
1048 | jermar | 145 | if (!check_area_conflicts(as, base, size, NULL)) { |
146 | spinlock_unlock(&as->lock); |
||
147 | interrupts_restore(ipl); |
||
148 | return NULL; |
||
149 | } |
||
703 | jermar | 150 | |
822 | palkovsky | 151 | a = (as_area_t *) malloc(sizeof(as_area_t), 0); |
703 | jermar | 152 | |
822 | palkovsky | 153 | spinlock_initialize(&a->lock, "as_area_lock"); |
154 | |||
155 | link_initialize(&a->link); |
||
1026 | jermar | 156 | a->flags = flags; |
1048 | jermar | 157 | a->pages = SIZE2FRAMES(size); |
822 | palkovsky | 158 | a->base = base; |
159 | |||
160 | list_append(&a->link, &as->as_area_head); |
||
161 | |||
703 | jermar | 162 | spinlock_unlock(&as->lock); |
163 | interrupts_restore(ipl); |
||
704 | jermar | 164 | |
703 | jermar | 165 | return a; |
166 | } |
||
167 | |||
754 | jermar | 168 | /** Initialize mapping for one page of address space. |
703 | jermar | 169 | * |
754 | jermar | 170 | * This functions maps 'page' to 'frame' according |
171 | * to attributes of the address space area to |
||
172 | * wich 'page' belongs. |
||
703 | jermar | 173 | * |
840 | jermar | 174 | * @param as Target address space. |
754 | jermar | 175 | * @param page Virtual page within the area. |
176 | * @param frame Physical frame to which page will be mapped. |
||
703 | jermar | 177 | */ |
754 | jermar | 178 | void as_set_mapping(as_t *as, __address page, __address frame) |
703 | jermar | 179 | { |
977 | jermar | 180 | as_area_t *area; |
703 | jermar | 181 | ipl_t ipl; |
182 | |||
183 | ipl = interrupts_disable(); |
||
1044 | jermar | 184 | page_table_lock(as, true); |
703 | jermar | 185 | |
977 | jermar | 186 | area = find_area_and_lock(as, page); |
754 | jermar | 187 | if (!area) { |
188 | panic("page not part of any as_area\n"); |
||
189 | } |
||
190 | |||
756 | jermar | 191 | page_mapping_insert(as, page, frame, get_area_flags(area)); |
754 | jermar | 192 | |
193 | spinlock_unlock(&area->lock); |
||
1044 | jermar | 194 | page_table_unlock(as, true); |
703 | jermar | 195 | interrupts_restore(ipl); |
196 | } |
||
197 | |||
198 | /** Handle page fault within the current address space. |
||
199 | * |
||
200 | * This is the high-level page fault handler. |
||
201 | * Interrupts are assumed disabled. |
||
202 | * |
||
203 | * @param page Faulting page. |
||
204 | * |
||
704 | jermar | 205 | * @return 0 on page fault, 1 on success. |
703 | jermar | 206 | */ |
207 | int as_page_fault(__address page) |
||
208 | { |
||
1044 | jermar | 209 | pte_t *pte; |
977 | jermar | 210 | as_area_t *area; |
703 | jermar | 211 | __address frame; |
212 | |||
213 | ASSERT(AS); |
||
1044 | jermar | 214 | |
703 | jermar | 215 | spinlock_lock(&AS->lock); |
977 | jermar | 216 | area = find_area_and_lock(AS, page); |
703 | jermar | 217 | if (!area) { |
218 | /* |
||
219 | * No area contained mapping for 'page'. |
||
220 | * Signal page fault to low-level handler. |
||
221 | */ |
||
222 | spinlock_unlock(&AS->lock); |
||
223 | return 0; |
||
224 | } |
||
225 | |||
1044 | jermar | 226 | page_table_lock(AS, false); |
227 | |||
703 | jermar | 228 | /* |
1044 | jermar | 229 | * To avoid race condition between two page faults |
230 | * on the same address, we need to make sure |
||
231 | * the mapping has not been already inserted. |
||
232 | */ |
||
233 | if ((pte = page_mapping_find(AS, page))) { |
||
234 | if (PTE_PRESENT(pte)) { |
||
235 | page_table_unlock(AS, false); |
||
236 | spinlock_unlock(&area->lock); |
||
237 | spinlock_unlock(&AS->lock); |
||
238 | return 1; |
||
239 | } |
||
240 | } |
||
241 | |||
242 | /* |
||
754 | jermar | 243 | * In general, there can be several reasons that |
244 | * can have caused this fault. |
||
245 | * |
||
246 | * - non-existent mapping: the area is a scratch |
||
247 | * area (e.g. stack) and so far has not been |
||
248 | * allocated a frame for the faulting page |
||
249 | * |
||
250 | * - non-present mapping: another possibility, |
||
251 | * currently not implemented, would be frame |
||
252 | * reuse; when this becomes a possibility, |
||
253 | * do not forget to distinguish between |
||
254 | * the different causes |
||
703 | jermar | 255 | */ |
814 | palkovsky | 256 | frame = PFN2ADDR(frame_alloc(ONE_FRAME, 0)); |
754 | jermar | 257 | memsetb(PA2KA(frame), FRAME_SIZE, 0); |
703 | jermar | 258 | |
259 | /* |
||
260 | * Map 'page' to 'frame'. |
||
261 | * Note that TLB shootdown is not attempted as only new information is being |
||
262 | * inserted into page tables. |
||
263 | */ |
||
756 | jermar | 264 | page_mapping_insert(AS, page, frame, get_area_flags(area)); |
1044 | jermar | 265 | page_table_unlock(AS, false); |
703 | jermar | 266 | |
267 | spinlock_unlock(&area->lock); |
||
268 | spinlock_unlock(&AS->lock); |
||
269 | return 1; |
||
270 | } |
||
271 | |||
823 | jermar | 272 | /** Switch address spaces. |
703 | jermar | 273 | * |
823 | jermar | 274 | * @param old Old address space or NULL. |
275 | * @param new New address space. |
||
703 | jermar | 276 | */ |
823 | jermar | 277 | void as_switch(as_t *old, as_t *new) |
703 | jermar | 278 | { |
279 | ipl_t ipl; |
||
823 | jermar | 280 | bool needs_asid = false; |
703 | jermar | 281 | |
282 | ipl = interrupts_disable(); |
||
823 | jermar | 283 | spinlock_lock(&as_lock); |
703 | jermar | 284 | |
285 | /* |
||
823 | jermar | 286 | * First, take care of the old address space. |
287 | */ |
||
288 | if (old) { |
||
289 | spinlock_lock(&old->lock); |
||
290 | ASSERT(old->refcount); |
||
291 | if((--old->refcount == 0) && (old != AS_KERNEL)) { |
||
292 | /* |
||
293 | * The old address space is no longer active on |
||
294 | * any processor. It can be appended to the |
||
295 | * list of inactive address spaces with assigned |
||
296 | * ASID. |
||
297 | */ |
||
298 | ASSERT(old->asid != ASID_INVALID); |
||
299 | list_append(&old->inactive_as_with_asid_link, &inactive_as_with_asid_head); |
||
300 | } |
||
301 | spinlock_unlock(&old->lock); |
||
302 | } |
||
303 | |||
304 | /* |
||
305 | * Second, prepare the new address space. |
||
306 | */ |
||
307 | spinlock_lock(&new->lock); |
||
308 | if ((new->refcount++ == 0) && (new != AS_KERNEL)) { |
||
309 | if (new->asid != ASID_INVALID) |
||
310 | list_remove(&new->inactive_as_with_asid_link); |
||
311 | else |
||
312 | needs_asid = true; /* defer call to asid_get() until new->lock is released */ |
||
313 | } |
||
314 | SET_PTL0_ADDRESS(new->page_table); |
||
315 | spinlock_unlock(&new->lock); |
||
316 | |||
317 | if (needs_asid) { |
||
318 | /* |
||
319 | * Allocation of new ASID was deferred |
||
320 | * until now in order to avoid deadlock. |
||
321 | */ |
||
322 | asid_t asid; |
||
323 | |||
324 | asid = asid_get(); |
||
325 | spinlock_lock(&new->lock); |
||
326 | new->asid = asid; |
||
327 | spinlock_unlock(&new->lock); |
||
328 | } |
||
329 | spinlock_unlock(&as_lock); |
||
330 | interrupts_restore(ipl); |
||
331 | |||
332 | /* |
||
703 | jermar | 333 | * Perform architecture-specific steps. |
727 | jermar | 334 | * (e.g. write ASID to hardware register etc.) |
703 | jermar | 335 | */ |
823 | jermar | 336 | as_install_arch(new); |
703 | jermar | 337 | |
823 | jermar | 338 | AS = new; |
703 | jermar | 339 | } |
754 | jermar | 340 | |
341 | /** Compute flags for virtual address translation subsytem. |
||
342 | * |
||
343 | * The address space area must be locked. |
||
344 | * Interrupts must be disabled. |
||
345 | * |
||
346 | * @param a Address space area. |
||
347 | * |
||
348 | * @return Flags to be used in page_mapping_insert(). |
||
349 | */ |
||
350 | int get_area_flags(as_area_t *a) |
||
351 | { |
||
352 | int flags; |
||
353 | |||
1026 | jermar | 354 | flags = PAGE_USER | PAGE_PRESENT | PAGE_CACHEABLE; |
754 | jermar | 355 | |
1026 | jermar | 356 | if (a->flags & AS_AREA_READ) |
357 | flags |= PAGE_READ; |
||
358 | |||
359 | if (a->flags & AS_AREA_WRITE) |
||
360 | flags |= PAGE_WRITE; |
||
361 | |||
362 | if (a->flags & AS_AREA_EXEC) |
||
363 | flags |= PAGE_EXEC; |
||
364 | |||
754 | jermar | 365 | return flags; |
366 | } |
||
756 | jermar | 367 | |
368 | /** Create page table. |
||
369 | * |
||
370 | * Depending on architecture, create either address space |
||
371 | * private or global page table. |
||
372 | * |
||
373 | * @param flags Flags saying whether the page table is for kernel address space. |
||
374 | * |
||
375 | * @return First entry of the page table. |
||
376 | */ |
||
377 | pte_t *page_table_create(int flags) |
||
378 | { |
||
379 | ASSERT(as_operations); |
||
380 | ASSERT(as_operations->page_table_create); |
||
381 | |||
382 | return as_operations->page_table_create(flags); |
||
383 | } |
||
977 | jermar | 384 | |
1044 | jermar | 385 | /** Lock page table. |
386 | * |
||
387 | * This function should be called before any page_mapping_insert(), |
||
388 | * page_mapping_remove() and page_mapping_find(). |
||
389 | * |
||
390 | * Locking order is such that address space areas must be locked |
||
391 | * prior to this call. Address space can be locked prior to this |
||
392 | * call in which case the lock argument is false. |
||
393 | * |
||
394 | * @param as Address space. |
||
395 | * @param as_locked If false, do not attempt to lock as->lock. |
||
396 | */ |
||
397 | void page_table_lock(as_t *as, bool lock) |
||
398 | { |
||
399 | ASSERT(as_operations); |
||
400 | ASSERT(as_operations->page_table_lock); |
||
401 | |||
402 | as_operations->page_table_lock(as, lock); |
||
403 | } |
||
404 | |||
405 | /** Unlock page table. |
||
406 | * |
||
407 | * @param as Address space. |
||
408 | * @param as_locked If false, do not attempt to unlock as->lock. |
||
409 | */ |
||
410 | void page_table_unlock(as_t *as, bool unlock) |
||
411 | { |
||
412 | ASSERT(as_operations); |
||
413 | ASSERT(as_operations->page_table_unlock); |
||
414 | |||
415 | as_operations->page_table_unlock(as, unlock); |
||
416 | } |
||
417 | |||
977 | jermar | 418 | /** Find address space area and change it. |
419 | * |
||
420 | * @param as Address space. |
||
421 | * @param address Virtual address belonging to the area to be changed. Must be page-aligned. |
||
422 | * @param size New size of the virtual memory block starting at address. |
||
423 | * @param flags Flags influencing the remap operation. Currently unused. |
||
424 | * |
||
425 | * @return address on success, (__address) -1 otherwise. |
||
426 | */ |
||
427 | __address as_remap(as_t *as, __address address, size_t size, int flags) |
||
428 | { |
||
429 | as_area_t *area = NULL; |
||
430 | ipl_t ipl; |
||
431 | size_t pages; |
||
432 | |||
433 | ipl = interrupts_disable(); |
||
434 | spinlock_lock(&as->lock); |
||
435 | |||
436 | /* |
||
437 | * Locate the area. |
||
438 | */ |
||
439 | area = find_area_and_lock(as, address); |
||
440 | if (!area) { |
||
441 | spinlock_unlock(&as->lock); |
||
1048 | jermar | 442 | interrupts_restore(ipl); |
977 | jermar | 443 | return (__address) -1; |
444 | } |
||
445 | |||
446 | pages = SIZE2FRAMES((address - area->base) + size); |
||
1048 | jermar | 447 | if (!check_area_conflicts(as, address, pages * PAGE_SIZE, area)) { |
1076 | jermar | 448 | spinlock_unlock(&area->lock); |
449 | spinlock_unlock(&as->lock); |
||
1048 | jermar | 450 | interrupts_restore(ipl); |
451 | return (__address) -1; |
||
452 | } |
||
453 | |||
454 | if (pages < area->pages) { |
||
977 | jermar | 455 | int i; |
456 | |||
457 | /* |
||
458 | * Shrinking the area. |
||
459 | */ |
||
1048 | jermar | 460 | for (i = pages; i < area->pages; i++) { |
977 | jermar | 461 | pte_t *pte; |
462 | |||
463 | /* |
||
464 | * Releasing physical memory. |
||
465 | * This depends on the fact that the memory was allocated using frame_alloc(). |
||
1044 | jermar | 466 | */ |
467 | page_table_lock(as, false); |
||
977 | jermar | 468 | pte = page_mapping_find(as, area->base + i*PAGE_SIZE); |
980 | palkovsky | 469 | if (pte && PTE_VALID(pte)) { |
1044 | jermar | 470 | __address frame; |
471 | |||
977 | jermar | 472 | ASSERT(PTE_PRESENT(pte)); |
1044 | jermar | 473 | frame = PTE_GET_FRAME(pte); |
983 | palkovsky | 474 | page_mapping_remove(as, area->base + i*PAGE_SIZE); |
1044 | jermar | 475 | page_table_unlock(as, false); |
476 | |||
477 | frame_free(ADDR2PFN(frame)); |
||
478 | } else { |
||
479 | page_table_unlock(as, false); |
||
977 | jermar | 480 | } |
481 | } |
||
482 | /* |
||
483 | * Invalidate TLB's. |
||
484 | */ |
||
1048 | jermar | 485 | tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base + pages*PAGE_SIZE, area->pages - pages); |
486 | tlb_invalidate_pages(AS->asid, area->base + pages*PAGE_SIZE, area->pages - pages); |
||
977 | jermar | 487 | tlb_shootdown_finalize(); |
983 | palkovsky | 488 | } |
489 | |||
1048 | jermar | 490 | area->pages = pages; |
977 | jermar | 491 | |
492 | spinlock_unlock(&area->lock); |
||
493 | spinlock_unlock(&as->lock); |
||
494 | interrupts_restore(ipl); |
||
495 | |||
496 | return address; |
||
497 | } |
||
498 | |||
499 | /** Find address space area and lock it. |
||
500 | * |
||
501 | * The address space must be locked and interrupts must be disabled. |
||
502 | * |
||
503 | * @param as Address space. |
||
504 | * @param va Virtual address. |
||
505 | * |
||
506 | * @return Locked address space area containing va on success or NULL on failure. |
||
507 | */ |
||
508 | as_area_t *find_area_and_lock(as_t *as, __address va) |
||
509 | { |
||
510 | link_t *cur; |
||
511 | as_area_t *a; |
||
512 | |||
513 | for (cur = as->as_area_head.next; cur != &as->as_area_head; cur = cur->next) { |
||
514 | a = list_get_instance(cur, as_area_t, link); |
||
515 | spinlock_lock(&a->lock); |
||
516 | |||
1048 | jermar | 517 | if ((va >= a->base) && (va < a->base + a->pages * PAGE_SIZE)) |
518 | return a; |
||
977 | jermar | 519 | |
520 | spinlock_unlock(&a->lock); |
||
521 | } |
||
522 | |||
523 | return NULL; |
||
524 | } |
||
1048 | jermar | 525 | |
526 | /** Check area conflicts with other areas. |
||
527 | * |
||
528 | * The address space must be locked and interrupts must be disabled. |
||
529 | * |
||
530 | * @param as Address space. |
||
531 | * @param va Starting virtual address of the area being tested. |
||
532 | * @param size Size of the area being tested. |
||
533 | * @param avoid_area Do not touch this area. |
||
534 | * |
||
535 | * @return True if there is no conflict, false otherwise. |
||
536 | */ |
||
537 | bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area) |
||
538 | { |
||
539 | link_t *cur; |
||
540 | as_area_t *a; |
||
541 | |||
1070 | jermar | 542 | /* |
543 | * We don't want any area to have conflicts with NULL page. |
||
544 | */ |
||
545 | if (overlaps(va, size, NULL, PAGE_SIZE)) |
||
546 | return false; |
||
547 | |||
1048 | jermar | 548 | for (cur = as->as_area_head.next; cur != &as->as_area_head; cur = cur->next) { |
1070 | jermar | 549 | __address a_start; |
550 | size_t a_size; |
||
1048 | jermar | 551 | |
552 | a = list_get_instance(cur, as_area_t, link); |
||
553 | if (a == avoid_area) |
||
554 | continue; |
||
555 | |||
556 | spinlock_lock(&a->lock); |
||
557 | |||
1070 | jermar | 558 | a_start = a->base; |
559 | a_size = a->pages * PAGE_SIZE; |
||
1048 | jermar | 560 | |
561 | spinlock_unlock(&a->lock); |
||
562 | |||
1070 | jermar | 563 | if (overlaps(va, size, a_start, a_size)) |
564 | return false; |
||
1048 | jermar | 565 | |
566 | } |
||
567 | |||
1070 | jermar | 568 | /* |
569 | * So far, the area does not conflict with other areas. |
||
570 | * Check if it doesn't conflict with kernel address space. |
||
571 | */ |
||
572 | if (!KERNEL_ADDRESS_SPACE_SHADOWED) { |
||
573 | return !overlaps(va, size, |
||
574 | KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START); |
||
575 | } |
||
576 | |||
1048 | jermar | 577 | return true; |
578 | } |