Subversion Repositories HelenOS

Rev

Rev 1076 | Rev 1147 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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