Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
162 decky 1
/*
2
 * Copyright (C) 2005 Martin Decky
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
#include <arch/mm/page.h>
684 jermar 30
#include <genarch/mm/page_pt.h>
162 decky 31
#include <arch/mm/frame.h>
1374 decky 32
#include <arch/asm.h>
162 decky 33
#include <mm/frame.h>
34
#include <mm/page.h>
1374 decky 35
#include <mm/as.h>
36
#include <arch.h>
684 jermar 37
#include <arch/types.h>
1374 decky 38
#include <arch/exception.h>
1383 decky 39
#include <align.h>
1374 decky 40
#include <config.h>
41
#include <print.h>
42
#include <symtab.h>
162 decky 43
 
1374 decky 44
static phte_t *phte;
45
 
46
 
47
/** Try to find PTE for faulting address
48
 *
49
 * Try to find PTE for faulting address.
1383 decky 50
 * The as->lock must be held on entry to this function
51
 * if lock is true.
1374 decky 52
 *
1383 decky 53
 * @param as       Address space.
54
 * @param lock     Lock/unlock the address space.
1374 decky 55
 * @param badvaddr Faulting virtual address.
1378 decky 56
 * @param istate   Pointer to interrupted state.
57
 * @param pfrc     Pointer to variable where as_page_fault() return code will be stored.
1374 decky 58
 * @return         PTE on success, NULL otherwise.
59
 *
60
 */
1383 decky 61
static pte_t *find_mapping_and_check(as_t *as, bool lock, __address badvaddr, istate_t *istate, int *pfcr)
1374 decky 62
{
63
    /*
64
     * Check if the mapping exists in page tables.
65
     */
1383 decky 66
    pte_t *pte = page_mapping_find(as, badvaddr);
1374 decky 67
    if ((pte) && (pte->p)) {
68
        /*
69
         * Mapping found in page tables.
70
         * Immediately succeed.
71
         */
72
        return pte;
73
    } else {
74
        int rc;
75
 
76
        /*
77
         * Mapping not found in page tables.
78
         * Resort to higher-level page fault handler.
79
         */
1383 decky 80
        page_table_unlock(as, lock);
1374 decky 81
        switch (rc = as_page_fault(badvaddr, istate)) {
82
            case AS_PF_OK:
83
                /*
84
                 * The higher-level page fault handler succeeded,
85
                 * The mapping ought to be in place.
86
                 */
1383 decky 87
                page_table_lock(as, lock);
88
                pte = page_mapping_find(as, badvaddr);
1374 decky 89
                ASSERT((pte) && (pte->p));
90
                return pte;
91
            case AS_PF_DEFER:
1383 decky 92
                page_table_lock(as, lock);
1374 decky 93
                *pfcr = rc;
94
                return NULL;
95
            case AS_PF_FAULT:
1383 decky 96
                page_table_lock(as, lock);
1374 decky 97
                printf("Page fault.\n");
98
                *pfcr = rc;
99
                return NULL;
100
            default:
101
                panic("unexpected rc (%d)\n", rc);
102
        }  
103
    }
104
}
105
 
106
 
107
static void pht_refill_fail(__address badvaddr, istate_t *istate)
108
{
109
    char *symbol = "";
110
    char *sym2 = "";
111
 
112
    char *s = get_symtab_entry(istate->pc);
113
    if (s)
114
        symbol = s;
115
    s = get_symtab_entry(istate->lr);
116
    if (s)
117
        sym2 = s;
118
    panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);
119
}
120
 
1378 decky 121
 
1374 decky 122
static void pht_insert(const __address vaddr, const pfn_t pfn)
123
{
124
    __u32 page = (vaddr >> 12) & 0xffff;
125
    __u32 api = (vaddr >> 22) & 0x3f;
126
    __u32 vsid;
127
 
128
    asm volatile (
129
        "mfsrin %0, %1\n"
130
        : "=r" (vsid)
131
        : "r" (vaddr)
132
    );
133
 
134
    /* Primary hash (xor) */
135
    __u32 hash = ((vsid ^ page) & 0x3ff) << 3;
136
 
137
    __u32 i;
1378 decky 138
    bool found = false;
1374 decky 139
    /* Find unused PTE in PTEG */
140
    for (i = 0; i < 8; i++) {
1378 decky 141
        if (!phte[hash + i].v) {
142
            found = true;
1374 decky 143
            break;
1378 decky 144
        }
1374 decky 145
    }
146
 
1378 decky 147
    if (!found) {
148
        /* Secondary hash (not) */
149
        hash = ~hash;
150
 
151
        /* Find unused PTE in PTEG */
152
        for (i = 0; i < 8; i++) {
153
            if (!phte[hash + i].v) {
154
                found = true;
155
                break;
156
            }
157
        }
158
 
159
        if (!found) {
160
            // TODO: A/C precedence groups
161
            i = page % 8;
162
        }
163
    }
1374 decky 164
 
165
    phte[hash + i].v = 1;
166
    phte[hash + i].vsid = vsid;
167
    phte[hash + i].h = 0;
168
    phte[hash + i].api = api;
169
    phte[hash + i].rpn = pfn;
170
    phte[hash + i].r = 0;
171
    phte[hash + i].c = 0;
172
    phte[hash + i].pp = 2; // FIXME
173
}
174
 
175
 
176
/** Process Instruction/Data Storage Interrupt
177
 *
178
 * @param data   True if Data Storage Interrupt.
179
 * @param istate Interrupted register context.
180
 *
181
 */
182
void pht_refill(bool data, istate_t *istate)
183
{
184
    asid_t asid;
185
    __address badvaddr;
186
    pte_t *pte;
187
    int pfcr;
1383 decky 188
    as_t *as;
189
    bool lock;
1374 decky 190
 
1383 decky 191
    if (AS == NULL) {
192
        as = AS_KERNEL;
193
        lock = false;
194
    } else {
195
        as = AS;
196
        lock = true;
197
    }
198
 
1374 decky 199
    if (data) {
200
        asm volatile (
201
            "mfdar %0\n"
202
            : "=r" (badvaddr)
203
        );
204
    } else
205
        badvaddr = istate->pc;
206
 
1383 decky 207
    spinlock_lock(&as->lock);
208
    asid = as->asid;
209
    spinlock_unlock(&as->lock);
1374 decky 210
 
1383 decky 211
    page_table_lock(as, lock);
1374 decky 212
 
1383 decky 213
    pte = find_mapping_and_check(as, lock, badvaddr, istate, &pfcr);
1374 decky 214
    if (!pte) {
215
        switch (pfcr) {
1378 decky 216
            case AS_PF_FAULT:
217
                goto fail;
218
                break;
219
            case AS_PF_DEFER:
220
                /*
221
                 * The page fault came during copy_from_uspace()
222
                 * or copy_to_uspace().
223
                 */
1383 decky 224
                page_table_unlock(as, lock);
1378 decky 225
                return;
226
            default:
227
                panic("Unexpected pfrc (%d)\n", pfcr);
1374 decky 228
        }
229
    }
230
 
231
    pte->a = 1; /* Record access to PTE */
232
    pht_insert(badvaddr, pte->pfn);
233
 
1383 decky 234
    page_table_unlock(as, lock);
1374 decky 235
    return;
236
 
237
fail:
1383 decky 238
    page_table_unlock(as, lock);
1374 decky 239
    pht_refill_fail(badvaddr, istate);
240
}
241
 
242
 
243
void pht_init(void)
244
{
245
    memsetb((__address) phte, 1 << PHT_BITS, 0);
246
}
247
 
248
 
162 decky 249
void page_arch_init(void)
250
{
1374 decky 251
    if (config.cpu_active == 1) {
252
        page_mapping_operations = &pt_mapping_operations;
253
 
254
        /* Allocate page hash table */
255
        phte_t *physical_phte = (phte_t *) PFN2ADDR(frame_alloc(PHT_ORDER, FRAME_KA | FRAME_PANIC));
256
        phte = (phte_t *) PA2KA((__address) physical_phte);
257
 
258
        ASSERT((__address) physical_phte % (1 << PHT_BITS) == 0);
259
        pht_init();
260
 
261
        asm volatile (
262
            "mtsdr1 %0\n"
263
            :
264
            : "r" ((__address) physical_phte)
265
        );
266
    }
162 decky 267
}
1383 decky 268
 
269
 
270
__address hw_map(__address physaddr, size_t size)
271
{
272
    if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
273
        panic("Unable to map physical memory %p (%d bytes)", physaddr, size)
274
 
275
    __address virtaddr = PA2KA(last_frame);
276
    pfn_t i;
277
    for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
278
        page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE);
279
 
280
    last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
281
 
282
    return virtaddr;
283
}