[20d50a1] | 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 |
|
---|
[9179d0a] | 29 | /**
|
---|
| 30 | * @file as.c
|
---|
| 31 | * @brief Address space related functions.
|
---|
| 32 | *
|
---|
[20d50a1] | 33 | * This file contains address space manipulation functions.
|
---|
| 34 | * Roughly speaking, this is a higher-level client of
|
---|
| 35 | * Virtual Address Translation (VAT) subsystem.
|
---|
[9179d0a] | 36 | *
|
---|
| 37 | * Functionality provided by this file allows one to
|
---|
| 38 | * create address space and create, resize and share
|
---|
| 39 | * address space areas.
|
---|
| 40 | *
|
---|
| 41 | * @see page.c
|
---|
| 42 | *
|
---|
[20d50a1] | 43 | */
|
---|
| 44 |
|
---|
| 45 | #include <mm/as.h>
|
---|
[ef67bab] | 46 | #include <arch/mm/as.h>
|
---|
[20d50a1] | 47 | #include <mm/page.h>
|
---|
| 48 | #include <mm/frame.h>
|
---|
[085d973] | 49 | #include <mm/slab.h>
|
---|
[20d50a1] | 50 | #include <mm/tlb.h>
|
---|
| 51 | #include <arch/mm/page.h>
|
---|
| 52 | #include <genarch/mm/page_pt.h>
|
---|
[2802767] | 53 | #include <genarch/mm/page_ht.h>
|
---|
[4512d7e] | 54 | #include <mm/asid.h>
|
---|
[20d50a1] | 55 | #include <arch/mm/asid.h>
|
---|
| 56 | #include <synch/spinlock.h>
|
---|
[1068f6a] | 57 | #include <synch/mutex.h>
|
---|
[5c9a08b] | 58 | #include <adt/list.h>
|
---|
[252127e] | 59 | #include <adt/btree.h>
|
---|
[df0103f7] | 60 | #include <proc/task.h>
|
---|
[e3c762cd] | 61 | #include <proc/thread.h>
|
---|
[20d50a1] | 62 | #include <arch/asm.h>
|
---|
[df0103f7] | 63 | #include <panic.h>
|
---|
[20d50a1] | 64 | #include <debug.h>
|
---|
[df0103f7] | 65 | #include <print.h>
|
---|
[20d50a1] | 66 | #include <memstr.h>
|
---|
[5a7d9d1] | 67 | #include <macros.h>
|
---|
[20d50a1] | 68 | #include <arch.h>
|
---|
[df0103f7] | 69 | #include <errno.h>
|
---|
| 70 | #include <config.h>
|
---|
| 71 | #include <arch/types.h>
|
---|
| 72 | #include <typedefs.h>
|
---|
[e3c762cd] | 73 | #include <syscall/copy.h>
|
---|
| 74 | #include <arch/interrupt.h>
|
---|
[20d50a1] | 75 |
|
---|
[ef67bab] | 76 | as_operations_t *as_operations = NULL;
|
---|
[20d50a1] | 77 |
|
---|
[1068f6a] | 78 | /** Address space lock. It protects inactive_as_with_asid_head. Must be acquired before as_t mutex. */
|
---|
[7e4e532] | 79 | SPINLOCK_INITIALIZE(as_lock);
|
---|
| 80 |
|
---|
| 81 | /**
|
---|
| 82 | * This list contains address spaces that are not active on any
|
---|
| 83 | * processor and that have valid ASID.
|
---|
| 84 | */
|
---|
| 85 | LIST_INITIALIZE(inactive_as_with_asid_head);
|
---|
| 86 |
|
---|
[071a8ae6] | 87 | /** Kernel address space. */
|
---|
| 88 | as_t *AS_KERNEL = NULL;
|
---|
| 89 |
|
---|
[df0103f7] | 90 | static int area_flags_to_page_flags(int aflags);
|
---|
[6a3c9a7] | 91 | static int get_area_flags(as_area_t *a);
|
---|
[d3e7ff4] | 92 | static as_area_t *find_area_and_lock(as_t *as, __address va);
|
---|
[37e7d2b9] | 93 | static bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area);
|
---|
[20d50a1] | 94 |
|
---|
[ef67bab] | 95 | /** Initialize address space subsystem. */
|
---|
| 96 | void as_init(void)
|
---|
| 97 | {
|
---|
| 98 | as_arch_init();
|
---|
[8e1ea655] | 99 | AS_KERNEL = as_create(FLAG_AS_KERNEL);
|
---|
[ef67bab] | 100 | if (!AS_KERNEL)
|
---|
| 101 | panic("can't create kernel address space\n");
|
---|
| 102 | }
|
---|
| 103 |
|
---|
[071a8ae6] | 104 | /** Create address space.
|
---|
| 105 | *
|
---|
| 106 | * @param flags Flags that influence way in wich the address space is created.
|
---|
| 107 | */
|
---|
[ef67bab] | 108 | as_t *as_create(int flags)
|
---|
[20d50a1] | 109 | {
|
---|
| 110 | as_t *as;
|
---|
| 111 |
|
---|
[bb68433] | 112 | as = (as_t *) malloc(sizeof(as_t), 0);
|
---|
[7e4e532] | 113 | link_initialize(&as->inactive_as_with_asid_link);
|
---|
[1068f6a] | 114 | mutex_initialize(&as->lock);
|
---|
[252127e] | 115 | btree_create(&as->as_area_btree);
|
---|
[bb68433] | 116 |
|
---|
| 117 | if (flags & FLAG_AS_KERNEL)
|
---|
| 118 | as->asid = ASID_KERNEL;
|
---|
| 119 | else
|
---|
| 120 | as->asid = ASID_INVALID;
|
---|
| 121 |
|
---|
[7e4e532] | 122 | as->refcount = 0;
|
---|
[bb68433] | 123 | as->page_table = page_table_create(flags);
|
---|
[20d50a1] | 124 |
|
---|
| 125 | return as;
|
---|
| 126 | }
|
---|
| 127 |
|
---|
[5be1923] | 128 | /** Free Adress space */
|
---|
| 129 | void as_free(as_t *as)
|
---|
| 130 | {
|
---|
| 131 | ASSERT(as->refcount == 0);
|
---|
| 132 |
|
---|
| 133 | /* TODO: free as_areas and other resources held by as */
|
---|
| 134 | /* TODO: free page table */
|
---|
| 135 | free(as);
|
---|
| 136 | }
|
---|
| 137 |
|
---|
[20d50a1] | 138 | /** Create address space area of common attributes.
|
---|
| 139 | *
|
---|
| 140 | * The created address space area is added to the target address space.
|
---|
| 141 | *
|
---|
| 142 | * @param as Target address space.
|
---|
[a9e8b39] | 143 | * @param flags Flags of the area memory.
|
---|
[37e7d2b9] | 144 | * @param size Size of area.
|
---|
[20d50a1] | 145 | * @param base Base address of area.
|
---|
[a9e8b39] | 146 | * @param attrs Attributes of the area.
|
---|
[20d50a1] | 147 | *
|
---|
| 148 | * @return Address space area on success or NULL on failure.
|
---|
| 149 | */
|
---|
[a9e8b39] | 150 | as_area_t *as_area_create(as_t *as, int flags, size_t size, __address base, int attrs)
|
---|
[20d50a1] | 151 | {
|
---|
| 152 | ipl_t ipl;
|
---|
| 153 | as_area_t *a;
|
---|
| 154 |
|
---|
| 155 | if (base % PAGE_SIZE)
|
---|
[37e7d2b9] | 156 | return NULL;
|
---|
| 157 |
|
---|
[dbbeb26] | 158 | if (!size)
|
---|
| 159 | return NULL;
|
---|
| 160 |
|
---|
[37e7d2b9] | 161 | /* Writeable executable areas are not supported. */
|
---|
| 162 | if ((flags & AS_AREA_EXEC) && (flags & AS_AREA_WRITE))
|
---|
| 163 | return NULL;
|
---|
[20d50a1] | 164 |
|
---|
| 165 | ipl = interrupts_disable();
|
---|
[1068f6a] | 166 | mutex_lock(&as->lock);
|
---|
[20d50a1] | 167 |
|
---|
[37e7d2b9] | 168 | if (!check_area_conflicts(as, base, size, NULL)) {
|
---|
[1068f6a] | 169 | mutex_unlock(&as->lock);
|
---|
[37e7d2b9] | 170 | interrupts_restore(ipl);
|
---|
| 171 | return NULL;
|
---|
| 172 | }
|
---|
[20d50a1] | 173 |
|
---|
[bb68433] | 174 | a = (as_area_t *) malloc(sizeof(as_area_t), 0);
|
---|
| 175 |
|
---|
[1068f6a] | 176 | mutex_initialize(&a->lock);
|
---|
[bb68433] | 177 |
|
---|
[c23502d] | 178 | a->flags = flags;
|
---|
[a9e8b39] | 179 | a->attributes = attrs;
|
---|
[37e7d2b9] | 180 | a->pages = SIZE2FRAMES(size);
|
---|
[bb68433] | 181 | a->base = base;
|
---|
| 182 |
|
---|
[252127e] | 183 | btree_insert(&as->as_area_btree, base, (void *) a, NULL);
|
---|
[20d50a1] | 184 |
|
---|
[1068f6a] | 185 | mutex_unlock(&as->lock);
|
---|
[20d50a1] | 186 | interrupts_restore(ipl);
|
---|
[f9425006] | 187 |
|
---|
[20d50a1] | 188 | return a;
|
---|
| 189 | }
|
---|
| 190 |
|
---|
[df0103f7] | 191 | /** Find address space area and change it.
|
---|
| 192 | *
|
---|
| 193 | * @param as Address space.
|
---|
| 194 | * @param address Virtual address belonging to the area to be changed. Must be page-aligned.
|
---|
| 195 | * @param size New size of the virtual memory block starting at address.
|
---|
| 196 | * @param flags Flags influencing the remap operation. Currently unused.
|
---|
| 197 | *
|
---|
[7242a78e] | 198 | * @return Zero on success or a value from @ref errno.h otherwise.
|
---|
[df0103f7] | 199 | */
|
---|
[7242a78e] | 200 | int as_area_resize(as_t *as, __address address, size_t size, int flags)
|
---|
[df0103f7] | 201 | {
|
---|
[7242a78e] | 202 | as_area_t *area;
|
---|
[df0103f7] | 203 | ipl_t ipl;
|
---|
| 204 | size_t pages;
|
---|
| 205 |
|
---|
| 206 | ipl = interrupts_disable();
|
---|
[1068f6a] | 207 | mutex_lock(&as->lock);
|
---|
[df0103f7] | 208 |
|
---|
| 209 | /*
|
---|
| 210 | * Locate the area.
|
---|
| 211 | */
|
---|
| 212 | area = find_area_and_lock(as, address);
|
---|
| 213 | if (!area) {
|
---|
[1068f6a] | 214 | mutex_unlock(&as->lock);
|
---|
[df0103f7] | 215 | interrupts_restore(ipl);
|
---|
[7242a78e] | 216 | return ENOENT;
|
---|
[df0103f7] | 217 | }
|
---|
| 218 |
|
---|
| 219 | if (area->flags & AS_AREA_DEVICE) {
|
---|
| 220 | /*
|
---|
| 221 | * Remapping of address space areas associated
|
---|
| 222 | * with memory mapped devices is not supported.
|
---|
| 223 | */
|
---|
[1068f6a] | 224 | mutex_unlock(&area->lock);
|
---|
| 225 | mutex_unlock(&as->lock);
|
---|
[df0103f7] | 226 | interrupts_restore(ipl);
|
---|
[7242a78e] | 227 | return ENOTSUP;
|
---|
[df0103f7] | 228 | }
|
---|
| 229 |
|
---|
| 230 | pages = SIZE2FRAMES((address - area->base) + size);
|
---|
| 231 | if (!pages) {
|
---|
| 232 | /*
|
---|
| 233 | * Zero size address space areas are not allowed.
|
---|
| 234 | */
|
---|
[1068f6a] | 235 | mutex_unlock(&area->lock);
|
---|
| 236 | mutex_unlock(&as->lock);
|
---|
[df0103f7] | 237 | interrupts_restore(ipl);
|
---|
[7242a78e] | 238 | return EPERM;
|
---|
[df0103f7] | 239 | }
|
---|
| 240 |
|
---|
| 241 | if (pages < area->pages) {
|
---|
| 242 | int i;
|
---|
| 243 |
|
---|
| 244 | /*
|
---|
| 245 | * Shrinking the area.
|
---|
| 246 | * No need to check for overlaps.
|
---|
| 247 | */
|
---|
| 248 | for (i = pages; i < area->pages; i++) {
|
---|
| 249 | pte_t *pte;
|
---|
| 250 |
|
---|
| 251 | /*
|
---|
| 252 | * Releasing physical memory.
|
---|
| 253 | * This depends on the fact that the memory was allocated using frame_alloc().
|
---|
| 254 | */
|
---|
| 255 | page_table_lock(as, false);
|
---|
| 256 | pte = page_mapping_find(as, area->base + i*PAGE_SIZE);
|
---|
| 257 | if (pte && PTE_VALID(pte)) {
|
---|
| 258 | __address frame;
|
---|
| 259 |
|
---|
| 260 | ASSERT(PTE_PRESENT(pte));
|
---|
| 261 | frame = PTE_GET_FRAME(pte);
|
---|
| 262 | page_mapping_remove(as, area->base + i*PAGE_SIZE);
|
---|
| 263 | page_table_unlock(as, false);
|
---|
| 264 |
|
---|
| 265 | frame_free(ADDR2PFN(frame));
|
---|
| 266 | } else {
|
---|
| 267 | page_table_unlock(as, false);
|
---|
| 268 | }
|
---|
| 269 | }
|
---|
| 270 | /*
|
---|
| 271 | * Invalidate TLB's.
|
---|
| 272 | */
|
---|
| 273 | tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base + pages*PAGE_SIZE, area->pages - pages);
|
---|
| 274 | tlb_invalidate_pages(AS->asid, area->base + pages*PAGE_SIZE, area->pages - pages);
|
---|
| 275 | tlb_shootdown_finalize();
|
---|
| 276 | } else {
|
---|
| 277 | /*
|
---|
| 278 | * Growing the area.
|
---|
| 279 | * Check for overlaps with other address space areas.
|
---|
| 280 | */
|
---|
| 281 | if (!check_area_conflicts(as, address, pages * PAGE_SIZE, area)) {
|
---|
[1068f6a] | 282 | mutex_unlock(&area->lock);
|
---|
| 283 | mutex_unlock(&as->lock);
|
---|
[df0103f7] | 284 | interrupts_restore(ipl);
|
---|
[7242a78e] | 285 | return EADDRNOTAVAIL;
|
---|
[df0103f7] | 286 | }
|
---|
| 287 | }
|
---|
| 288 |
|
---|
| 289 | area->pages = pages;
|
---|
| 290 |
|
---|
[1068f6a] | 291 | mutex_unlock(&area->lock);
|
---|
| 292 | mutex_unlock(&as->lock);
|
---|
[df0103f7] | 293 | interrupts_restore(ipl);
|
---|
| 294 |
|
---|
[7242a78e] | 295 | return 0;
|
---|
| 296 | }
|
---|
| 297 |
|
---|
| 298 | /** Destroy address space area.
|
---|
| 299 | *
|
---|
| 300 | * @param as Address space.
|
---|
| 301 | * @param address Address withing the area to be deleted.
|
---|
| 302 | *
|
---|
| 303 | * @return Zero on success or a value from @ref errno.h on failure.
|
---|
| 304 | */
|
---|
| 305 | int as_area_destroy(as_t *as, __address address)
|
---|
| 306 | {
|
---|
| 307 | as_area_t *area;
|
---|
| 308 | __address base;
|
---|
| 309 | ipl_t ipl;
|
---|
| 310 | int i;
|
---|
| 311 |
|
---|
| 312 | ipl = interrupts_disable();
|
---|
[1068f6a] | 313 | mutex_lock(&as->lock);
|
---|
[7242a78e] | 314 |
|
---|
| 315 | area = find_area_and_lock(as, address);
|
---|
| 316 | if (!area) {
|
---|
[1068f6a] | 317 | mutex_unlock(&as->lock);
|
---|
[7242a78e] | 318 | interrupts_restore(ipl);
|
---|
| 319 | return ENOENT;
|
---|
| 320 | }
|
---|
| 321 |
|
---|
| 322 | base = area->base;
|
---|
| 323 | for (i = 0; i < area->pages; i++) {
|
---|
| 324 | pte_t *pte;
|
---|
| 325 |
|
---|
| 326 | /*
|
---|
| 327 | * Releasing physical memory.
|
---|
| 328 | * Areas mapping memory-mapped devices are treated differently than
|
---|
| 329 | * areas backing frame_alloc()'ed memory.
|
---|
| 330 | */
|
---|
| 331 | page_table_lock(as, false);
|
---|
| 332 | pte = page_mapping_find(as, area->base + i*PAGE_SIZE);
|
---|
| 333 | if (pte && PTE_VALID(pte)) {
|
---|
| 334 | ASSERT(PTE_PRESENT(pte));
|
---|
| 335 | page_mapping_remove(as, area->base + i*PAGE_SIZE);
|
---|
| 336 | if (area->flags & AS_AREA_DEVICE) {
|
---|
| 337 | __address frame;
|
---|
| 338 | frame = PTE_GET_FRAME(pte);
|
---|
| 339 | frame_free(ADDR2PFN(frame));
|
---|
| 340 | }
|
---|
| 341 | page_table_unlock(as, false);
|
---|
| 342 | } else {
|
---|
| 343 | page_table_unlock(as, false);
|
---|
| 344 | }
|
---|
| 345 | }
|
---|
| 346 | /*
|
---|
| 347 | * Invalidate TLB's.
|
---|
| 348 | */
|
---|
| 349 | tlb_shootdown_start(TLB_INVL_PAGES, AS->asid, area->base, area->pages);
|
---|
| 350 | tlb_invalidate_pages(AS->asid, area->base, area->pages);
|
---|
| 351 | tlb_shootdown_finalize();
|
---|
| 352 |
|
---|
[8d4f2ae] | 353 | area->attributes |= AS_AREA_ATTR_PARTIAL;
|
---|
[1068f6a] | 354 | mutex_unlock(&area->lock);
|
---|
[7242a78e] | 355 |
|
---|
| 356 | /*
|
---|
| 357 | * Remove the empty area from address space.
|
---|
| 358 | */
|
---|
| 359 | btree_remove(&AS->as_area_btree, base, NULL);
|
---|
| 360 |
|
---|
[8d4f2ae] | 361 | free(area);
|
---|
| 362 |
|
---|
[1068f6a] | 363 | mutex_unlock(&AS->lock);
|
---|
[7242a78e] | 364 | interrupts_restore(ipl);
|
---|
| 365 | return 0;
|
---|
[df0103f7] | 366 | }
|
---|
| 367 |
|
---|
[7c23af9] | 368 | /** Steal address space area from another task.
|
---|
[df0103f7] | 369 | *
|
---|
[7c23af9] | 370 | * Address space area is stolen from another task
|
---|
| 371 | * Moreover, any existing mapping
|
---|
[df0103f7] | 372 | * is copied as well, providing thus a mechanism
|
---|
| 373 | * for sharing group of pages. The source address
|
---|
| 374 | * space area and any associated mapping is preserved.
|
---|
| 375 | *
|
---|
[7c23af9] | 376 | * @param src_task Pointer of source task
|
---|
[a9e8b39] | 377 | * @param src_base Base address of the source address space area.
|
---|
[7c23af9] | 378 | * @param acc_size Expected size of the source area
|
---|
| 379 | * @param dst_base Target base address
|
---|
[df0103f7] | 380 | *
|
---|
[7242a78e] | 381 | * @return Zero on success or ENOENT if there is no such task or
|
---|
[df0103f7] | 382 | * if there is no such address space area,
|
---|
| 383 | * EPERM if there was a problem in accepting the area or
|
---|
| 384 | * ENOMEM if there was a problem in allocating destination
|
---|
| 385 | * address space area.
|
---|
| 386 | */
|
---|
[7c23af9] | 387 | int as_area_steal(task_t *src_task, __address src_base, size_t acc_size,
|
---|
| 388 | __address dst_base)
|
---|
[df0103f7] | 389 | {
|
---|
| 390 | ipl_t ipl;
|
---|
| 391 | count_t i;
|
---|
[7c23af9] | 392 | as_t *src_as;
|
---|
[a9e8b39] | 393 | int src_flags;
|
---|
| 394 | size_t src_size;
|
---|
| 395 | as_area_t *src_area, *dst_area;
|
---|
[df0103f7] | 396 |
|
---|
[7c23af9] | 397 | ipl = interrupts_disable();
|
---|
| 398 | spinlock_lock(&src_task->lock);
|
---|
| 399 | src_as = src_task->as;
|
---|
[6fa476f7] | 400 |
|
---|
[1068f6a] | 401 | mutex_lock(&src_as->lock);
|
---|
[7c23af9] | 402 | src_area = find_area_and_lock(src_as, src_base);
|
---|
[a9e8b39] | 403 | if (!src_area) {
|
---|
[6fa476f7] | 404 | /*
|
---|
| 405 | * Could not find the source address space area.
|
---|
| 406 | */
|
---|
[7c23af9] | 407 | spinlock_unlock(&src_task->lock);
|
---|
[1068f6a] | 408 | mutex_unlock(&src_as->lock);
|
---|
[6fa476f7] | 409 | interrupts_restore(ipl);
|
---|
| 410 | return ENOENT;
|
---|
| 411 | }
|
---|
[a9e8b39] | 412 | src_size = src_area->pages * PAGE_SIZE;
|
---|
| 413 | src_flags = src_area->flags;
|
---|
[1068f6a] | 414 | mutex_unlock(&src_area->lock);
|
---|
| 415 | mutex_unlock(&src_as->lock);
|
---|
[df0103f7] | 416 |
|
---|
[7c23af9] | 417 |
|
---|
| 418 | if (src_size != acc_size) {
|
---|
| 419 | spinlock_unlock(&src_task->lock);
|
---|
[df0103f7] | 420 | interrupts_restore(ipl);
|
---|
| 421 | return EPERM;
|
---|
| 422 | }
|
---|
| 423 | /*
|
---|
[a9e8b39] | 424 | * Create copy of the source address space area.
|
---|
| 425 | * The destination area is created with AS_AREA_ATTR_PARTIAL
|
---|
| 426 | * attribute set which prevents race condition with
|
---|
| 427 | * preliminary as_page_fault() calls.
|
---|
[df0103f7] | 428 | */
|
---|
[7c23af9] | 429 | dst_area = as_area_create(AS, src_flags, src_size, dst_base, AS_AREA_ATTR_PARTIAL);
|
---|
[a9e8b39] | 430 | if (!dst_area) {
|
---|
[df0103f7] | 431 | /*
|
---|
| 432 | * Destination address space area could not be created.
|
---|
| 433 | */
|
---|
[7c23af9] | 434 | spinlock_unlock(&src_task->lock);
|
---|
[df0103f7] | 435 | interrupts_restore(ipl);
|
---|
| 436 | return ENOMEM;
|
---|
| 437 | }
|
---|
| 438 |
|
---|
[7c23af9] | 439 | spinlock_unlock(&src_task->lock);
|
---|
[df0103f7] | 440 |
|
---|
| 441 | /*
|
---|
| 442 | * Avoid deadlock by first locking the address space with lower address.
|
---|
| 443 | */
|
---|
[7c23af9] | 444 | if (AS < src_as) {
|
---|
[1068f6a] | 445 | mutex_lock(&AS->lock);
|
---|
| 446 | mutex_lock(&src_as->lock);
|
---|
[df0103f7] | 447 | } else {
|
---|
[1068f6a] | 448 | mutex_lock(&AS->lock);
|
---|
| 449 | mutex_lock(&src_as->lock);
|
---|
[df0103f7] | 450 | }
|
---|
| 451 |
|
---|
[a9e8b39] | 452 | for (i = 0; i < SIZE2FRAMES(src_size); i++) {
|
---|
[df0103f7] | 453 | pte_t *pte;
|
---|
| 454 | __address frame;
|
---|
| 455 |
|
---|
[7c23af9] | 456 | page_table_lock(src_as, false);
|
---|
| 457 | pte = page_mapping_find(src_as, src_base + i*PAGE_SIZE);
|
---|
[df0103f7] | 458 | if (pte && PTE_VALID(pte)) {
|
---|
| 459 | ASSERT(PTE_PRESENT(pte));
|
---|
| 460 | frame = PTE_GET_FRAME(pte);
|
---|
[a9e8b39] | 461 | if (!(src_flags & AS_AREA_DEVICE))
|
---|
[f3ac636] | 462 | frame_reference_add(ADDR2PFN(frame));
|
---|
[7c23af9] | 463 | page_table_unlock(src_as, false);
|
---|
[df0103f7] | 464 | } else {
|
---|
[7c23af9] | 465 | page_table_unlock(src_as, false);
|
---|
[df0103f7] | 466 | continue;
|
---|
| 467 | }
|
---|
| 468 |
|
---|
[7c23af9] | 469 | page_table_lock(AS, false);
|
---|
| 470 | page_mapping_insert(AS, dst_base + i*PAGE_SIZE, frame, area_flags_to_page_flags(src_flags));
|
---|
| 471 | page_table_unlock(AS, false);
|
---|
[df0103f7] | 472 | }
|
---|
[a9e8b39] | 473 |
|
---|
| 474 | /*
|
---|
| 475 | * Now the destination address space area has been
|
---|
| 476 | * fully initialized. Clear the AS_AREA_ATTR_PARTIAL
|
---|
| 477 | * attribute.
|
---|
| 478 | */
|
---|
[1068f6a] | 479 | mutex_lock(&dst_area->lock);
|
---|
[a9e8b39] | 480 | dst_area->attributes &= ~AS_AREA_ATTR_PARTIAL;
|
---|
[1068f6a] | 481 | mutex_unlock(&dst_area->lock);
|
---|
[df0103f7] | 482 |
|
---|
[1068f6a] | 483 | mutex_unlock(&AS->lock);
|
---|
| 484 | mutex_unlock(&src_as->lock);
|
---|
[df0103f7] | 485 | interrupts_restore(ipl);
|
---|
| 486 |
|
---|
| 487 | return 0;
|
---|
| 488 | }
|
---|
| 489 |
|
---|
[6a3c9a7] | 490 | /** Initialize mapping for one page of address space.
|
---|
[20d50a1] | 491 | *
|
---|
[6a3c9a7] | 492 | * This functions maps 'page' to 'frame' according
|
---|
| 493 | * to attributes of the address space area to
|
---|
| 494 | * wich 'page' belongs.
|
---|
[20d50a1] | 495 | *
|
---|
[23230aa] | 496 | * @param as Target address space.
|
---|
[6a3c9a7] | 497 | * @param page Virtual page within the area.
|
---|
| 498 | * @param frame Physical frame to which page will be mapped.
|
---|
[20d50a1] | 499 | */
|
---|
[6a3c9a7] | 500 | void as_set_mapping(as_t *as, __address page, __address frame)
|
---|
[20d50a1] | 501 | {
|
---|
[d3e7ff4] | 502 | as_area_t *area;
|
---|
[20d50a1] | 503 | ipl_t ipl;
|
---|
| 504 |
|
---|
| 505 | ipl = interrupts_disable();
|
---|
[2299914] | 506 | page_table_lock(as, true);
|
---|
[6a3c9a7] | 507 |
|
---|
[d3e7ff4] | 508 | area = find_area_and_lock(as, page);
|
---|
[6a3c9a7] | 509 | if (!area) {
|
---|
| 510 | panic("page not part of any as_area\n");
|
---|
| 511 | }
|
---|
| 512 |
|
---|
[ef67bab] | 513 | page_mapping_insert(as, page, frame, get_area_flags(area));
|
---|
[20d50a1] | 514 |
|
---|
[1068f6a] | 515 | mutex_unlock(&area->lock);
|
---|
[2299914] | 516 | page_table_unlock(as, true);
|
---|
[20d50a1] | 517 | interrupts_restore(ipl);
|
---|
| 518 | }
|
---|
| 519 |
|
---|
| 520 | /** Handle page fault within the current address space.
|
---|
| 521 | *
|
---|
| 522 | * This is the high-level page fault handler.
|
---|
| 523 | * Interrupts are assumed disabled.
|
---|
| 524 | *
|
---|
| 525 | * @param page Faulting page.
|
---|
[e3c762cd] | 526 | * @param istate Pointer to interrupted state.
|
---|
[20d50a1] | 527 | *
|
---|
[e3c762cd] | 528 | * @return 0 on page fault, 1 on success or 2 if the fault was caused by copy_to_uspace() or copy_from_uspace().
|
---|
[20d50a1] | 529 | */
|
---|
[e3c762cd] | 530 | int as_page_fault(__address page, istate_t *istate)
|
---|
[20d50a1] | 531 | {
|
---|
[2299914] | 532 | pte_t *pte;
|
---|
[d3e7ff4] | 533 | as_area_t *area;
|
---|
[20d50a1] | 534 | __address frame;
|
---|
| 535 |
|
---|
[1068f6a] | 536 | if (!THREAD)
|
---|
| 537 | return 0;
|
---|
| 538 |
|
---|
[20d50a1] | 539 | ASSERT(AS);
|
---|
[2299914] | 540 |
|
---|
[1068f6a] | 541 | mutex_lock(&AS->lock);
|
---|
[d3e7ff4] | 542 | area = find_area_and_lock(AS, page);
|
---|
[20d50a1] | 543 | if (!area) {
|
---|
| 544 | /*
|
---|
| 545 | * No area contained mapping for 'page'.
|
---|
| 546 | * Signal page fault to low-level handler.
|
---|
| 547 | */
|
---|
[1068f6a] | 548 | mutex_unlock(&AS->lock);
|
---|
[e3c762cd] | 549 | goto page_fault;
|
---|
[20d50a1] | 550 | }
|
---|
| 551 |
|
---|
[a9e8b39] | 552 | if (area->attributes & AS_AREA_ATTR_PARTIAL) {
|
---|
| 553 | /*
|
---|
| 554 | * The address space area is not fully initialized.
|
---|
| 555 | * Avoid possible race by returning error.
|
---|
| 556 | */
|
---|
[1068f6a] | 557 | mutex_unlock(&area->lock);
|
---|
| 558 | mutex_unlock(&AS->lock);
|
---|
[e3c762cd] | 559 | goto page_fault;
|
---|
[a9e8b39] | 560 | }
|
---|
| 561 |
|
---|
[1ace9ea] | 562 | ASSERT(!(area->flags & AS_AREA_DEVICE));
|
---|
| 563 |
|
---|
[2299914] | 564 | page_table_lock(AS, false);
|
---|
| 565 |
|
---|
| 566 | /*
|
---|
| 567 | * To avoid race condition between two page faults
|
---|
| 568 | * on the same address, we need to make sure
|
---|
| 569 | * the mapping has not been already inserted.
|
---|
| 570 | */
|
---|
| 571 | if ((pte = page_mapping_find(AS, page))) {
|
---|
| 572 | if (PTE_PRESENT(pte)) {
|
---|
| 573 | page_table_unlock(AS, false);
|
---|
[1068f6a] | 574 | mutex_unlock(&area->lock);
|
---|
| 575 | mutex_unlock(&AS->lock);
|
---|
[2299914] | 576 | return 1;
|
---|
| 577 | }
|
---|
| 578 | }
|
---|
| 579 |
|
---|
[20d50a1] | 580 | /*
|
---|
[6a3c9a7] | 581 | * In general, there can be several reasons that
|
---|
| 582 | * can have caused this fault.
|
---|
| 583 | *
|
---|
| 584 | * - non-existent mapping: the area is a scratch
|
---|
| 585 | * area (e.g. stack) and so far has not been
|
---|
| 586 | * allocated a frame for the faulting page
|
---|
| 587 | *
|
---|
| 588 | * - non-present mapping: another possibility,
|
---|
| 589 | * currently not implemented, would be frame
|
---|
| 590 | * reuse; when this becomes a possibility,
|
---|
| 591 | * do not forget to distinguish between
|
---|
| 592 | * the different causes
|
---|
[20d50a1] | 593 | */
|
---|
[085d973] | 594 | frame = PFN2ADDR(frame_alloc(ONE_FRAME, 0));
|
---|
[6a3c9a7] | 595 | memsetb(PA2KA(frame), FRAME_SIZE, 0);
|
---|
[20d50a1] | 596 |
|
---|
| 597 | /*
|
---|
| 598 | * Map 'page' to 'frame'.
|
---|
| 599 | * Note that TLB shootdown is not attempted as only new information is being
|
---|
| 600 | * inserted into page tables.
|
---|
| 601 | */
|
---|
[ef67bab] | 602 | page_mapping_insert(AS, page, frame, get_area_flags(area));
|
---|
[2299914] | 603 | page_table_unlock(AS, false);
|
---|
[20d50a1] | 604 |
|
---|
[1068f6a] | 605 | mutex_unlock(&area->lock);
|
---|
| 606 | mutex_unlock(&AS->lock);
|
---|
[e3c762cd] | 607 | return AS_PF_OK;
|
---|
| 608 |
|
---|
| 609 | page_fault:
|
---|
| 610 | if (!THREAD)
|
---|
| 611 | return AS_PF_FAULT;
|
---|
| 612 |
|
---|
| 613 | if (THREAD->in_copy_from_uspace) {
|
---|
| 614 | THREAD->in_copy_from_uspace = false;
|
---|
| 615 | istate_set_retaddr(istate, (__address) &memcpy_from_uspace_failover_address);
|
---|
| 616 | } else if (THREAD->in_copy_to_uspace) {
|
---|
| 617 | THREAD->in_copy_to_uspace = false;
|
---|
| 618 | istate_set_retaddr(istate, (__address) &memcpy_to_uspace_failover_address);
|
---|
| 619 | } else {
|
---|
| 620 | return AS_PF_FAULT;
|
---|
| 621 | }
|
---|
| 622 |
|
---|
| 623 | return AS_PF_DEFER;
|
---|
[20d50a1] | 624 | }
|
---|
| 625 |
|
---|
[7e4e532] | 626 | /** Switch address spaces.
|
---|
[1068f6a] | 627 | *
|
---|
| 628 | * Note that this function cannot sleep as it is essentially a part of
|
---|
| 629 | * the scheduling. Sleeping here would lead to deadlock on wakeup.
|
---|
[20d50a1] | 630 | *
|
---|
[7e4e532] | 631 | * @param old Old address space or NULL.
|
---|
| 632 | * @param new New address space.
|
---|
[20d50a1] | 633 | */
|
---|
[7e4e532] | 634 | void as_switch(as_t *old, as_t *new)
|
---|
[20d50a1] | 635 | {
|
---|
| 636 | ipl_t ipl;
|
---|
[7e4e532] | 637 | bool needs_asid = false;
|
---|
[4512d7e] | 638 |
|
---|
[20d50a1] | 639 | ipl = interrupts_disable();
|
---|
[7e4e532] | 640 | spinlock_lock(&as_lock);
|
---|
| 641 |
|
---|
| 642 | /*
|
---|
| 643 | * First, take care of the old address space.
|
---|
| 644 | */
|
---|
| 645 | if (old) {
|
---|
[1068f6a] | 646 | mutex_lock_active(&old->lock);
|
---|
[7e4e532] | 647 | ASSERT(old->refcount);
|
---|
| 648 | if((--old->refcount == 0) && (old != AS_KERNEL)) {
|
---|
| 649 | /*
|
---|
| 650 | * The old address space is no longer active on
|
---|
| 651 | * any processor. It can be appended to the
|
---|
| 652 | * list of inactive address spaces with assigned
|
---|
| 653 | * ASID.
|
---|
| 654 | */
|
---|
| 655 | ASSERT(old->asid != ASID_INVALID);
|
---|
| 656 | list_append(&old->inactive_as_with_asid_link, &inactive_as_with_asid_head);
|
---|
| 657 | }
|
---|
[1068f6a] | 658 | mutex_unlock(&old->lock);
|
---|
[7e4e532] | 659 | }
|
---|
| 660 |
|
---|
| 661 | /*
|
---|
| 662 | * Second, prepare the new address space.
|
---|
| 663 | */
|
---|
[1068f6a] | 664 | mutex_lock_active(&new->lock);
|
---|
[7e4e532] | 665 | if ((new->refcount++ == 0) && (new != AS_KERNEL)) {
|
---|
| 666 | if (new->asid != ASID_INVALID)
|
---|
| 667 | list_remove(&new->inactive_as_with_asid_link);
|
---|
| 668 | else
|
---|
| 669 | needs_asid = true; /* defer call to asid_get() until new->lock is released */
|
---|
| 670 | }
|
---|
| 671 | SET_PTL0_ADDRESS(new->page_table);
|
---|
[1068f6a] | 672 | mutex_unlock(&new->lock);
|
---|
[20d50a1] | 673 |
|
---|
[7e4e532] | 674 | if (needs_asid) {
|
---|
| 675 | /*
|
---|
| 676 | * Allocation of new ASID was deferred
|
---|
| 677 | * until now in order to avoid deadlock.
|
---|
| 678 | */
|
---|
| 679 | asid_t asid;
|
---|
| 680 |
|
---|
| 681 | asid = asid_get();
|
---|
[1068f6a] | 682 | mutex_lock_active(&new->lock);
|
---|
[7e4e532] | 683 | new->asid = asid;
|
---|
[1068f6a] | 684 | mutex_unlock(&new->lock);
|
---|
[7e4e532] | 685 | }
|
---|
| 686 | spinlock_unlock(&as_lock);
|
---|
| 687 | interrupts_restore(ipl);
|
---|
| 688 |
|
---|
[20d50a1] | 689 | /*
|
---|
| 690 | * Perform architecture-specific steps.
|
---|
[4512d7e] | 691 | * (e.g. write ASID to hardware register etc.)
|
---|
[20d50a1] | 692 | */
|
---|
[7e4e532] | 693 | as_install_arch(new);
|
---|
[20d50a1] | 694 |
|
---|
[7e4e532] | 695 | AS = new;
|
---|
[20d50a1] | 696 | }
|
---|
[6a3c9a7] | 697 |
|
---|
[df0103f7] | 698 | /** Convert address space area flags to page flags.
|
---|
[6a3c9a7] | 699 | *
|
---|
[df0103f7] | 700 | * @param aflags Flags of some address space area.
|
---|
[6a3c9a7] | 701 | *
|
---|
[df0103f7] | 702 | * @return Flags to be passed to page_mapping_insert().
|
---|
[6a3c9a7] | 703 | */
|
---|
[df0103f7] | 704 | int area_flags_to_page_flags(int aflags)
|
---|
[6a3c9a7] | 705 | {
|
---|
| 706 | int flags;
|
---|
| 707 |
|
---|
[9a8d91b] | 708 | flags = PAGE_USER | PAGE_PRESENT;
|
---|
[c23502d] | 709 |
|
---|
[df0103f7] | 710 | if (aflags & AS_AREA_READ)
|
---|
[c23502d] | 711 | flags |= PAGE_READ;
|
---|
| 712 |
|
---|
[df0103f7] | 713 | if (aflags & AS_AREA_WRITE)
|
---|
[c23502d] | 714 | flags |= PAGE_WRITE;
|
---|
| 715 |
|
---|
[df0103f7] | 716 | if (aflags & AS_AREA_EXEC)
|
---|
[c23502d] | 717 | flags |= PAGE_EXEC;
|
---|
[6a3c9a7] | 718 |
|
---|
[df0103f7] | 719 | if (!(aflags & AS_AREA_DEVICE))
|
---|
[9a8d91b] | 720 | flags |= PAGE_CACHEABLE;
|
---|
| 721 |
|
---|
[6a3c9a7] | 722 | return flags;
|
---|
| 723 | }
|
---|
[ef67bab] | 724 |
|
---|
[df0103f7] | 725 | /** Compute flags for virtual address translation subsytem.
|
---|
| 726 | *
|
---|
| 727 | * The address space area must be locked.
|
---|
| 728 | * Interrupts must be disabled.
|
---|
| 729 | *
|
---|
| 730 | * @param a Address space area.
|
---|
| 731 | *
|
---|
| 732 | * @return Flags to be used in page_mapping_insert().
|
---|
| 733 | */
|
---|
| 734 | int get_area_flags(as_area_t *a)
|
---|
| 735 | {
|
---|
| 736 | return area_flags_to_page_flags(a->flags);
|
---|
| 737 | }
|
---|
| 738 |
|
---|
[ef67bab] | 739 | /** Create page table.
|
---|
| 740 | *
|
---|
| 741 | * Depending on architecture, create either address space
|
---|
| 742 | * private or global page table.
|
---|
| 743 | *
|
---|
| 744 | * @param flags Flags saying whether the page table is for kernel address space.
|
---|
| 745 | *
|
---|
| 746 | * @return First entry of the page table.
|
---|
| 747 | */
|
---|
| 748 | pte_t *page_table_create(int flags)
|
---|
| 749 | {
|
---|
| 750 | ASSERT(as_operations);
|
---|
| 751 | ASSERT(as_operations->page_table_create);
|
---|
| 752 |
|
---|
| 753 | return as_operations->page_table_create(flags);
|
---|
| 754 | }
|
---|
[d3e7ff4] | 755 |
|
---|
[2299914] | 756 | /** Lock page table.
|
---|
| 757 | *
|
---|
| 758 | * This function should be called before any page_mapping_insert(),
|
---|
| 759 | * page_mapping_remove() and page_mapping_find().
|
---|
| 760 | *
|
---|
| 761 | * Locking order is such that address space areas must be locked
|
---|
| 762 | * prior to this call. Address space can be locked prior to this
|
---|
| 763 | * call in which case the lock argument is false.
|
---|
| 764 | *
|
---|
| 765 | * @param as Address space.
|
---|
[9179d0a] | 766 | * @param lock If false, do not attempt to lock as->lock.
|
---|
[2299914] | 767 | */
|
---|
| 768 | void page_table_lock(as_t *as, bool lock)
|
---|
| 769 | {
|
---|
| 770 | ASSERT(as_operations);
|
---|
| 771 | ASSERT(as_operations->page_table_lock);
|
---|
| 772 |
|
---|
| 773 | as_operations->page_table_lock(as, lock);
|
---|
| 774 | }
|
---|
| 775 |
|
---|
| 776 | /** Unlock page table.
|
---|
| 777 | *
|
---|
| 778 | * @param as Address space.
|
---|
[9179d0a] | 779 | * @param unlock If false, do not attempt to unlock as->lock.
|
---|
[2299914] | 780 | */
|
---|
| 781 | void page_table_unlock(as_t *as, bool unlock)
|
---|
| 782 | {
|
---|
| 783 | ASSERT(as_operations);
|
---|
| 784 | ASSERT(as_operations->page_table_unlock);
|
---|
| 785 |
|
---|
| 786 | as_operations->page_table_unlock(as, unlock);
|
---|
| 787 | }
|
---|
| 788 |
|
---|
[d3e7ff4] | 789 |
|
---|
| 790 | /** Find address space area and lock it.
|
---|
| 791 | *
|
---|
| 792 | * The address space must be locked and interrupts must be disabled.
|
---|
| 793 | *
|
---|
| 794 | * @param as Address space.
|
---|
| 795 | * @param va Virtual address.
|
---|
| 796 | *
|
---|
| 797 | * @return Locked address space area containing va on success or NULL on failure.
|
---|
| 798 | */
|
---|
| 799 | as_area_t *find_area_and_lock(as_t *as, __address va)
|
---|
| 800 | {
|
---|
| 801 | as_area_t *a;
|
---|
[252127e] | 802 | btree_node_t *leaf, *lnode;
|
---|
| 803 | int i;
|
---|
| 804 |
|
---|
| 805 | a = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf);
|
---|
| 806 | if (a) {
|
---|
| 807 | /* va is the base address of an address space area */
|
---|
[1068f6a] | 808 | mutex_lock(&a->lock);
|
---|
[252127e] | 809 | return a;
|
---|
| 810 | }
|
---|
[d3e7ff4] | 811 |
|
---|
[252127e] | 812 | /*
|
---|
[c47912f] | 813 | * Search the leaf node and the righmost record of its left neighbour
|
---|
[252127e] | 814 | * to find out whether this is a miss or va belongs to an address
|
---|
| 815 | * space area found there.
|
---|
| 816 | */
|
---|
| 817 |
|
---|
| 818 | /* First, search the leaf node itself. */
|
---|
| 819 | for (i = 0; i < leaf->keys; i++) {
|
---|
| 820 | a = (as_area_t *) leaf->value[i];
|
---|
[1068f6a] | 821 | mutex_lock(&a->lock);
|
---|
[252127e] | 822 | if ((a->base <= va) && (va < a->base + a->pages * PAGE_SIZE)) {
|
---|
| 823 | return a;
|
---|
| 824 | }
|
---|
[1068f6a] | 825 | mutex_unlock(&a->lock);
|
---|
[252127e] | 826 | }
|
---|
[d3e7ff4] | 827 |
|
---|
[252127e] | 828 | /*
|
---|
[c47912f] | 829 | * Second, locate the left neighbour and test its last record.
|
---|
[b26db0c] | 830 | * Because of its position in the B+tree, it must have base < va.
|
---|
[252127e] | 831 | */
|
---|
[c47912f] | 832 | if ((lnode = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf))) {
|
---|
[252127e] | 833 | a = (as_area_t *) lnode->value[lnode->keys - 1];
|
---|
[1068f6a] | 834 | mutex_lock(&a->lock);
|
---|
[252127e] | 835 | if (va < a->base + a->pages * PAGE_SIZE) {
|
---|
[37e7d2b9] | 836 | return a;
|
---|
[252127e] | 837 | }
|
---|
[1068f6a] | 838 | mutex_unlock(&a->lock);
|
---|
[d3e7ff4] | 839 | }
|
---|
| 840 |
|
---|
| 841 | return NULL;
|
---|
| 842 | }
|
---|
[37e7d2b9] | 843 |
|
---|
| 844 | /** Check area conflicts with other areas.
|
---|
| 845 | *
|
---|
| 846 | * The address space must be locked and interrupts must be disabled.
|
---|
| 847 | *
|
---|
| 848 | * @param as Address space.
|
---|
| 849 | * @param va Starting virtual address of the area being tested.
|
---|
| 850 | * @param size Size of the area being tested.
|
---|
| 851 | * @param avoid_area Do not touch this area.
|
---|
| 852 | *
|
---|
| 853 | * @return True if there is no conflict, false otherwise.
|
---|
| 854 | */
|
---|
| 855 | bool check_area_conflicts(as_t *as, __address va, size_t size, as_area_t *avoid_area)
|
---|
| 856 | {
|
---|
| 857 | as_area_t *a;
|
---|
[252127e] | 858 | btree_node_t *leaf, *node;
|
---|
| 859 | int i;
|
---|
[37e7d2b9] | 860 |
|
---|
[5a7d9d1] | 861 | /*
|
---|
| 862 | * We don't want any area to have conflicts with NULL page.
|
---|
| 863 | */
|
---|
| 864 | if (overlaps(va, size, NULL, PAGE_SIZE))
|
---|
| 865 | return false;
|
---|
| 866 |
|
---|
[252127e] | 867 | /*
|
---|
| 868 | * The leaf node is found in O(log n), where n is proportional to
|
---|
| 869 | * the number of address space areas belonging to as.
|
---|
| 870 | * The check for conflicts is then attempted on the rightmost
|
---|
[c47912f] | 871 | * record in the left neighbour, the leftmost record in the right
|
---|
| 872 | * neighbour and all records in the leaf node itself.
|
---|
[252127e] | 873 | */
|
---|
| 874 |
|
---|
| 875 | if ((a = (as_area_t *) btree_search(&as->as_area_btree, va, &leaf))) {
|
---|
| 876 | if (a != avoid_area)
|
---|
| 877 | return false;
|
---|
| 878 | }
|
---|
| 879 |
|
---|
| 880 | /* First, check the two border cases. */
|
---|
[c47912f] | 881 | if ((node = btree_leaf_node_left_neighbour(&as->as_area_btree, leaf))) {
|
---|
[252127e] | 882 | a = (as_area_t *) node->value[node->keys - 1];
|
---|
[1068f6a] | 883 | mutex_lock(&a->lock);
|
---|
[252127e] | 884 | if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
|
---|
[1068f6a] | 885 | mutex_unlock(&a->lock);
|
---|
[252127e] | 886 | return false;
|
---|
| 887 | }
|
---|
[1068f6a] | 888 | mutex_unlock(&a->lock);
|
---|
[252127e] | 889 | }
|
---|
[c47912f] | 890 | if ((node = btree_leaf_node_right_neighbour(&as->as_area_btree, leaf))) {
|
---|
[252127e] | 891 | a = (as_area_t *) node->value[0];
|
---|
[1068f6a] | 892 | mutex_lock(&a->lock);
|
---|
[252127e] | 893 | if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
|
---|
[1068f6a] | 894 | mutex_unlock(&a->lock);
|
---|
[252127e] | 895 | return false;
|
---|
| 896 | }
|
---|
[1068f6a] | 897 | mutex_unlock(&a->lock);
|
---|
[252127e] | 898 | }
|
---|
| 899 |
|
---|
| 900 | /* Second, check the leaf node. */
|
---|
| 901 | for (i = 0; i < leaf->keys; i++) {
|
---|
| 902 | a = (as_area_t *) leaf->value[i];
|
---|
[37e7d2b9] | 903 |
|
---|
| 904 | if (a == avoid_area)
|
---|
| 905 | continue;
|
---|
[252127e] | 906 |
|
---|
[1068f6a] | 907 | mutex_lock(&a->lock);
|
---|
[252127e] | 908 | if (overlaps(va, size, a->base, a->pages * PAGE_SIZE)) {
|
---|
[1068f6a] | 909 | mutex_unlock(&a->lock);
|
---|
[252127e] | 910 | return false;
|
---|
| 911 | }
|
---|
[1068f6a] | 912 | mutex_unlock(&a->lock);
|
---|
[5a7d9d1] | 913 | }
|
---|
[37e7d2b9] | 914 |
|
---|
[5a7d9d1] | 915 | /*
|
---|
| 916 | * So far, the area does not conflict with other areas.
|
---|
| 917 | * Check if it doesn't conflict with kernel address space.
|
---|
| 918 | */
|
---|
| 919 | if (!KERNEL_ADDRESS_SPACE_SHADOWED) {
|
---|
| 920 | return !overlaps(va, size,
|
---|
| 921 | KERNEL_ADDRESS_SPACE_START, KERNEL_ADDRESS_SPACE_END-KERNEL_ADDRESS_SPACE_START);
|
---|
[37e7d2b9] | 922 | }
|
---|
| 923 |
|
---|
| 924 | return true;
|
---|
| 925 | }
|
---|
[df0103f7] | 926 |
|
---|
[1068f6a] | 927 | /** Return size of the address space area with given base. */
|
---|
[7c23af9] | 928 | size_t as_get_size(__address base)
|
---|
| 929 | {
|
---|
| 930 | ipl_t ipl;
|
---|
| 931 | as_area_t *src_area;
|
---|
| 932 | size_t size;
|
---|
| 933 |
|
---|
| 934 | ipl = interrupts_disable();
|
---|
| 935 | src_area = find_area_and_lock(AS, base);
|
---|
| 936 | if (src_area){
|
---|
| 937 | size = src_area->pages * PAGE_SIZE;
|
---|
[1068f6a] | 938 | mutex_unlock(&src_area->lock);
|
---|
[7c23af9] | 939 | } else {
|
---|
| 940 | size = 0;
|
---|
| 941 | }
|
---|
| 942 | interrupts_restore(ipl);
|
---|
| 943 | return size;
|
---|
| 944 | }
|
---|
| 945 |
|
---|
[df0103f7] | 946 | /*
|
---|
| 947 | * Address space related syscalls.
|
---|
| 948 | */
|
---|
| 949 |
|
---|
| 950 | /** Wrapper for as_area_create(). */
|
---|
| 951 | __native sys_as_area_create(__address address, size_t size, int flags)
|
---|
| 952 | {
|
---|
[a9e8b39] | 953 | if (as_area_create(AS, flags, size, address, AS_AREA_ATTR_NONE))
|
---|
[df0103f7] | 954 | return (__native) address;
|
---|
| 955 | else
|
---|
| 956 | return (__native) -1;
|
---|
| 957 | }
|
---|
| 958 |
|
---|
| 959 | /** Wrapper for as_area_resize. */
|
---|
| 960 | __native sys_as_area_resize(__address address, size_t size, int flags)
|
---|
| 961 | {
|
---|
[7242a78e] | 962 | return (__native) as_area_resize(AS, address, size, 0);
|
---|
| 963 | }
|
---|
| 964 |
|
---|
| 965 | /** Wrapper for as_area_destroy. */
|
---|
| 966 | __native sys_as_area_destroy(__address address)
|
---|
| 967 | {
|
---|
| 968 | return (__native) as_area_destroy(AS, address);
|
---|
[df0103f7] | 969 | }
|
---|