WebSVN – HelenOS – Diff – /kernel/trunk/arch/ppc32/src/mm/tlb.c


/*
 * Copyright (C) 2006 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#include <arch/mm/tlb.h>
#include <arch/types.h>
#include <mm/tlb.h>
#include <mm/frame.h>
#include <mm/page.h>
#include <mm/as.h>
#include <arch.h>
#include <print.h>
#include <symtab.h>
 
 
static phte_t *phte;
 
 
/** Initialize Page Hash Table.
 *
 * Setup the Page Hash Table with no entries.
 *
 */
void tlb_arch_init(void)
{
    phte_t *physical_phte = (phte_t *) PFN2ADDR(frame_alloc(PHT_ORDER, FRAME_KA | FRAME_PANIC));
    phte =(phte_t *) PA2KA((__address) physical_phte);
   
    ASSERT((__address) physical_phte % (1 << PHT_BITS) == 0);
   
    memsetb((__address) phte, 1 << PHT_BITS, 0);
   
    asm volatile (
        "mtsdr1 %0\n"
        :
        : "r" ((__address) physical_phte)
    );
}
 
 
/** Try to find PTE for faulting address
 *
 * Try to find PTE for faulting address.
 * The AS->lock must be held on entry to this function.
 *
 * @param badvaddr Faulting virtual address.
 * @param istate Pointer to interrupted state.
 * @param pfrc Pointer to variable where as_page_fault() return code will be stored.
 * @return         PTE on success, NULL otherwise.
 *
 */
static pte_t *find_mapping_and_check(__address badvaddr, istate_t *istate, int *pfcr)
{
    /*
     * Check if the mapping exists in page tables.
     */
    pte_t *pte = page_mapping_find(AS, badvaddr);
    if ((pte) && (pte->p)) {
        /*
         * Mapping found in page tables.
         * Immediately succeed.
         */
        return pte;
    } else {
        int rc;
   
        /*
         * Mapping not found in page tables.
         * Resort to higher-level page fault handler.
         */
        page_table_unlock(AS, true);
        switch (rc = as_page_fault(badvaddr, istate)) {
        case AS_PF_OK:
            /*
             * The higher-level page fault handler succeeded,
             * The mapping ought to be in place.
             */
            page_table_lock(AS, true);
            pte = page_mapping_find(AS, badvaddr);
            ASSERT((pte) && (pte->p));
            return pte;
            break;
        case AS_PF_DEFER:
            page_table_lock(AS, true);
            *pfcr = rc;
            return NULL;
            break;
        case AS_PF_FAULT:
            page_table_lock(AS, true);
            printf("Page fault.\n");
            *pfcr = rc;
            return NULL;
            break;
        default:
            panic("unexpected rc (%d)\n", rc);
            break;
        }  
    }
}
 
 
static void pht_refill_fail(__address badvaddr, istate_t *istate)
{
    char *symbol = "";
    char *sym2 = "";
 
    char *s = get_symtab_entry(istate->pc);
    if (s)
        symbol = s;
    s = get_symtab_entry(istate->lr);
    if (s)
        sym2 = s;
    panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);
}
 
 
/** Process Instruction/Data Storage Interrupt
 *
 * @param data   True if Data Storage Interrupt.
 * @param istate Interrupted register context.
 *
 */
void pht_refill(bool data, istate_t *istate)
{
    asid_t asid;
    __address badvaddr;
    pte_t *pte;
    __u32 page;
    __u32 api;
    __u32 vsid;
    __u32 hash;
    __u32 i;
    int pfcr;
   
    if (data) {
        asm volatile (
            "mfdar %0\n"
            : "=r" (badvaddr)
        );
    } else
        badvaddr = istate->pc;
       
    spinlock_lock(&AS->lock);
    asid = AS->asid;
    spinlock_unlock(&AS->lock);
   
    page_table_lock(AS, true);
   
    pte = find_mapping_and_check(badvaddr, istate, &pfcr);
    if (!pte) {
        switch (pfcr) {
        case AS_PF_FAULT:
            goto fail;
            break;
        case AS_PF_DEFER:
            /*
             * The page fault came during copy_from_uspace()
             * or copy_to_uspace().
             */
            page_table_unlock(AS, true);
            return;
        default:
            panic("Unexpected pfrc (%d)\n", pfcr);
            break;
        }
    }
 
    /* Record access to PTE */
    pte->a = 1;
   
    page = (badvaddr >> 12) & 0xffff;
    api = (badvaddr >> 22) & 0x3f;
    asm volatile (
        "mfsrin %0, %1\n"
        : "=r" (vsid)
        : "r" (badvaddr)
    );
   
    /* Primary hash (xor) */
    hash = ((vsid ^ page) & 0x3ff) << 3;
   
    /* Find invalid PTE in PTEG */
    for (i = 0; i < 8; i++) {
        if (!phte[hash + i].v)
            break;
    }
   
    // TODO: Check access/change bits, secondary hash
   
    if (i == 8)
        i = page % 8;
   
    phte[hash + i].v = 1;
    phte[hash + i].vsid = vsid;
    phte[hash + i].h = 0;
    phte[hash + i].api = api;
    phte[hash + i].rpn = pte->pfn;
    phte[hash + i].r = 0;
    phte[hash + i].c = 0;
    phte[hash + i].pp = 2; // FIXME
   
    page_table_unlock(AS, true);
    return;
   
fail:
    page_table_unlock(AS, true);
    pht_refill_fail(badvaddr, istate);
}
 
 
/** Print contents of Page Hash Table. */
void tlb_print(void)
{
}
 

Rev 1270	Rev 1288
1	/*	1	/*
2	* Copyright (C) 2006 Martin Decky	2	* Copyright (C) 2006 Martin Decky
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	#include <arch/mm/tlb.h>	29	#include <arch/mm/tlb.h>
30	#include <arch/types.h>	30	#include <arch/types.h>
31	#include <mm/tlb.h>	31	#include <mm/tlb.h>
32	#include <mm/frame.h>	32	#include <mm/frame.h>
33	#include <mm/page.h>	33	#include <mm/page.h>
34	#include <mm/as.h>	34	#include <mm/as.h>
35	#include <arch.h>	35	#include <arch.h>
36	#include <print.h>	36	#include <print.h>
37	#include <symtab.h>	37	#include <symtab.h>
38		38
39		39
40	static phte_t *phte;	40	static phte_t *phte;
41		41
42		42
43	/** Initialize Page Hash Table.	43	/** Initialize Page Hash Table.
44	*	44	*
45	* Setup the Page Hash Table with no entries.	45	* Setup the Page Hash Table with no entries.
46	*	46	*
47	*/	47	*/
48	void tlb_arch_init(void)	48	void tlb_arch_init(void)
49	{	49	{
50	phte_t physical_phte = (phte_t ) PFN2ADDR(frame_alloc(PHT_ORDER, FRAME_KA \| FRAME_PANIC));	50	phte_t physical_phte = (phte_t ) PFN2ADDR(frame_alloc(PHT_ORDER, FRAME_KA \| FRAME_PANIC));
51	phte =(phte_t *) PA2KA((__address) physical_phte);	51	phte =(phte_t *) PA2KA((__address) physical_phte);
52		52
53	ASSERT((__address) physical_phte % (1 << PHT_BITS) == 0);	53	ASSERT((__address) physical_phte % (1 << PHT_BITS) == 0);
54		54
55	memsetb((__address) phte, 1 << PHT_BITS, 0);	55	memsetb((__address) phte, 1 << PHT_BITS, 0);
56		56
57	asm volatile (	57	asm volatile (
58	"mtsdr1 %0\n"	58	"mtsdr1 %0\n"
59	:	59	:
60	: "r" ((__address) physical_phte)	60	: "r" ((__address) physical_phte)
61	);	61	);
62	}	62	}
63		63
64		64
65	/** Try to find PTE for faulting address	65	/** Try to find PTE for faulting address
66	*	66	*
67	* Try to find PTE for faulting address.	67	* Try to find PTE for faulting address.
68	* The AS->lock must be held on entry to this function.	68	* The AS->lock must be held on entry to this function.
69	*	69	*
70	* @param badvaddr Faulting virtual address.	70	* @param badvaddr Faulting virtual address.
-		71	* @param istate Pointer to interrupted state.
-		72	* @param pfrc Pointer to variable where as_page_fault() return code will be stored.
71	* @return PTE on success, NULL otherwise.	73	* @return PTE on success, NULL otherwise.
72	*	74	*
73	*/	75	*/
74	static pte_t *find_mapping_and_check(__address badvaddr)	76	static pte_t find_mapping_and_check(__address badvaddr, istate_t istate, int *pfcr)
75	{	77	{
76	/*	78	/*
77	* Check if the mapping exists in page tables.	79	* Check if the mapping exists in page tables.
78	*/	80	*/
79	pte_t *pte = page_mapping_find(AS, badvaddr);	81	pte_t *pte = page_mapping_find(AS, badvaddr);
80	if ((pte) && (pte->p)) {	82	if ((pte) && (pte->p)) {
81	/*	83	/*
82	* Mapping found in page tables.	84	* Mapping found in page tables.
83	* Immediately succeed.	85	* Immediately succeed.
84	*/	86	*/
85	return pte;	87	return pte;
86	} else {	88	} else {
-		89	int rc;
-		90
87	/*	91	/*
88	* Mapping not found in page tables.	92	* Mapping not found in page tables.
89	* Resort to higher-level page fault handler.	93	* Resort to higher-level page fault handler.
90	*/	94	*/
91	page_table_unlock(AS, true);	95	page_table_unlock(AS, true);
92	if (as_page_fault(badvaddr)) {	96	switch (rc = as_page_fault(badvaddr, istate)) {
-		97	case AS_PF_OK:
93	/*	98	/*
94	* The higher-level page fault handler succeeded,	99	* The higher-level page fault handler succeeded,
95	* The mapping ought to be in place.	100	* The mapping ought to be in place.
96	*/	101	*/
97	page_table_lock(AS, true);	102	page_table_lock(AS, true);
98	pte = page_mapping_find(AS, badvaddr);	103	pte = page_mapping_find(AS, badvaddr);
99	ASSERT((pte) && (pte->p));	104	ASSERT((pte) && (pte->p));
100	return pte;	105	return pte;
-		106	break;
-		107	case AS_PF_DEFER:
-		108	page_table_lock(AS, true);
-		109	*pfcr = rc;
-		110	return NULL;
101	} else {	111	break;
-		112	case AS_PF_FAULT:
102	page_table_lock(AS, true);	113	page_table_lock(AS, true);
103	printf("Page fault.\n");	114	printf("Page fault.\n");
-		115	*pfcr = rc;
104	return NULL;	116	return NULL;
-		117	break;
-		118	default:
-		119	panic("unexpected rc (%d)\n", rc);
105	}	120	break;
106		121	}
107	}	122	}
108	}	123	}
109		124
110		125
111	static void pht_refill_fail(__address badvaddr, istate_t *istate)	126	static void pht_refill_fail(__address badvaddr, istate_t *istate)
112	{	127	{
113	char *symbol = "";	128	char *symbol = "";
114	char *sym2 = "";	129	char *sym2 = "";
115		130
116	char *s = get_symtab_entry(istate->pc);	131	char *s = get_symtab_entry(istate->pc);
117	if (s)	132	if (s)
118	symbol = s;	133	symbol = s;
119	s = get_symtab_entry(istate->lr);	134	s = get_symtab_entry(istate->lr);
120	if (s)	135	if (s)
121	sym2 = s;	136	sym2 = s;
122	panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);	137	panic("%p: PHT Refill Exception at %p (%s<-%s)\n", badvaddr, istate->pc, symbol, sym2);
123	}	138	}
124		139
125		140
126	/** Process Instruction/Data Storage Interrupt	141	/** Process Instruction/Data Storage Interrupt
127	*	142	*
128	* @param data True if Data Storage Interrupt.	143	* @param data True if Data Storage Interrupt.
129	* @param istate Interrupted register context.	144	* @param istate Interrupted register context.
130	*	145	*
131	*/	146	*/
132	void pht_refill(bool data, istate_t *istate)	147	void pht_refill(bool data, istate_t *istate)
133	{	148	{
134	asid_t asid;	149	asid_t asid;
135	__address badvaddr;	150	__address badvaddr;
136	pte_t *pte;	151	pte_t *pte;
137	__u32 page;	152	__u32 page;
138	__u32 api;	153	__u32 api;
139	__u32 vsid;	154	__u32 vsid;
140	__u32 hash;	155	__u32 hash;
141	__u32 i;	156	__u32 i;
-		157	int pfcr;
142		158
143	if (data) {	159	if (data) {
144	asm volatile (	160	asm volatile (
145	"mfdar %0\n"	161	"mfdar %0\n"
146	: "=r" (badvaddr)	162	: "=r" (badvaddr)
147	);	163	);
148	} else	164	} else
149	badvaddr = istate->pc;	165	badvaddr = istate->pc;
150		166
151	spinlock_lock(&AS->lock);	167	spinlock_lock(&AS->lock);
152	asid = AS->asid;	168	asid = AS->asid;
153	spinlock_unlock(&AS->lock);	169	spinlock_unlock(&AS->lock);
154		170
155	page_table_lock(AS, true);	171	page_table_lock(AS, true);
156		172
157	pte = find_mapping_and_check(badvaddr);	173	pte = find_mapping_and_check(badvaddr, istate, &pfcr);
158	if (!pte)	174	if (!pte) {
-		175	switch (pfcr) {
-		176	case AS_PF_FAULT:
159	goto fail;	177	goto fail;
-		178	break;
-		179	case AS_PF_DEFER:
-		180	/*
-		181	* The page fault came during copy_from_uspace()
-		182	* or copy_to_uspace().
-		183	*/
-		184	page_table_unlock(AS, true);
-		185	return;
-		186	default:
-		187	panic("Unexpected pfrc (%d)\n", pfcr);
-		188	break;
-		189	}
-		190	}
160		191
161	/* Record access to PTE */	192	/* Record access to PTE */
162	pte->a = 1;	193	pte->a = 1;
163		194
164	page = (badvaddr >> 12) & 0xffff;	195	page = (badvaddr >> 12) & 0xffff;
165	api = (badvaddr >> 22) & 0x3f;	196	api = (badvaddr >> 22) & 0x3f;
166	asm volatile (	197	asm volatile (
167	"mfsrin %0, %1\n"	198	"mfsrin %0, %1\n"
168	: "=r" (vsid)	199	: "=r" (vsid)
169	: "r" (badvaddr)	200	: "r" (badvaddr)
170	);	201	);
171		202
172	/* Primary hash (xor) */	203	/* Primary hash (xor) */
173	hash = ((vsid ^ page) & 0x3ff) << 3;	204	hash = ((vsid ^ page) & 0x3ff) << 3;
174		205
175	/* Find invalid PTE in PTEG */	206	/* Find invalid PTE in PTEG */
176	for (i = 0; i < 8; i++) {	207	for (i = 0; i < 8; i++) {
177	if (!phte[hash + i].v)	208	if (!phte[hash + i].v)
178	break;	209	break;
179	}	210	}
180		211
181	// TODO: Check access/change bits, secondary hash	212	// TODO: Check access/change bits, secondary hash
182		213
183	if (i == 8)	214	if (i == 8)
184	i = page % 8;	215	i = page % 8;
185		216
186	phte[hash + i].v = 1;	217	phte[hash + i].v = 1;
187	phte[hash + i].vsid = vsid;	218	phte[hash + i].vsid = vsid;
188	phte[hash + i].h = 0;	219	phte[hash + i].h = 0;
189	phte[hash + i].api = api;	220	phte[hash + i].api = api;
190	phte[hash + i].rpn = pte->pfn;	221	phte[hash + i].rpn = pte->pfn;
191	phte[hash + i].r = 0;	222	phte[hash + i].r = 0;
192	phte[hash + i].c = 0;	223	phte[hash + i].c = 0;
193	phte[hash + i].pp = 2; // FIXME	224	phte[hash + i].pp = 2; // FIXME
194		225
195	page_table_unlock(AS, true);	226	page_table_unlock(AS, true);
196	return;	227	return;
197		228
198	fail:	229	fail:
199	page_table_unlock(AS, true);	230	page_table_unlock(AS, true);
200	pht_refill_fail(badvaddr, istate);	231	pht_refill_fail(badvaddr, istate);
201	}	232	}
202		233
203		234
204	/** Print contents of Page Hash Table. */	235	/** Print contents of Page Hash Table. */
205	void tlb_print(void)	236	void tlb_print(void)
206	{	237	{
207	}	238	}
208		239

Subversion Repositories HelenOS

(root)/kernel/trunk/arch/ppc32/src/mm/tlb.c – Rev 1270 → 1288