source: mainline/generic/src/mm/as.c@ 1068f6a

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 1068f6a was 1068f6a, checked in by Jakub Jermar <jakub@…>, 19 years ago

Turn address space lock, address space area lock and
page_ht_lock into mutexes.

  • Property mode set to 100644
File size: 23.8 KB
RevLine 
[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]76as_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]79SPINLOCK_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 */
85LIST_INITIALIZE(inactive_as_with_asid_head);
86
[071a8ae6]87/** Kernel address space. */
88as_t *AS_KERNEL = NULL;
89
[df0103f7]90static int area_flags_to_page_flags(int aflags);
[6a3c9a7]91static int get_area_flags(as_area_t *a);
[d3e7ff4]92static as_area_t *find_area_and_lock(as_t *as, __address va);
[37e7d2b9]93static 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. */
96void 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]108as_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 */
129void 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]150as_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]200int 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 */
305int 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]387int 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]500void 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]530int 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
609page_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]634void 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]704int 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 */
734int 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 */
748pte_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 */
768void 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 */
781void 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 */
799as_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 */
855bool 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]928size_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}
Note: See TracBrowser for help on using the repository browser.