Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 686 → Rev 687

/kernel/trunk/test/mm/mapping1/test.c
29,6 → 29,7
#include <test.h>
#include <mm/page.h>
#include <mm/frame.h>
#include <mm/asid.h>
#include <arch/mm/page.h>
#include <arch/types.h>
#include <debug.h>
55,9 → 56,9
*((__u32 *) frame1) = VALUE1;
printf("Mapping virtual address %P to physical address %P.\n", PAGE0, KA2PA(frame0));
page_mapping_insert(PAGE0, KA2PA(frame0), PAGE_PRESENT | PAGE_WRITE, 0);
page_mapping_insert(PAGE0, ASID_KERNEL, KA2PA(frame0), PAGE_PRESENT | PAGE_WRITE, 0);
printf("Mapping virtual address %P to physical address %P.\n", PAGE1, KA2PA(frame1));
page_mapping_insert(PAGE1, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE, 0);
page_mapping_insert(PAGE1, ASID_KERNEL, KA2PA(frame1), PAGE_PRESENT | PAGE_WRITE, 0);
printf("Value at virtual address %P is %L.\n", PAGE0, v0 = *((__u32 *) PAGE0));
printf("Value at virtual address %P is %L.\n", PAGE1, v1 = *((__u32 *) PAGE1));
/kernel/trunk/genarch/src/mm/page_pt.c
30,13 → 30,14
#include <mm/page.h>
#include <mm/frame.h>
#include <arch/mm/page.h>
#include <arch/mm/asid.h>
#include <arch/types.h>
#include <typedefs.h>
#include <arch/asm.h>
#include <memstr.h>
 
static void pt_mapping_insert(__address page, __address frame, int flags, __address root);
static pte_t *pt_mapping_find(__address page, __address root);
static void pt_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root);
static pte_t *pt_mapping_find(__address page, asid_t asid, __address root);
 
page_operations_t page_pt_operations = {
.mapping_insert = pt_mapping_insert,
49,11 → 50,12
* using 'flags'.
*
* @param page Virtual address of the page to be mapped.
* @param asid Ignored.
* @param frame Physical address of memory frame to which the mapping is done.
* @param flags Flags to be used for mapping.
* @param root Explicit PTL0 address.
*/
void pt_mapping_insert(__address page, __address frame, int flags, __address root)
void pt_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root)
{
pte_t *ptl0, *ptl1, *ptl2, *ptl3;
__address newpt;
96,11 → 98,12
* Find mapping for virtual page.
*
* @param page Virtual page.
* @param asid Ignored.
* @param root PTL0 address if non-zero.
*
* @return NULL if there is no such mapping; entry from PTL3 describing the mapping otherwise.
*/
pte_t *pt_mapping_find(__address page, __address root)
pte_t *pt_mapping_find(__address page, asid_t asid, __address root)
{
pte_t *ptl0, *ptl1, *ptl2, *ptl3;
 
/kernel/trunk/genarch/src/mm/page_ht.c
29,12 → 29,13
#include <genarch/mm/page_ht.h>
#include <mm/page.h>
#include <mm/frame.h>
#include <arch/mm/asid.h>
#include <arch/types.h>
#include <typedefs.h>
#include <arch/asm.h>
 
static void ht_mapping_insert(__address page, __address frame, int flags, __address root);
static pte_t *ht_mapping_find(__address page, __address root);
static void ht_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root);
static pte_t *ht_mapping_find(__address page, asid_t asid, __address root);
 
page_operations_t page_ht_operations = {
.mapping_insert = ht_mapping_insert,
47,11 → 48,12
* using 'flags'.
*
* @param page Virtual address of the page to be mapped.
* @param asid Address space to which page belongs.
* @param frame Physical address of memory frame to which the mapping is done.
* @param flags Flags to be used for mapping.
* @param root Explicit PTL0 address.
*/
void ht_mapping_insert(__address page, __address frame, int flags, __address root)
void ht_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root)
{
}
 
60,11 → 62,12
* Find mapping for virtual page.
*
* @param page Virtual page.
* @param asid Address space to wich page belongs.
* @param root PTL0 address if non-zero.
*
* @return NULL if there is no such mapping; entry from PTL3 describing the mapping otherwise.
*/
pte_t *ht_mapping_find(__address page, __address root)
pte_t *ht_mapping_find(__address page, asid_t asid, __address root)
{
return NULL;
}
/kernel/trunk/genarch/src/acpi/acpi.c
29,7 → 29,7
#include <genarch/acpi/acpi.h>
#include <genarch/acpi/madt.h>
#include <arch/bios/bios.h>
 
#include <mm/asid.h>
#include <mm/page.h>
#include <print.h>
 
79,7 → 79,7
 
static void map_sdt(struct acpi_sdt_header *sdt)
{
page_mapping_insert((__address) sdt, (__address) sdt, PAGE_NOT_CACHEABLE, 0);
page_mapping_insert((__address) sdt, ASID_KERNEL, (__address) sdt, PAGE_NOT_CACHEABLE, 0);
map_structure((__address) sdt, sdt->length);
}
 
/kernel/trunk/generic/include/mm/page.h
29,6 → 29,7
#ifndef __PAGE_H__
#define __PAGE_H__
 
#include <arch/mm/asid.h>
#include <arch/types.h>
#include <typedefs.h>
 
56,8 → 57,8
#define PAGE_EXEC (1<<PAGE_EXEC_SHIFT)
 
struct page_operations {
void (* mapping_insert)(__address page, __address frame, int flags, __address root);
pte_t *(* mapping_find)(__address page, __address root);
void (* mapping_insert)(__address page, asid_t asid, __address frame, int flags, __address root);
pte_t *(* mapping_find)(__address page, asid_t asid, __address root);
};
typedef struct page_operations page_operations_t;
 
64,8 → 65,8
extern page_operations_t *page_operations;
 
extern void page_init(void);
extern void page_mapping_insert(__address page, __address frame, int flags, __address root);
extern pte_t *page_mapping_find(__address page, __address root);
extern void page_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root);
extern pte_t *page_mapping_find(__address page, asid_t asid, __address root);
extern void map_structure(__address s, size_t size);
 
#endif
/kernel/trunk/generic/include/mm/asid.h
0,0 → 1,34
/*
* 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.
*/
 
#ifndef __ASID_H__
#define __ASID_H__
 
#define ASID_KERNEL 0
 
#endif
/kernel/trunk/generic/src/mm/vm.c
162,7 → 162,7
 
ASSERT(m->ptl0);
for (i=0; i<a->size; i++)
page_mapping_insert(a->address + i*PAGE_SIZE, a->mapping[i], flags, (__address) m->ptl0);
page_mapping_insert(a->address + i*PAGE_SIZE, m->asid, a->mapping[i], flags, (__address) m->ptl0);
spinlock_unlock(&a->lock);
spinlock_unlock(&m->lock);
180,7 → 180,7
 
ASSERT(m->ptl0);
for (i=0; i<a->size; i++)
page_mapping_insert(a->address + i*PAGE_SIZE, 0, PAGE_NOT_PRESENT, (__address) m->ptl0);
page_mapping_insert(a->address + i*PAGE_SIZE, 0, 0, PAGE_NOT_PRESENT, (__address) m->ptl0);
spinlock_unlock(&a->lock);
spinlock_unlock(&m->lock);
/kernel/trunk/generic/src/mm/page.c
27,13 → 27,16
*/
 
#include <mm/page.h>
#include <arch/mm/page.h>
#include <arch/mm/asid.h>
#include <mm/asid.h>
#include <mm/frame.h>
#include <arch/mm/page.h>
#include <arch/types.h>
#include <typedefs.h>
#include <arch/asm.h>
#include <memstr.h>
#include <debug.h>
#include <arch.h>
 
/** Virtual operations for page subsystem. */
page_operations_t *page_operations = NULL;
41,7 → 44,7
void page_init(void)
{
page_arch_init();
page_mapping_insert(0x0, 0x0, PAGE_NOT_PRESENT, 0);
page_mapping_insert(0x0, 0, 0x0, PAGE_NOT_PRESENT, 0);
}
 
/** Map memory structure
61,7 → 64,7
cnt = length/PAGE_SIZE + (length%PAGE_SIZE>0);
 
for (i = 0; i < cnt; i++)
page_mapping_insert(s + i*PAGE_SIZE, s + i*PAGE_SIZE, PAGE_NOT_CACHEABLE, 0);
page_mapping_insert(s + i*PAGE_SIZE, ASID_KERNEL, s + i*PAGE_SIZE, PAGE_NOT_CACHEABLE, 0);
 
}
 
71,16 → 74,17
* using 'flags'. Allocate and setup any missing page tables.
*
* @param page Virtual address of the page to be mapped.
* @param asid Address space to wich page belongs.
* @param frame Physical address of memory frame to which the mapping is done.
* @param flags Flags to be used for mapping.
* @param root Explicit PTL0 address.
*/
void page_mapping_insert(__address page, __address frame, int flags, __address root)
void page_mapping_insert(__address page, asid_t asid, __address frame, int flags, __address root)
{
ASSERT(page_operations);
ASSERT(page_operations->mapping_insert);
page_operations->mapping_insert(page, frame, flags, root);
page_operations->mapping_insert(page, asid, frame, flags, root);
}
 
/** Find mapping for virtual page
88,14 → 92,15
* Find mapping for virtual page.
*
* @param page Virtual page.
* @param asid Address space to wich page belongs.
* @param root PTL0 address if non-zero.
*
* @return NULL if there is no such mapping; entry from PTL3 describing the mapping otherwise.
*/
pte_t *page_mapping_find(__address page, __address root)
pte_t *page_mapping_find(__address page, asid_t asid, __address root)
{
ASSERT(page_operations);
ASSERT(page_operations->mapping_find);
 
return page_operations->mapping_find(page, root);
return page_operations->mapping_find(page, asid, root);
}
/kernel/trunk/arch/amd64/src/mm/page.c
56,7 → 56,7
* PA2KA(identity) mapping for all frames.
*/
for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
page_mapping_insert(PA2KA(cur), cur, PAGE_CACHEABLE | PAGE_EXEC, KA2PA(dba));
page_mapping_insert(PA2KA(cur), 0, cur, PAGE_CACHEABLE | PAGE_EXEC, KA2PA(dba));
}
 
exc_register(14, "page_fault", page_fault);
/kernel/trunk/arch/mips32/src/mm/tlb.c
336,7 → 336,7
/*
* Handler cannot succeed if badvaddr has no mapping.
*/
pte = page_mapping_find(badvaddr, 0);
pte = page_mapping_find(badvaddr, VM->asid, 0);
if (!pte) {
printf("No such mapping.\n");
return NULL;
/kernel/trunk/arch/ia32/src/smp/smp.c
43,6 → 43,7
#include <mm/frame.h>
#include <mm/page.h>
#include <mm/heap.h>
#include <mm/asid.h>
#include <print.h>
#include <memstr.h>
#include <arch/i8259.h>
63,9 → 64,9
}
 
if (config.cpu_count > 1) {
page_mapping_insert((__address)l_apic, (__address)l_apic,
page_mapping_insert((__address)l_apic, ASID_KERNEL, (__address)l_apic,
PAGE_NOT_CACHEABLE, 0);
page_mapping_insert((__address) io_apic,
page_mapping_insert((__address) io_apic, ASID_KERNEL,
(__address) io_apic,
PAGE_NOT_CACHEABLE, 0);
}
/kernel/trunk/arch/ia32/src/mm/page.c
31,6 → 31,7
#include <arch/mm/frame.h>
#include <mm/frame.h>
#include <mm/page.h>
#include <mm/asid.h>
#include <arch/types.h>
#include <config.h>
#include <func.h>
60,7 → 61,7
* PA2KA(identity) mapping for all frames until last_frame.
*/
for (cur = 0; cur < last_frame; cur += FRAME_SIZE)
page_mapping_insert(PA2KA(cur), cur, PAGE_CACHEABLE, KA2PA(dba));
page_mapping_insert(PA2KA(cur), ASID_KERNEL, cur, PAGE_CACHEABLE, KA2PA(dba));
 
exc_register(14, "page_fault", page_fault);
write_cr3(KA2PA(dba));
/kernel/trunk/arch/ia32/src/drivers/ega.c
29,6 → 29,7
#include <arch/ega.h>
#include <putchar.h>
#include <mm/page.h>
#include <mm/asid.h>
#include <arch/mm/page.h>
#include <synch/spinlock.h>
#include <arch/types.h>
58,7 → 59,7
{
__u8 hi, lo;
 
page_mapping_insert(PA2KA(VIDEORAM), VIDEORAM, PAGE_NOT_CACHEABLE, 0);
page_mapping_insert(PA2KA(VIDEORAM), ASID_KERNEL, VIDEORAM, PAGE_NOT_CACHEABLE, 0);
outb(0x3d4,0xe);
hi = inb(0x3d5);
outb(0x3d4,0xf);