WebSVN – HelenOS – Diff – /kernel/trunk/genarch/src/mm/page_ht.c


/*
 * Copyright (C) 2006 Jakub Jermar
 * 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 <genarch/mm/page_ht.h>
#include <mm/page.h>
#include <mm/frame.h>
#include <mm/heap.h>
#include <mm/as.h>
#include <arch/mm/asid.h>
#include <arch/types.h>
#include <typedefs.h>
#include <arch/asm.h>
#include <synch/spinlock.h>
#include <arch.h>
#include <debug.h>
#include <memstr.h>
 
/**
 * This lock protects the page hash table.
 */
SPINLOCK_INITIALIZE(page_ht_lock);
 
/**
 * Page hash table pointer.
 * The page hash table may be accessed only when page_ht_lock is held.
 */
pte_t *page_ht = NULL;
 
static void ht_mapping_insert(as_t *as, __address page, __address frame, int flags);
static pte_t *ht_mapping_find(as_t *as, __address page);
 
page_operations_t page_ht_operations = {
    .mapping_insert = ht_mapping_insert,
    .mapping_find = ht_mapping_find
};
 
/** Map page to frame using page hash table.
 *
 * Map virtual address 'page' to physical address 'frame'
 * using 'flags'.
 *
 * The address space must be locked and interruptsmust be disabled.
 *
 * @param as Address space to which page belongs.
 * @param page Virtual address of the page to be mapped.
 * @param frame Physical address of memory frame to which the mapping is done.
 * @param flags Flags to be used for mapping.
 */
void ht_mapping_insert(as_t *as, __address page, __address frame, int flags)
{
    pte_t *t, *u;
    ipl_t ipl;
   
    ipl = interrupts_disable();
    spinlock_lock(&page_ht_lock);
 
    t = HT_HASH(page, as->asid);
    if (!HT_SLOT_EMPTY(t)) {
   
        /*
         * The slot is occupied.
         * Walk through the collision chain and append the mapping to its end.
         */
         
        do {
            u = t;
            if (HT_COMPARE(page, as->asid, t)) {
                /*
                 * Nothing to do,
                 * the record is already there.
                 */
                spinlock_unlock(&page_ht_lock);
                interrupts_restore(ipl);
                return;
            }
        } while ((t = HT_GET_NEXT(t)));
   
        t = (pte_t *) malloc(sizeof(pte_t));    /* FIXME: use slab allocator for this */
        if (!t)
            panic("could not allocate memory\n");
 
        HT_SET_NEXT(u, t);
    }
   
    HT_SET_RECORD(t, page, as->asid, frame, flags);
    HT_SET_NEXT(t, NULL);
   
    spinlock_unlock(&page_ht_lock);
    interrupts_restore(ipl);
}
 
/** Find mapping for virtual page in page hash table.
 *
 * Find mapping for virtual page.
 *
 * The address space must be locked and interrupts must be disabled.
 *
 * @param as Address space to wich page belongs.
 * @param page Virtual page.
 *
 * @return NULL if there is no such mapping; requested mapping otherwise.
 */
pte_t *ht_mapping_find(as_t *as, __address page)
{
    pte_t *t;
   
    spinlock_lock(&page_ht_lock);
    t = HT_HASH(page, as->asid);
    if (!HT_SLOT_EMPTY(t)) {
        while (!HT_COMPARE(page, as->asid, t) && HT_GET_NEXT(t))
            t = HT_GET_NEXT(t);
        t = HT_COMPARE(page, as->asid, t) ? t : NULL;
    } else {
        t = NULL;
    }
    spinlock_unlock(&page_ht_lock);
    return t;
}
 
/** Invalidate page hash table.
 *
 * Interrupts must be disabled.
 */
void ht_invalidate_all(void)
{
    pte_t *t, *u;
    int i;
   
    spinlock_lock(&page_ht_lock);
    for (i = 0; i < HT_ENTRIES; i++) {
        if (!HT_SLOT_EMPTY(&page_ht[i])) {
            t = HT_GET_NEXT(&page_ht[i]);
            while (t) {
                u = t;
                t = HT_GET_NEXT(t);
                free(u);        /* FIXME: use slab allocator for this */
            }
            HT_INVALIDATE_SLOT(&page_ht[i]);
        }
    }
    spinlock_unlock(&page_ht_lock);
}
 

Rev 756	Rev 757
1	/*	1	/*
2	* Copyright (C) 2006 Jakub Jermar	2	* Copyright (C) 2006 Jakub Jermar
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 <genarch/mm/page_ht.h>	29	#include <genarch/mm/page_ht.h>
30	#include <mm/page.h>	30	#include <mm/page.h>
31	#include <mm/frame.h>	31	#include <mm/frame.h>
32	#include <mm/heap.h>	32	#include <mm/heap.h>
33	#include <mm/as.h>	33	#include <mm/as.h>
34	#include <arch/mm/asid.h>	34	#include <arch/mm/asid.h>
35	#include <arch/types.h>	35	#include <arch/types.h>
36	#include <typedefs.h>	36	#include <typedefs.h>
37	#include <arch/asm.h>	37	#include <arch/asm.h>
38	#include <synch/spinlock.h>	38	#include <synch/spinlock.h>
39	#include <arch.h>	39	#include <arch.h>
40	#include <debug.h>	40	#include <debug.h>
41	#include <memstr.h>	41	#include <memstr.h>
42		42
43	/**	43	/**
44	* This lock protects the page hash table.	44	* This lock protects the page hash table.
45	*/	45	*/
46	SPINLOCK_INITIALIZE(page_ht_lock);	46	SPINLOCK_INITIALIZE(page_ht_lock);
47		47
48	/**	48	/**
49	* Page hash table pointer.	49	* Page hash table pointer.
50	* The page hash table may be accessed only when page_ht_lock is held.	50	* The page hash table may be accessed only when page_ht_lock is held.
51	*/	51	*/
52	pte_t *page_ht = NULL;	52	pte_t *page_ht = NULL;
53		53
54	static void ht_mapping_insert(as_t *as, __address page, __address frame, int flags);	54	static void ht_mapping_insert(as_t *as, __address page, __address frame, int flags);
55	static pte_t ht_mapping_find(as_t as, __address page);	55	static pte_t ht_mapping_find(as_t as, __address page);
56		56
57	page_operations_t page_ht_operations = {	57	page_operations_t page_ht_operations = {
58	.mapping_insert = ht_mapping_insert,	58	.mapping_insert = ht_mapping_insert,
59	.mapping_find = ht_mapping_find,	59	.mapping_find = ht_mapping_find
60	};	60	};
61		61
62	/** Map page to frame using page hash table.	62	/** Map page to frame using page hash table.
63	*	63	*
64	* Map virtual address 'page' to physical address 'frame'	64	* Map virtual address 'page' to physical address 'frame'
65	* using 'flags'.	65	* using 'flags'.
66	*	66	*
67	* The address space must be locked and interruptsmust be disabled.	67	* The address space must be locked and interruptsmust be disabled.
68	*	68	*
69	* @param as Address space to which page belongs.	69	* @param as Address space to which page belongs.
70	* @param page Virtual address of the page to be mapped.	70	* @param page Virtual address of the page to be mapped.
71	* @param frame Physical address of memory frame to which the mapping is done.	71	* @param frame Physical address of memory frame to which the mapping is done.
72	* @param flags Flags to be used for mapping.	72	* @param flags Flags to be used for mapping.
73	*/	73	*/
74	void ht_mapping_insert(as_t *as, __address page, __address frame, int flags)	74	void ht_mapping_insert(as_t *as, __address page, __address frame, int flags)
75	{	75	{
76	pte_t t, u;	76	pte_t t, u;
77	ipl_t ipl;	77	ipl_t ipl;
78		78
79	ipl = interrupts_disable();	79	ipl = interrupts_disable();
80	spinlock_lock(&page_ht_lock);	80	spinlock_lock(&page_ht_lock);
81		81
82	t = HT_HASH(page, as->asid);	82	t = HT_HASH(page, as->asid);
83	if (!HT_SLOT_EMPTY(t)) {	83	if (!HT_SLOT_EMPTY(t)) {
84		84
85	/*	85	/*
86	* The slot is occupied.	86	* The slot is occupied.
87	* Walk through the collision chain and append the mapping to its end.	87	* Walk through the collision chain and append the mapping to its end.
88	*/	88	*/
89		89
90	do {	90	do {
91	u = t;	91	u = t;
92	if (HT_COMPARE(page, as->asid, t)) {	92	if (HT_COMPARE(page, as->asid, t)) {
93	/*	93	/*
94	* Nothing to do,	94	* Nothing to do,
95	* the record is already there.	95	* the record is already there.
96	*/	96	*/
97	spinlock_unlock(&page_ht_lock);	97	spinlock_unlock(&page_ht_lock);
98	interrupts_restore(ipl);	98	interrupts_restore(ipl);
99	return;	99	return;
100	}	100	}
101	} while ((t = HT_GET_NEXT(t)));	101	} while ((t = HT_GET_NEXT(t)));
102		102
103	t = (pte_t ) malloc(sizeof(pte_t)); / FIXME: use slab allocator for this */	103	t = (pte_t ) malloc(sizeof(pte_t)); / FIXME: use slab allocator for this */
104	if (!t)	104	if (!t)
105	panic("could not allocate memory\n");	105	panic("could not allocate memory\n");
106		106
107	HT_SET_NEXT(u, t);	107	HT_SET_NEXT(u, t);
108	}	108	}
109		109
110	HT_SET_RECORD(t, page, as->asid, frame, flags);	110	HT_SET_RECORD(t, page, as->asid, frame, flags);
111	HT_SET_NEXT(t, NULL);	111	HT_SET_NEXT(t, NULL);
112		112
113	spinlock_unlock(&page_ht_lock);	113	spinlock_unlock(&page_ht_lock);
114	interrupts_restore(ipl);	114	interrupts_restore(ipl);
115	}	115	}
116		116
117	/** Find mapping for virtual page in page hash table.	117	/** Find mapping for virtual page in page hash table.
118	*	118	*
119	* Find mapping for virtual page.	119	* Find mapping for virtual page.
120	*	120	*
121	* The address space must be locked and interrupts must be disabled.	121	* The address space must be locked and interrupts must be disabled.
122	*	122	*
123	* @param as Address space to wich page belongs.	123	* @param as Address space to wich page belongs.
124	* @param page Virtual page.	124	* @param page Virtual page.
125	*	125	*
126	* @return NULL if there is no such mapping; requested mapping otherwise.	126	* @return NULL if there is no such mapping; requested mapping otherwise.
127	*/	127	*/
128	pte_t ht_mapping_find(as_t as, __address page)	128	pte_t ht_mapping_find(as_t as, __address page)
129	{	129	{
130	pte_t *t;	130	pte_t *t;
131		131
132	spinlock_lock(&page_ht_lock);	132	spinlock_lock(&page_ht_lock);
133	t = HT_HASH(page, as->asid);	133	t = HT_HASH(page, as->asid);
134	if (!HT_SLOT_EMPTY(t)) {	134	if (!HT_SLOT_EMPTY(t)) {
135	while (!HT_COMPARE(page, as->asid, t) && HT_GET_NEXT(t))	135	while (!HT_COMPARE(page, as->asid, t) && HT_GET_NEXT(t))
136	t = HT_GET_NEXT(t);	136	t = HT_GET_NEXT(t);
137	t = HT_COMPARE(page, as->asid, t) ? t : NULL;	137	t = HT_COMPARE(page, as->asid, t) ? t : NULL;
138	} else {	138	} else {
139	t = NULL;	139	t = NULL;
140	}	140	}
141	spinlock_unlock(&page_ht_lock);	141	spinlock_unlock(&page_ht_lock);
142	return t;	142	return t;
143	}	143	}
144		144
145	/** Invalidate page hash table.	145	/** Invalidate page hash table.
146	*	146	*
147	* Interrupts must be disabled.	147	* Interrupts must be disabled.
148	*/	148	*/
149	void ht_invalidate_all(void)	149	void ht_invalidate_all(void)
150	{	150	{
151	pte_t t, u;	151	pte_t t, u;
152	int i;	152	int i;
153		153
154	spinlock_lock(&page_ht_lock);	154	spinlock_lock(&page_ht_lock);
155	for (i = 0; i < HT_ENTRIES; i++) {	155	for (i = 0; i < HT_ENTRIES; i++) {
156	if (!HT_SLOT_EMPTY(&page_ht[i])) {	156	if (!HT_SLOT_EMPTY(&page_ht[i])) {
157	t = HT_GET_NEXT(&page_ht[i]);	157	t = HT_GET_NEXT(&page_ht[i]);
158	while (t) {	158	while (t) {
159	u = t;	159	u = t;
160	t = HT_GET_NEXT(t);	160	t = HT_GET_NEXT(t);
161	free(u); /* FIXME: use slab allocator for this */	161	free(u); /* FIXME: use slab allocator for this */
162	}	162	}
163	HT_INVALIDATE_SLOT(&page_ht[i]);	163	HT_INVALIDATE_SLOT(&page_ht[i]);
164	}	164	}
165	}	165	}
166	spinlock_unlock(&page_ht_lock);	166	spinlock_unlock(&page_ht_lock);
167	}	167	}
168		168

Subversion Repositories HelenOS

(root)/kernel/trunk/genarch/src/mm/page_ht.c – Rev 756 → 757