VirtualBox

source: vbox/trunk/src/VBox/ValidationKit/bootsectors/bs3kit/bs3-rm-InitMemory.c@ 60009

Last change on this file since 60009 was 59941, checked in by vboxsync, 9 years ago

bs3kit: Updates and fixes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.7 KB
Line 
1/* $Id: bs3-rm-InitMemory.c 59941 2016-03-07 15:13:51Z vboxsync $ */
2/** @file
3 * BS3Kit - Bs3InitMemory
4 */
5
6/*
7 * Copyright (C) 2007-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27/*********************************************************************************************************************************
28* Header Files *
29*********************************************************************************************************************************/
30#include "bs3kit-template-header.h"
31#include "bs3-cmn-memory.h"
32#include <iprt/asm.h>
33
34
35/*********************************************************************************************************************************
36* Structures and Typedefs *
37*********************************************************************************************************************************/
38
39typedef struct INT15E820ENTRY
40{
41 uint64_t uBaseAddr;
42 uint64_t cbRange;
43 /** Memory type this entry describes, see INT15E820_TYPE_XXX. */
44 uint32_t uType;
45 uint32_t fAcpi3;
46} INT15E820ENTRY;
47AssertCompileSize(INT15E820ENTRY,24);
48
49
50/** @name INT15E820_TYPE_XXX - Memory types returned by int 15h function 0xe820.
51 * @{ */
52#define INT15E820_TYPE_USABLE 1 /**< Usable RAM. */
53#define INT15E820_TYPE_RESERVED 2 /**< Reserved by the system, unusable. */
54#define INT15E820_TYPE_ACPI_RECLAIMABLE 3 /**< ACPI reclaimable memory, whatever that means. */
55#define INT15E820_TYPE_ACPI_NVS 4 /**< ACPI non-volatile storage? */
56#define INT15E820_TYPE_BAD 5 /**< Bad memory, unusable. */
57/** @} */
58
59
60/**
61 * Performs a int 15h function 0xe820 call.
62 *
63 * @returns Continuation value on success, 0 on failure.
64 * (Because of the way the API works, EBX should never be zero when
65 * data is returned.)
66 * @param pEntry The return buffer.
67 * @param cbEntry The size of the buffer (min 20 bytes).
68 * @param uContinuationValue Zero the first time, the return value from the
69 * previous call after that.
70 */
71BS3_DECL(uint32_t) Bs3BiosInt15hE820(INT15E820ENTRY BS3_FAR *pEntry, size_t cbEntry, uint32_t uContinuationValue);
72#pragma aux Bs3BiosInt15hE820 = \
73 ".386" \
74 "shl ebx, 10h" \
75 "mov bx, ax" /* ebx = continutation */ \
76 "movzx ecx, cx" \
77 "movzx edi, di" \
78 "mov edx, 0534d4150h" /*SMAP*/ \
79 "mov eax, 0xe820" \
80 "int 15h" \
81 "jc failed" \
82 "cmp eax, 0534d4150h" \
83 "jne failed" \
84 "cmp cx, 20" \
85 "jb failed" \
86 "mov ax, bx" \
87 "shr ebx, 10h" /* ax:bx = continuation */ \
88 "jmp done" \
89 "failed:" \
90 "xor ax, ax" \
91 "xor bx, bx" \
92 "done:" \
93 parm [es di] [cx] [ax bx] \
94 value [ax bx] \
95 modify exact [ax bx cx dx di es];
96
97
98/*********************************************************************************************************************************
99* Global Variables *
100*********************************************************************************************************************************/
101/** Slab control structure for the 4K management of low memory (< 1MB). */
102BS3SLABCTLLOW BS3_DATA_NM(g_Bs3Mem4KLow);
103/** Slab control structure for the 4K management of tiled upper memory,
104 * between 1 MB and 16MB. */
105BS3SLABCTLUPPERTILED BS3_DATA_NM(g_Bs3Mem4KUpperTiled);
106
107
108/** Translates a power of two request size to an slab list index. */
109uint8_t const BS3_DATA_NM(g_aiBs3SlabListsByPowerOfTwo)[12] =
110{
111 /* 2^0 = 1 */ 0,
112 /* 2^1 = 2 */ 0,
113 /* 2^2 = 4 */ 0,
114 /* 2^3 = 8 */ 0,
115 /* 2^4 = 16 */ 0,
116 /* 2^5 = 32 */ 1,
117 /* 2^6 = 64 */ 2,
118 /* 2^7 = 128 */ 3,
119 /* 2^8 = 256 */ 4,
120 /* 2^9 = 512 */ 5,
121 /* 2^10 = 1024 */ -1
122 /* 2^11 = 2048 */ -1
123};
124
125/** The slab list chunk sizes. */
126uint16_t const BS3_DATA_NM(g_acbBs3SlabLists)[BS3_MEM_SLAB_LIST_COUNT] =
127{
128 16,
129 32,
130 64,
131 128,
132 256,
133 512,
134};
135
136/** Low memory slab lists, sizes given by g_acbBs3SlabLists. */
137BS3SLABHEAD BS3_DATA_NM(g_aBs3LowSlabLists)[BS3_MEM_SLAB_LIST_COUNT];
138/** Upper tiled memory slab lists, sizes given by g_acbBs3SlabLists. */
139BS3SLABHEAD BS3_DATA_NM(g_aBs3UpperTiledSlabLists)[BS3_MEM_SLAB_LIST_COUNT];
140
141/** Slab control structure sizes for the slab lists.
142 * This is to help the allocator when growing a list. */
143uint16_t const BS3_DATA_NM(g_cbBs3SlabCtlSizesforLists)[BS3_MEM_SLAB_LIST_COUNT] =
144{
145 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 16 / 8 /*=32*/), 16),
146 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 32 / 8 /*=16*/), 32),
147 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 64 / 8 /*=8*/), 64),
148 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 128 / 8 /*=4*/), 128),
149 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 256 / 8 /*=2*/), 256),
150 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 512 / 8 /*=1*/), 512),
151};
152
153
154
155BS3_DECL(void) Bs3InitMemory_rm(void)
156{
157 uint16_t i;
158 uint16_t cPages;
159 INT15E820ENTRY Entry;
160
161 /*
162 * Enable the A20 gate.
163 */
164 Bs3A20Enable();
165
166 /*
167 * Low memory (4K chunks).
168 * - 0x00000 to 0x004ff - Interrupt Vector table, BIOS data area.
169 * - 0x01000 to 0x0ffff - Stacks.
170 * - 0x10000 to 0x1yyyy - BS3TEXT16
171 * - 0x20000 to 0x26fff - BS3SYSTEM16
172 * - 0x27000 to 0xzzzzz - BS3DATA16, BS3TEXT32, BS3TEXT64, BS3DATA32, BS3DATA64 (in that order).
173 * - 0xzzzzZ to 0x9fdff - Free conventional memory.
174 * - 0x9fc00 to 0x9ffff - Extended BIOS data area (exact start may vary).
175 * - 0xa0000 to 0xbffff - VGA MMIO
176 * - 0xc0000 to 0xc7fff - VGA BIOS
177 * - 0xc8000 to 0xeffff - ROMs, tables, unusable.
178 * - 0xf0000 to 0xfffff - PC BIOS.
179 */
180 Bs3SlabInit(&BS3_DATA_NM(g_Bs3Mem4KLow).Core, sizeof(BS3_DATA_NM(g_Bs3Mem4KLow)),
181 0 /*uFlatSlabPtr*/, 0xA0000 /* 640 KB*/, _4K);
182
183 /* Mark the stacks and whole image as allocated. */
184 cPages = (BS3_DATA_NM(Bs3TotalImageSize) + _4K - 1U) >> 12;
185 ASMBitSetRange(BS3_DATA_NM(g_Bs3Mem4KLow).Core.bmAllocated, 0, 0x10 + cPages);
186
187 /* Mark any unused pages between BS3TEXT16 and BS3SYSTEM16 as free. */
188 cPages = (BS3_DATA_NM(Bs3Text16_Size) + _4K - 1U) >> 12;
189 ASMBitClearRange(BS3_DATA_NM(g_Bs3Mem4KLow).Core.bmAllocated, 0x10U + cPages, 0x20U);
190
191 /* In case the system has less than 640KB of memory, check the BDA variable for it. */
192 cPages = *(uint16_t BS3_FAR *)BS3_FP_MAKE(0x0000, 0x0413); /* KB of low memory */
193 if (cPages < 640)
194 {
195 cPages = 640 - cPages;
196 cPages = RT_ALIGN(cPages, 4);
197 cPages >>= 2;
198 ASMBitSetRange(BS3_DATA_NM(g_Bs3Mem4KLow).Core.bmAllocated, 0xA0 - cPages, 0xA0);
199 }
200 else
201 ASMBitSet(BS3_DATA_NM(g_Bs3Mem4KLow).Core.bmAllocated, 0x9F);
202
203 /* Recalc free pages. */
204 cPages = 0;
205 i = BS3_DATA_NM(g_Bs3Mem4KLow).Core.cChunks;
206 while (i-- > 0)
207 cPages += !ASMBitTest(BS3_DATA_NM(g_Bs3Mem4KLow).Core.bmAllocated, i);
208 BS3_DATA_NM(g_Bs3Mem4KLow).Core.cFreeChunks = cPages;
209
210 /*
211 * First 16 MB of memory above 1MB. We start out by marking it all allocated.
212 */
213 Bs3SlabInit(&BS3_DATA_NM(g_Bs3Mem4KUpperTiled).Core, sizeof(BS3_DATA_NM(g_Bs3Mem4KUpperTiled)),
214 _1M, BS3_SEL_TILED_AREA_SIZE - _1M, _4K);
215
216 ASMBitSetRange(BS3_DATA_NM(g_Bs3Mem4KUpperTiled).Core.bmAllocated, 0, BS3_DATA_NM(g_Bs3Mem4KUpperTiled).Core.cChunks);
217 BS3_DATA_NM(g_Bs3Mem4KUpperTiled).Core.cFreeChunks = 0;
218
219 /* Ask the BIOS about where there's memory, and make pages in between 1MB
220 and BS3_SEL_TILED_AREA_SIZE present. This means we're only interested
221 in entries describing usable memory, ASSUMING of course no overlaps. */
222 if ( (BS3_DATA_NM(g_uBs3CpuDetected) & BS3CPU_TYPE_MASK) >= BS3CPU_80386
223 && Bs3BiosInt15hE820(&Entry, sizeof(Entry), 0) != 0)
224 {
225 uint32_t uCont = 0;
226 i = 0;
227 while ( (uCont = Bs3BiosInt15hE820(&Entry, sizeof(Entry), uCont)) != 0
228 && i++ < 2048)
229 {
230 if (Entry.uType == INT15E820_TYPE_USABLE)
231 {
232 if (Entry.uBaseAddr < BS3_SEL_TILED_AREA_SIZE)
233 {
234 /* Entry concerning tiled memory. Convert from 64-bit to 32-bit
235 values and check whether it's concerning anything at or above 1MB */
236 uint32_t uRange = (uint32_t)Entry.uBaseAddr;
237 uint32_t cbRange = Entry.cbRange >= BS3_SEL_TILED_AREA_SIZE
238 ? BS3_SEL_TILED_AREA_SIZE : (uint32_t)Entry.cbRange;
239 uint32_t uRangeEnd = uRange + cbRange;
240 AssertCompile(BS3_SEL_TILED_AREA_SIZE <= _512M /* the range of 16-bit cPages. */ );
241 if ( uRange >= _1M
242 || uRangeEnd > _1M)
243 {
244 /* Adjust the start of the range such that it's at or above 1MB and page aligned. */
245 if (uRange < _1M)
246 {
247 cbRange -= _1M - uRange;
248 uRange = _1M;
249 }
250 else if (uRange & (_4K - 1U))
251 {
252 cbRange -= uRange & (_4K - 1U);
253 uRange = RT_ALIGN_32(uRange, _4K);
254 }
255
256 /* Adjust the end/size of the range such that it's page aligned and not beyond the tiled area. */
257 if (uRangeEnd > BS3_SEL_TILED_AREA_SIZE)
258 {
259 cbRange -= uRangeEnd - BS3_SEL_TILED_AREA_SIZE;
260 uRangeEnd = BS3_SEL_TILED_AREA_SIZE;
261 }
262 else if (uRangeEnd & (_4K - 1U))
263 {
264 cbRange -= uRangeEnd & (_4K - 1U);
265 uRangeEnd &= ~(uint32_t)(_4K - 1U);
266 }
267
268 /* If there is still something, enable it.
269 (We're a bit paranoid here don't trust the BIOS to only report a page once.) */
270 cPages = cbRange >> 12; /*div 4K*/
271 if (cPages)
272 {
273 uRange -= _1M;
274 i = uRange >> 12; /*div _4K*/
275 while (cPages-- > 0)
276 {
277 uint16_t uLineToLong = ASMBitTestAndClear(g_Bs3Mem4KUpperTiled.Core.bmAllocated, i);
278 BS3_DATA_NM(g_Bs3Mem4KUpperTiled).Core.cFreeChunks += uLineToLong;
279 i++;
280 }
281 }
282 }
283 }
284 }
285 }
286 }
287
288 /*
289 * Initialize the slab lists.
290 */
291 for (i = 0; i < BS3_MEM_SLAB_LIST_COUNT; i++)
292 {
293 Bs3SlabListInit(&g_aBs3LowSlabLists[i], g_acbBs3SlabLists[i]);
294 Bs3SlabListInit(&g_aBs3UpperTiledSlabLists[i], g_acbBs3SlabLists[i]);
295 }
296
297#if 0
298 /*
299 * For debugging.
300 */
301 Bs3Printf("Memory-low: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KLow.Core.cFreeChunks, g_Bs3Mem4KLow.Core.cChunks);
302 for (i = 0; i < 20; i++)
303 Bs3Printf("%02x ", g_Bs3Mem4KLow.Core.bmAllocated[i]);
304 Bs3Printf("\n");
305 Bs3Printf("Memory-upt: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KUpperTiled.Core.cFreeChunks, g_Bs3Mem4KUpperTiled.Core.cChunks);
306 for (i = 0; i < 32; i++)
307 Bs3Printf("%02x ", g_Bs3Mem4KUpperTiled.Core.bmAllocated[i]);
308 Bs3Printf("...\n");
309#endif
310}
311
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette