source: mainline/kernel/generic/src/mm/km.c@ 69114714

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 69114714 was 96d9cdd, checked in by Jakub Jermar <jakub@…>, 13 years ago

Revert most of jakub@….
The code already did the right thing; it was the author who was confused.

  • Property mode set to 100644
File size: 7.4 KB
RevLine 
[622f409]1/*
2 * Copyright (c) 2011 Jakub Jermar
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/** @addtogroup genericmm
30 * @{
31 */
32
33/**
34 * @file
35 * @brief Kernel virtual memory setup.
36 */
37
38#include <mm/km.h>
[55896b6]39#include <arch/mm/km.h>
[c868e2d]40#include <mm/page.h>
[f7f47a7]41#include <mm/frame.h>
42#include <mm/asid.h>
[55896b6]43#include <config.h>
[29938b2]44#include <typedefs.h>
[7c3e482]45#include <lib/ra.h>
46#include <debug.h>
[f7f47a7]47#include <arch.h>
[d4673296]48#include <align.h>
49#include <macros.h>
50#include <bitops.h>
[7c3e482]51
52static ra_arena_t *km_ni_arena;
[622f409]53
[f7f47a7]54#define DEFERRED_PAGES_MAX (PAGE_SIZE / sizeof(uintptr_t))
55
56/** Number of freed pages in the deferred buffer. */
57static volatile unsigned deferred_pages;
58/** Buffer of deferred freed pages. */
59static uintptr_t deferred_page[DEFERRED_PAGES_MAX];
60
61/** Flush the buffer of deferred freed pages.
62 *
63 * @return Number of freed pages.
64 */
65static unsigned km_flush_deferred(void)
66{
67 unsigned i = 0;
68 ipl_t ipl;
69
70 ipl = tlb_shootdown_start(TLB_INVL_ASID, ASID_KERNEL, 0, 0);
71
72 for (i = 0; i < deferred_pages; i++) {
73 page_mapping_remove(AS_KERNEL, deferred_page[i]);
74 km_page_free(deferred_page[i], PAGE_SIZE);
75 }
76
77 tlb_invalidate_asid(ASID_KERNEL);
78
79 as_invalidate_translation_cache(AS_KERNEL, 0, -1);
80 tlb_shootdown_finalize(ipl);
81
82 return i;
83}
84
[622f409]85/** Architecture dependent setup of identity-mapped kernel memory. */
86void km_identity_init(void)
87{
[55896b6]88 km_identity_arch_init();
89 config.identity_configured = true;
[622f409]90}
91
92/** Architecture dependent setup of non-identity-mapped kernel memory. */
93void km_non_identity_init(void)
94{
[7c3e482]95 km_ni_arena = ra_arena_create();
96 ASSERT(km_ni_arena != NULL);
[55896b6]97 km_non_identity_arch_init();
98 config.non_identity_configured = true;
[622f409]99}
100
[1b478f6]101bool km_is_non_identity(uintptr_t addr)
102{
103 return km_is_non_identity_arch(addr);
104}
105
[29938b2]106void km_non_identity_span_add(uintptr_t base, size_t size)
107{
[7c3e482]108 bool span_added;
109
[c868e2d]110 page_mapping_make_global(base, size);
111
[7c3e482]112 span_added = ra_span_add(km_ni_arena, base, size);
113 ASSERT(span_added);
114}
115
116uintptr_t km_page_alloc(size_t size, size_t align)
117{
118 return ra_alloc(km_ni_arena, size, align);
[29938b2]119}
120
[7c3e482]121void km_page_free(uintptr_t page, size_t size)
122{
123 ra_free(km_ni_arena, page, size);
124}
125
[bf3dd35]126static uintptr_t
127km_map_aligned(uintptr_t paddr, size_t size, unsigned int flags)
[d4673296]128{
[adec5b45]129 uintptr_t vaddr;
[d4673296]130 size_t align;
[adec5b45]131 uintptr_t offs;
[d4673296]132
[03cdd2b]133 ASSERT(ALIGN_DOWN(paddr, FRAME_SIZE) == paddr);
134 ASSERT(ALIGN_UP(size, FRAME_SIZE) == size);
135
[492ddc9]136 /* Enforce natural or at least PAGE_SIZE alignment. */
[d4673296]137 align = ispwr2(size) ? size : (1U << (fnzb(size) + 1));
[03cdd2b]138 vaddr = km_page_alloc(size, max(PAGE_SIZE, align));
[d4673296]139
140 page_table_lock(AS_KERNEL, true);
[03cdd2b]141 for (offs = 0; offs < size; offs += PAGE_SIZE) {
[adec5b45]142 page_mapping_insert(AS_KERNEL, vaddr + offs, paddr + offs,
143 flags);
[d4673296]144 }
145 page_table_unlock(AS_KERNEL, true);
146
[adec5b45]147 return vaddr;
[d4673296]148}
149
[03cdd2b]150static void km_unmap_aligned(uintptr_t vaddr, size_t size)
151{
152 uintptr_t offs;
153 ipl_t ipl;
154
155 ASSERT(ALIGN_DOWN(vaddr, PAGE_SIZE) == vaddr);
156 ASSERT(ALIGN_UP(size, PAGE_SIZE) == size);
157
158 page_table_lock(AS_KERNEL, true);
159
160 ipl = tlb_shootdown_start(TLB_INVL_ASID, ASID_KERNEL, 0, 0);
161
162 for (offs = 0; offs < size; offs += PAGE_SIZE)
163 page_mapping_remove(AS_KERNEL, vaddr + offs);
164
165 tlb_invalidate_asid(ASID_KERNEL);
166
167 as_invalidate_translation_cache(AS_KERNEL, 0, -1);
168 tlb_shootdown_finalize(ipl);
169 page_table_unlock(AS_KERNEL, true);
170
[96d9cdd]171 km_page_free(vaddr, size);
[03cdd2b]172}
173
174/** Map a piece of physical address space into the virtual address space.
175 *
176 * @param paddr Physical address to be mapped. May be unaligned.
177 * @param size Size of area starting at paddr to be mapped.
178 * @param flags Protection flags to be used for the mapping.
179 *
180 * @return New virtual address mapped to paddr.
181 */
[bf3dd35]182uintptr_t km_map(uintptr_t paddr, size_t size, unsigned int flags)
[babb57e]183{
184 uintptr_t page;
[03cdd2b]185 size_t offs;
186
187 offs = paddr - ALIGN_DOWN(paddr, FRAME_SIZE);
188 page = km_map_aligned(ALIGN_DOWN(paddr, FRAME_SIZE),
189 ALIGN_UP(size + offs, FRAME_SIZE), flags);
[babb57e]190
191 return page + offs;
192}
[d4673296]193
[03cdd2b]194/** Unmap a piece of virtual address space.
195 *
196 * @param vaddr Virtual address to be unmapped. May be unaligned, but
197 * it must a value previously returned by km_map().
198 * @param size Size of area starting at vaddr to be unmapped.
199 */
200void km_unmap(uintptr_t vaddr, size_t size)
201{
202 size_t offs;
203
204 offs = vaddr - ALIGN_DOWN(vaddr, PAGE_SIZE);
205 km_unmap_aligned(ALIGN_DOWN(vaddr, PAGE_SIZE),
206 ALIGN_UP(size + offs, PAGE_SIZE));
207}
208
209/** Unmap kernel non-identity page.
[f7f47a7]210 *
211 * @param[in] page Non-identity page to be unmapped.
212 */
213static void km_unmap_deferred(uintptr_t page)
214{
215 page_table_lock(AS_KERNEL, true);
216
217 if (deferred_pages == DEFERRED_PAGES_MAX) {
218 (void) km_flush_deferred();
219 deferred_pages = 0;
220 }
221
222 deferred_page[deferred_pages++] = page;
223
224 page_table_unlock(AS_KERNEL, true);
225}
226
227/** Create a temporary page.
228 *
229 * The page is mapped read/write to a newly allocated frame of physical memory.
230 * The page must be returned back to the system by a call to
231 * km_temporary_page_put().
232 *
233 * @param[inout] framep Pointer to a variable which will receive the physical
234 * address of the allocated frame.
235 * @param[in] flags Frame allocation flags. FRAME_NONE or FRAME_NO_RESERVE.
236 * @return Virtual address of the allocated frame.
237 */
238uintptr_t km_temporary_page_get(uintptr_t *framep, frame_flags_t flags)
239{
240 uintptr_t frame;
241 uintptr_t page;
242
243 ASSERT(THREAD);
244 ASSERT(framep);
245 ASSERT(!(flags & ~FRAME_NO_RESERVE));
246
247 /*
248 * Allocate a frame, preferably from high memory.
249 */
250 frame = (uintptr_t) frame_alloc(ONE_FRAME,
251 FRAME_HIGHMEM | FRAME_ATOMIC | flags);
252 if (frame) {
[1ccd0aa]253 page = km_map(frame, PAGE_SIZE,
254 PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
[f7f47a7]255 ASSERT(page); // FIXME
256 } else {
257 frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME,
258 FRAME_LOWMEM);
259 page = PA2KA(frame);
260 }
261
262 *framep = frame;
263 return page;
264}
265
266/** Destroy a temporary page.
267 *
268 * This function destroys a temporary page previously created by
269 * km_temporary_page_get(). The page destruction may be immediate or deferred.
270 * The frame mapped by the destroyed page is not freed.
271 *
272 * @param[in] page Temporary page to be destroyed.
273 */
274void km_temporary_page_put(uintptr_t page)
275{
276 ASSERT(THREAD);
277
278 if (km_is_non_identity(page))
279 km_unmap_deferred(page);
280}
[7c3e482]281
[622f409]282/** @}
283 */
284
Note: See TracBrowser for help on using the repository browser.