Subversion Repositories HelenOS

Rev

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

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