Subversion Repositories HelenOS

Rev

Rev 822 | Rev 840 | 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);
703 jermar 72
 
756 jermar 73
/** Initialize address space subsystem. */
74
void as_init(void)
75
{
76
    as_arch_init();
789 palkovsky 77
    AS_KERNEL = as_create(FLAG_AS_KERNEL);
756 jermar 78
        if (!AS_KERNEL)
79
                panic("can't create kernel address space\n");
80
}
81
 
757 jermar 82
/** Create address space.
83
 *
84
 * @param flags Flags that influence way in wich the address space is created.
85
 */
756 jermar 86
as_t *as_create(int flags)
703 jermar 87
{
88
    as_t *as;
89
 
822 palkovsky 90
    as = (as_t *) malloc(sizeof(as_t), 0);
823 jermar 91
    link_initialize(&as->inactive_as_with_asid_link);
822 palkovsky 92
    spinlock_initialize(&as->lock, "as_lock");
93
    list_initialize(&as->as_area_head);
94
 
95
    if (flags & FLAG_AS_KERNEL)
96
        as->asid = ASID_KERNEL;
97
    else
98
        as->asid = ASID_INVALID;
99
 
823 jermar 100
    as->refcount = 0;
822 palkovsky 101
    as->page_table = page_table_create(flags);
703 jermar 102
 
103
    return as;
104
}
105
 
106
/** Create address space area of common attributes.
107
 *
108
 * The created address space area is added to the target address space.
109
 *
110
 * @param as Target address space.
111
 * @param type Type of area.
112
 * @param size Size of area in multiples of PAGE_SIZE.
113
 * @param base Base address of area.
114
 *
115
 * @return Address space area on success or NULL on failure.
116
 */
117
as_area_t *as_area_create(as_t *as, as_area_type_t type, size_t size, __address base)
118
{
119
    ipl_t ipl;
120
    as_area_t *a;
121
 
122
    if (base % PAGE_SIZE)
123
        panic("addr not aligned to a page boundary");
124
 
125
    ipl = interrupts_disable();
126
    spinlock_lock(&as->lock);
127
 
128
    /*
129
     * TODO: test as_area which is to be created doesn't overlap with an existing one.
130
     */
131
 
822 palkovsky 132
    a = (as_area_t *) malloc(sizeof(as_area_t), 0);
703 jermar 133
 
822 palkovsky 134
    spinlock_initialize(&a->lock, "as_area_lock");
135
 
136
    link_initialize(&a->link);         
137
    a->type = type;
138
    a->size = size;
139
    a->base = base;
140
 
141
    list_append(&a->link, &as->as_area_head);
142
 
703 jermar 143
    spinlock_unlock(&as->lock);
144
    interrupts_restore(ipl);
704 jermar 145
 
703 jermar 146
    return a;
147
}
148
 
754 jermar 149
/** Initialize mapping for one page of address space.
703 jermar 150
 *
754 jermar 151
 * This functions maps 'page' to 'frame' according
152
 * to attributes of the address space area to
153
 * wich 'page' belongs.
703 jermar 154
 *
754 jermar 155
 * @param a Target address space.
156
 * @param page Virtual page within the area.
157
 * @param frame Physical frame to which page will be mapped.
703 jermar 158
 */
754 jermar 159
void as_set_mapping(as_t *as, __address page, __address frame)
703 jermar 160
{
754 jermar 161
    as_area_t *a, *area = NULL;
162
    link_t *cur;
703 jermar 163
    ipl_t ipl;
164
 
165
    ipl = interrupts_disable();
754 jermar 166
    spinlock_lock(&as->lock);
703 jermar 167
 
754 jermar 168
    /*
169
     * First, try locate an area.
170
     */
171
    for (cur = as->as_area_head.next; cur != &as->as_area_head; cur = cur->next) {
172
        a = list_get_instance(cur, as_area_t, link);
173
        spinlock_lock(&a->lock);
174
 
175
        if ((page >= a->base) && (page < a->base + a->size * PAGE_SIZE)) {
176
            area = a;
177
            break;
178
        }
179
 
180
        spinlock_unlock(&a->lock);
181
    }
718 decky 182
 
754 jermar 183
    if (!area) {
184
        panic("page not part of any as_area\n");
185
    }
186
 
187
    /*
188
     * Note: area->lock is held.
189
     */
190
 
756 jermar 191
    page_mapping_insert(as, page, frame, get_area_flags(area));
754 jermar 192
 
193
    spinlock_unlock(&area->lock);
194
    spinlock_unlock(&as->lock);
703 jermar 195
    interrupts_restore(ipl);
196
}
197
 
198
/** Handle page fault within the current address space.
199
 *
200
 * This is the high-level page fault handler.
201
 * Interrupts are assumed disabled.
202
 *
203
 * @param page Faulting page.
204
 *
704 jermar 205
 * @return 0 on page fault, 1 on success.
703 jermar 206
 */
207
int as_page_fault(__address page)
208
{
209
    link_t *cur;
210
    as_area_t *a, *area = NULL;
211
    __address frame;
212
 
213
    ASSERT(AS);
214
    spinlock_lock(&AS->lock);
215
 
216
    /*
217
     * Search this areas of this address space for presence of 'page'.
218
     */
219
    for (cur = AS->as_area_head.next; cur != &AS->as_area_head; cur = cur->next) {
220
        a = list_get_instance(cur, as_area_t, link);
221
        spinlock_lock(&a->lock);
222
 
223
        if ((page >= a->base) && (page < a->base + a->size * PAGE_SIZE)) {
224
 
225
            /*
226
             * We found the area containing 'page'.
227
             * TODO: access checking
228
             */
229
            area = a;
230
            break;
231
        }
232
 
233
        spinlock_unlock(&a->lock);
234
    }
235
 
236
    if (!area) {
237
        /*
238
         * No area contained mapping for 'page'.
239
         * Signal page fault to low-level handler.
240
         */
241
        spinlock_unlock(&AS->lock);
242
        return 0;
243
    }
244
 
245
    /*
246
     * Note: area->lock is held.
247
     */
248
 
249
    /*
754 jermar 250
     * In general, there can be several reasons that
251
     * can have caused this fault.
252
     *
253
     * - non-existent mapping: the area is a scratch
254
     *   area (e.g. stack) and so far has not been
255
     *   allocated a frame for the faulting page
256
     *
257
     * - non-present mapping: another possibility,
258
     *   currently not implemented, would be frame
259
     *   reuse; when this becomes a possibility,
260
     *   do not forget to distinguish between
261
     *   the different causes
703 jermar 262
     */
814 palkovsky 263
    frame = PFN2ADDR(frame_alloc(ONE_FRAME, 0));
754 jermar 264
    memsetb(PA2KA(frame), FRAME_SIZE, 0);
703 jermar 265
 
266
    /*
267
     * Map 'page' to 'frame'.
268
     * Note that TLB shootdown is not attempted as only new information is being
269
     * inserted into page tables.
270
     */
756 jermar 271
    page_mapping_insert(AS, page, frame, get_area_flags(area));
703 jermar 272
 
273
    spinlock_unlock(&area->lock);
274
    spinlock_unlock(&AS->lock);
275
 
276
    return 1;
277
}
278
 
823 jermar 279
/** Switch address spaces.
703 jermar 280
 *
823 jermar 281
 * @param old Old address space or NULL.
282
 * @param new New address space.
703 jermar 283
 */
823 jermar 284
void as_switch(as_t *old, as_t *new)
703 jermar 285
{
286
    ipl_t ipl;
823 jermar 287
    bool needs_asid = false;
703 jermar 288
 
289
    ipl = interrupts_disable();
823 jermar 290
    spinlock_lock(&as_lock);
703 jermar 291
 
292
    /*
823 jermar 293
     * First, take care of the old address space.
294
     */
295
    if (old) {
296
        spinlock_lock(&old->lock);
297
        ASSERT(old->refcount);
298
        if((--old->refcount == 0) && (old != AS_KERNEL)) {
299
            /*
300
             * The old address space is no longer active on
301
             * any processor. It can be appended to the
302
             * list of inactive address spaces with assigned
303
             * ASID.
304
             */
305
             ASSERT(old->asid != ASID_INVALID);
306
             list_append(&old->inactive_as_with_asid_link, &inactive_as_with_asid_head);
307
        }
308
        spinlock_unlock(&old->lock);
309
    }
310
 
311
    /*
312
     * Second, prepare the new address space.
313
     */
314
    spinlock_lock(&new->lock);
315
    if ((new->refcount++ == 0) && (new != AS_KERNEL)) {
316
        if (new->asid != ASID_INVALID)
317
            list_remove(&new->inactive_as_with_asid_link);
318
        else
319
            needs_asid = true;  /* defer call to asid_get() until new->lock is released */
320
    }
321
    SET_PTL0_ADDRESS(new->page_table);
322
    spinlock_unlock(&new->lock);
323
 
324
    if (needs_asid) {
325
        /*
326
         * Allocation of new ASID was deferred
327
         * until now in order to avoid deadlock.
328
         */
329
        asid_t asid;
330
 
331
        asid = asid_get();
332
        spinlock_lock(&new->lock);
333
        new->asid = asid;
334
        spinlock_unlock(&new->lock);
335
    }
336
    spinlock_unlock(&as_lock);
337
    interrupts_restore(ipl);
338
 
339
    /*
703 jermar 340
     * Perform architecture-specific steps.
727 jermar 341
     * (e.g. write ASID to hardware register etc.)
703 jermar 342
     */
823 jermar 343
    as_install_arch(new);
703 jermar 344
 
823 jermar 345
    AS = new;
703 jermar 346
}
754 jermar 347
 
348
/** Compute flags for virtual address translation subsytem.
349
 *
350
 * The address space area must be locked.
351
 * Interrupts must be disabled.
352
 *
353
 * @param a Address space area.
354
 *
355
 * @return Flags to be used in page_mapping_insert().
356
 */
357
int get_area_flags(as_area_t *a)
358
{
359
    int flags;
360
 
361
    switch (a->type) {
362
        case AS_AREA_TEXT:
363
            flags = PAGE_EXEC | PAGE_READ | PAGE_USER | PAGE_PRESENT | PAGE_CACHEABLE;
364
            break;
365
        case AS_AREA_DATA:
366
        case AS_AREA_STACK:
367
            flags = PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_PRESENT | PAGE_CACHEABLE;
368
            break;
369
        default:
370
            panic("unexpected as_area_type_t %d", a->type);
371
    }
372
 
373
    return flags;
374
}
756 jermar 375
 
376
/** Create page table.
377
 *
378
 * Depending on architecture, create either address space
379
 * private or global page table.
380
 *
381
 * @param flags Flags saying whether the page table is for kernel address space.
382
 *
383
 * @return First entry of the page table.
384
 */
385
pte_t *page_table_create(int flags)
386
{
387
        ASSERT(as_operations);
388
        ASSERT(as_operations->page_table_create);
389
 
390
        return as_operations->page_table_create(flags);
391
}