Subversion Repositories HelenOS

Rev

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