Subversion Repositories HelenOS

Rev

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