Subversion Repositories HelenOS-historic

Rev

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

Rev Author Line No. Line
1215 decky 1
/*
2
 * Copyright (C) 2006 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/tlb.h>
30
#include <arch/types.h>
31
#include <mm/tlb.h>
1269 decky 32
#include <mm/frame.h>
1215 decky 33
#include <mm/page.h>
34
#include <mm/as.h>
35
#include <arch.h>
36
#include <print.h>
37
#include <symtab.h>
38
 
39
 
1269 decky 40
static phte_t *phte;
41
 
42
 
1215 decky 43
/** Initialize Page Hash Table.
44
 *
45
 * Setup the Page Hash Table with no entries.
46
 *
47
 */
48
void tlb_arch_init(void)
49
{
1269 decky 50
    phte_t *physical_phte = (phte_t *) PFN2ADDR(frame_alloc(PHT_ORDER, FRAME_KA | FRAME_PANIC));
51
    phte =(phte_t *) PA2KA((__address) physical_phte);
52
 
53
    ASSERT((__address) physical_phte % (1 << PHT_BITS) == 0);
54
 
55
    memsetb((__address) phte, 1 << PHT_BITS, 0);
56
 
57
    asm volatile (
58
        "mtsdr1 %0\n"
59
        :
60
        : "r" ((__address) physical_phte)
61
    );
1215 decky 62
}
63
 
64
 
65
/** Try to find PTE for faulting address
66
 *
67
 * Try to find PTE for faulting address.
68
 * The AS->lock must be held on entry to this function.
69
 *
70
 * @param badvaddr Faulting virtual address.
71
 * @return         PTE on success, NULL otherwise.
72
 *
73
 */
74
static pte_t *find_mapping_and_check(__address badvaddr)
75
{
76
    /*
77
     * Check if the mapping exists in page tables.
78
     */
79
    pte_t *pte = page_mapping_find(AS, badvaddr);
80
    if ((pte) && (pte->p)) {
81
        /*
82
         * Mapping found in page tables.
83
         * Immediately succeed.
84
         */
85
        return pte;
86
    } else {
87
        /*
88
         * Mapping not found in page tables.
89
         * Resort to higher-level page fault handler.
90
         */
91
        page_table_unlock(AS, true);
92
        if (as_page_fault(badvaddr)) {
93
            /*
94
             * The higher-level page fault handler succeeded,
95
             * The mapping ought to be in place.
96
             */
97
            page_table_lock(AS, true);
98
            pte = page_mapping_find(AS, badvaddr);
99
            ASSERT((pte) && (pte->p));
100
            return pte;
101
        } else {
102
            page_table_lock(AS, true);
103
            printf("Page fault.\n");
104
            return NULL;
105
        }
106
 
107
    }
108
}
109
 
110
 
111
static void pht_refill_fail(__address badvaddr, istate_t *istate)
112
{
113
    char *symbol = "";
114
    char *sym2 = "";
115
 
116
    char *s = get_symtab_entry(istate->pc);
117
    if (s)
118
        symbol = s;
119
    s = get_symtab_entry(istate->lr);
120
    if (s)
121
        sym2 = s;
1269 decky 122
    panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);
1215 decky 123
}
124
 
125
 
1269 decky 126
/** Process Instruction/Data Storage Interrupt
1215 decky 127
 *
1269 decky 128
 * @param data   True if Data Storage Interrupt.
1215 decky 129
 * @param istate Interrupted register context.
130
 *
131
 */
1269 decky 132
void pht_refill(bool data, istate_t *istate)
1215 decky 133
{
134
    asid_t asid;
135
    __address badvaddr;
136
    pte_t *pte;
1269 decky 137
    __u32 page;
138
    __u32 api;
139
    __u32 vsid;
140
    __u32 hash;
141
    __u32 i;
1215 decky 142
 
1269 decky 143
    if (data) {
144
        asm volatile (
145
            "mfdar %0\n"
146
            : "=r" (badvaddr)
147
        );
148
    } else
149
        badvaddr = istate->pc;
150
 
1215 decky 151
    spinlock_lock(&AS->lock);
152
    asid = AS->asid;
153
    spinlock_unlock(&AS->lock);
154
 
155
    page_table_lock(AS, true);
156
 
157
    pte = find_mapping_and_check(badvaddr);
158
    if (!pte)
159
        goto fail;
160
 
1269 decky 161
    /* Record access to PTE */
1215 decky 162
    pte->a = 1;
163
 
1270 decky 164
    page = (badvaddr >> 12) & 0xffff;
1269 decky 165
    api = (badvaddr >> 22) & 0x3f;
166
    asm volatile (
167
        "mfsrin %0, %1\n"
168
        : "=r" (vsid)
1270 decky 169
        : "r" (badvaddr)
1269 decky 170
    );
171
 
172
    /* Primary hash (xor) */
173
    hash = ((vsid ^ page) & 0x3ff) << 3;
174
 
175
    /* Find invalid PTE in PTEG */
176
    for (i = 0; i < 8; i++) {
177
        if (!phte[hash + i].v)
178
            break;
179
    }
180
 
181
    // TODO: Check access/change bits, secondary hash
182
 
183
    if (i == 8)
184
        i = page % 8;
185
 
186
    phte[hash + i].v = 1;
187
    phte[hash + i].vsid = vsid;
188
    phte[hash + i].h = 0;
189
    phte[hash + i].api = api;
190
    phte[hash + i].rpn = pte->pfn;
191
    phte[hash + i].r = 0;
192
    phte[hash + i].c = 0;
193
    phte[hash + i].pp = 2; // FIXME
194
 
1215 decky 195
    page_table_unlock(AS, true);
196
    return;
197
 
198
fail:
199
    page_table_unlock(AS, true);
200
    pht_refill_fail(badvaddr, istate);
201
}
202
 
203
 
204
/** Print contents of Page Hash Table. */
205
void tlb_print(void)
206
{
207
}