Subversion Repositories HelenOS

Rev

Rev 2787 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2787 Rev 3424
Line 38... Line 38...
38
 * mappings between virtual addresses and physical addresses.
38
 * mappings between virtual addresses and physical addresses.
39
 * Functions here are mere wrappers that call the real implementation.
39
 * Functions here are mere wrappers that call the real implementation.
40
 * They however, define the single interface.
40
 * They however, define the single interface.
41
 */
41
 */
42
 
42
 
-
 
43
/*
-
 
44
 * Note on memory prefetching and updating memory mappings, also described in:
-
 
45
 * AMD x86-64 Architecture Programmer's Manual, Volume 2, System Programming,
-
 
46
 * 7.2.1 Special Coherency Considerations.
-
 
47
 *
-
 
48
 * The processor which modifies a page table mapping can access prefetched data
-
 
49
 * from the old mapping.  In order to prevent this, we place a memory barrier
-
 
50
 * after a mapping is updated.
-
 
51
 *
-
 
52
 * We assume that the other processors are either not using the mapping yet
-
 
53
 * (i.e. during the bootstrap) or are executing the TLB shootdown code.  While
-
 
54
 * we don't care much about the former case, the processors in the latter case
-
 
55
 * will do an implicit serialization by virtue of running the TLB shootdown
-
 
56
 * interrupt handler.
-
 
57
 */
-
 
58
 
43
#include <mm/page.h>
59
#include <mm/page.h>
44
#include <arch/mm/page.h>
60
#include <arch/mm/page.h>
45
#include <arch/mm/asid.h>
61
#include <arch/mm/asid.h>
46
#include <mm/as.h>
62
#include <mm/as.h>
47
#include <mm/frame.h>
63
#include <mm/frame.h>
-
 
64
#include <arch/barrier.h>
48
#include <arch/types.h>
65
#include <arch/types.h>
49
#include <arch/asm.h>
66
#include <arch/asm.h>
50
#include <memstr.h>
67
#include <memstr.h>
51
#include <debug.h>
68
#include <debug.h>
52
#include <arch.h>
69
#include <arch.h>
Line 63... Line 80...
63
 *
80
 *
64
 * Identity-map memory structure
81
 * Identity-map memory structure
65
 * considering possible crossings
82
 * considering possible crossings
66
 * of page boundaries.
83
 * of page boundaries.
67
 *
84
 *
68
 * @param s Address of the structure.
85
 * @param s     Address of the structure.
69
 * @param size Size of the structure.
86
 * @param size      Size of the structure.
70
 */
87
 */
71
void map_structure(uintptr_t s, size_t size)
88
void map_structure(uintptr_t s, size_t size)
72
{
89
{
73
    int i, cnt, length;
90
    int i, cnt, length;
74
 
91
 
75
    length = size + (s - (s & ~(PAGE_SIZE - 1)));
92
    length = size + (s - (s & ~(PAGE_SIZE - 1)));
76
    cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
93
    cnt = length / PAGE_SIZE + (length % PAGE_SIZE > 0);
77
 
94
 
78
    for (i = 0; i < cnt; i++)
95
    for (i = 0; i < cnt; i++)
-
 
96
        page_mapping_insert(AS_KERNEL, s + i * PAGE_SIZE,
79
        page_mapping_insert(AS_KERNEL, s + i * PAGE_SIZE, s + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
97
            s + i * PAGE_SIZE, PAGE_NOT_CACHEABLE | PAGE_WRITE);
80
 
98
 
-
 
99
    /* Repel prefetched accesses to the old mapping. */
-
 
100
    memory_barrier();
81
}
101
}
82
 
102
 
83
/** Insert mapping of page to frame.
103
/** Insert mapping of page to frame.
84
 *
104
 *
85
 * Map virtual address page to physical address frame
105
 * Map virtual address page to physical address frame
86
 * using flags. Allocate and setup any missing page tables.
106
 * using flags. Allocate and setup any missing page tables.
87
 *
107
 *
88
 * The page table must be locked and interrupts must be disabled.
108
 * The page table must be locked and interrupts must be disabled.
89
 *
109
 *
90
 * @param as Address space to wich page belongs.
110
 * @param as        Address space to wich page belongs.
91
 * @param page Virtual address of the page to be mapped.
111
 * @param page      Virtual address of the page to be mapped.
92
 * @param frame Physical address of memory frame to which the mapping is done.
112
 * @param frame     Physical address of memory frame to which the mapping is
-
 
113
 *          done.
93
 * @param flags Flags to be used for mapping.
114
 * @param flags     Flags to be used for mapping.
94
 */
115
 */
95
void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
116
void page_mapping_insert(as_t *as, uintptr_t page, uintptr_t frame, int flags)
96
{
117
{
97
    ASSERT(page_mapping_operations);
118
    ASSERT(page_mapping_operations);
98
    ASSERT(page_mapping_operations->mapping_insert);
119
    ASSERT(page_mapping_operations->mapping_insert);
99
   
120
   
100
    page_mapping_operations->mapping_insert(as, page, frame, flags);
121
    page_mapping_operations->mapping_insert(as, page, frame, flags);
-
 
122
   
-
 
123
    /* Repel prefetched accesses to the old mapping. */
-
 
124
    memory_barrier();
101
}
125
}
102
 
126
 
103
/** Remove mapping of page.
127
/** Remove mapping of page.
104
 *
128
 *
105
 * Remove any mapping of page within address space as.
129
 * Remove any mapping of page within address space as.
106
 * TLB shootdown should follow in order to make effects of
130
 * TLB shootdown should follow in order to make effects of
107
 * this call visible.
131
 * this call visible.
108
 *
132
 *
109
 * The page table must be locked and interrupts must be disabled.
133
 * The page table must be locked and interrupts must be disabled.
110
 *
134
 *
111
 * @param as Address space to wich page belongs.
135
 * @param as        Address space to wich page belongs.
112
 * @param page Virtual address of the page to be demapped.
136
 * @param page      Virtual address of the page to be demapped.
113
 */
137
 */
114
void page_mapping_remove(as_t *as, uintptr_t page)
138
void page_mapping_remove(as_t *as, uintptr_t page)
115
{
139
{
116
    ASSERT(page_mapping_operations);
140
    ASSERT(page_mapping_operations);
117
    ASSERT(page_mapping_operations->mapping_remove);
141
    ASSERT(page_mapping_operations->mapping_remove);
118
   
142
   
119
    page_mapping_operations->mapping_remove(as, page);
143
    page_mapping_operations->mapping_remove(as, page);
-
 
144
 
-
 
145
    /* Repel prefetched accesses to the old mapping. */
-
 
146
    memory_barrier();
120
}
147
}
121
 
148
 
122
/** Find mapping for virtual page
149
/** Find mapping for virtual page
123
 *
150
 *
124
 * Find mapping for virtual page.
151
 * Find mapping for virtual page.
125
 *
152
 *
126
 * The page table must be locked and interrupts must be disabled.
153
 * The page table must be locked and interrupts must be disabled.
127
 *
154
 *
128
 * @param as Address space to wich page belongs.
155
 * @param as        Address space to wich page belongs.
129
 * @param page Virtual page.
156
 * @param page      Virtual page.
130
 *
157
 *
131
 * @return NULL if there is no such mapping; requested mapping otherwise.
158
 * @return      NULL if there is no such mapping; requested mapping
-
 
159
 *          otherwise.
132
 */
160
 */
133
pte_t *page_mapping_find(as_t *as, uintptr_t page)
161
pte_t *page_mapping_find(as_t *as, uintptr_t page)
134
{
162
{
135
    ASSERT(page_mapping_operations);
163
    ASSERT(page_mapping_operations);
136
    ASSERT(page_mapping_operations->mapping_find);
164
    ASSERT(page_mapping_operations->mapping_find);