VirtualBox

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

Last change on this file was 106061, checked in by vboxsync, 2 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.6 KB
Line 
1/* $Id: bs3-rm-InitMemory.c 106061 2024-09-16 14:03:52Z vboxsync $ */
2/** @file
3 * BS3Kit - Bs3InitMemory
4 */
5
6/*
7 * Copyright (C) 2007-2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * The contents of this file may alternatively be used under the terms
26 * of the Common Development and Distribution License Version 1.0
27 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28 * in the VirtualBox distribution, in which case the provisions of the
29 * CDDL are applicable instead of those of the GPL.
30 *
31 * You may elect to license modified versions of this file under the
32 * terms and conditions of either the GPL or the CDDL or both.
33 *
34 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35 */
36
37
38/*********************************************************************************************************************************
39* Header Files *
40*********************************************************************************************************************************/
41#define BS3_USE_RM_TEXT_SEG 1
42#define BS3_BIOS_INLINE_RM
43#include "bs3kit-template-header.h"
44#include <iprt/asm-mem.h> /* This sucks */
45#include "bs3-cmn-memory.h"
46#include <iprt/asm.h>
47#include <VBox/VMMDevTesting.h>
48
49
50
51/*********************************************************************************************************************************
52* Global Variables *
53*********************************************************************************************************************************/
54/** Slab control structure for the 4K management of low memory (< 1MB). */
55BS3SLABCTLLOW g_Bs3Mem4KLow;
56/** Slab control structure for the 4K management of tiled upper memory,
57 * between 1 MB and 16MB. */
58BS3SLABCTLUPPERTILED g_Bs3Mem4KUpperTiled;
59
60
61/** Translates a power of two request size to an slab list index. */
62uint8_t const g_aiBs3SlabListsByPowerOfTwo[12] =
63{
64 /* 2^0 = 1 */ 0,
65 /* 2^1 = 2 */ 0,
66 /* 2^2 = 4 */ 0,
67 /* 2^3 = 8 */ 0,
68 /* 2^4 = 16 */ 0,
69 /* 2^5 = 32 */ 1,
70 /* 2^6 = 64 */ 2,
71 /* 2^7 = 128 */ 3,
72 /* 2^8 = 256 */ 4,
73 /* 2^9 = 512 */ 5,
74 /* 2^10 = 1024 */ -1
75 /* 2^11 = 2048 */ -1
76};
77
78/** The slab list chunk sizes. */
79uint16_t const g_acbBs3SlabLists[BS3_MEM_SLAB_LIST_COUNT] =
80{
81 16,
82 32,
83 64,
84 128,
85 256,
86 512,
87};
88
89/** Low memory slab lists, sizes given by g_acbBs3SlabLists. */
90BS3SLABHEAD g_aBs3LowSlabLists[BS3_MEM_SLAB_LIST_COUNT];
91/** Upper tiled memory slab lists, sizes given by g_acbBs3SlabLists. */
92BS3SLABHEAD g_aBs3UpperTiledSlabLists[BS3_MEM_SLAB_LIST_COUNT];
93
94/** Slab control structure sizes for the slab lists.
95 * This is to help the allocator when growing a list. */
96uint16_t const g_cbBs3SlabCtlSizesforLists[BS3_MEM_SLAB_LIST_COUNT] =
97{
98 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 16 / 8 /*=32*/), 16),
99 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 32 / 8 /*=16*/), 32),
100 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 64 / 8 /*=8*/), 64),
101 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 128 / 8 /*=4*/), 128),
102 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 256 / 8 /*=2*/), 256),
103 RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 512 / 8 /*=1*/), 512),
104};
105
106
107/** The end RAM address below 4GB (approximately). */
108uint32_t g_uBs3EndOfRamBelow4G = 0;
109/** The end RAM address above 4GB, zero if no memory above 4GB. */
110uint64_t g_uBs3EndOfRamAbove4G = 0;
111
112
113/**
114 * Adds a range of memory to the tiled slabs.
115 *
116 * @param uRange Start of range.
117 * @param cbRange Size of range.
118 */
119static void bs3InitMemoryAddRange32(uint32_t uRange, uint32_t cbRange)
120{
121 uint32_t uRangeEnd = uRange + cbRange;
122 if (uRangeEnd < uRange)
123 uRangeEnd = UINT32_MAX;
124
125 /* Raise the end-of-ram-below-4GB marker? */
126 if (uRangeEnd > g_uBs3EndOfRamBelow4G)
127 g_uBs3EndOfRamBelow4G = uRangeEnd;
128
129 /* Applicable to tiled memory? */
130 if ( uRange < BS3_SEL_TILED_AREA_SIZE
131 && ( uRange >= _1M
132 || uRangeEnd >= _1M))
133 {
134 uint16_t cPages;
135
136 /* Adjust the start of the range such that it's at or above 1MB and page aligned. */
137 if (uRange < _1M)
138 {
139 cbRange -= _1M - uRange;
140 uRange = _1M;
141 }
142 else if (uRange & (_4K - 1U))
143 {
144 cbRange -= uRange & (_4K - 1U);
145 uRange = RT_ALIGN_32(uRange, _4K);
146 }
147
148 /* Adjust the end/size of the range such that it's page aligned and not beyond the tiled area. */
149 if (uRangeEnd > BS3_SEL_TILED_AREA_SIZE)
150 {
151 cbRange -= uRangeEnd - BS3_SEL_TILED_AREA_SIZE;
152 uRangeEnd = BS3_SEL_TILED_AREA_SIZE;
153 }
154 else if (uRangeEnd & (_4K - 1U))
155 {
156 cbRange -= uRangeEnd & (_4K - 1U);
157 uRangeEnd &= ~(uint32_t)(_4K - 1U);
158 }
159
160 /* If there is still something, enable it.
161 (We're a bit paranoid here don't trust the BIOS to only report a page once.) */
162 cPages = cbRange >> 12; /*div 4K*/
163 if (cPages)
164 {
165 unsigned i;
166 uRange -= _1M;
167 i = uRange >> 12; /*div _4K*/
168 while (cPages-- > 0)
169 {
170 uint16_t uLineToLong = ASMBitTestAndClear(g_Bs3Mem4KUpperTiled.Core.bmAllocated, i);
171 g_Bs3Mem4KUpperTiled.Core.cFreeChunks += uLineToLong;
172 i++;
173 }
174 }
175 }
176}
177
178
179BS3_DECL(void) BS3_FAR_CODE Bs3InitMemory_rm_far(void)
180{
181 INT15E820ENTRY Entry = { 0, 0, 0, 0 };
182 uint32_t cbEntry = sizeof(Entry);
183 uint32_t uCont = 0;
184 uint16_t i;
185 uint16_t cPages;
186 uint32_t u32;
187 uint32_t BS3_FAR *pu32Mmio;
188
189 /*
190 * Enable the A20 gate.
191 */
192 Bs3A20Enable();
193
194 /*
195 * Low memory (4K chunks).
196 * - 0x00000 to 0x004ff - Interrupt Vector table, BIOS data area.
197 * - 0x01000 to 0x0ffff - Stacks.
198 * - 0x10000 to 0x1yyyy - BS3TEXT16
199 * - 0x20000 to 0x26fff - BS3SYSTEM16
200 * - 0x29000 to 0xzzzzz - BS3DATA16, BS3TEXT32, BS3TEXT64, BS3DATA32, BS3DATA64 (in that order).
201 * - 0xzzzzZ to 0x9fdff - Free conventional memory.
202 * - 0x9fc00 to 0x9ffff - Extended BIOS data area (exact start may vary).
203 * - 0xa0000 to 0xbffff - VGA MMIO
204 * - 0xc0000 to 0xc7fff - VGA BIOS
205 * - 0xc8000 to 0xeffff - ROMs, tables, unusable.
206 * - 0xf0000 to 0xfffff - PC BIOS.
207 */
208 Bs3SlabInit(&g_Bs3Mem4KLow.Core, sizeof(g_Bs3Mem4KLow), 0 /*uFlatSlabPtr*/, 0xA0000 /* 640 KB*/, _4K);
209
210 /* Mark the stacks and whole image as allocated. */
211 cPages = (Bs3TotalImageSize + _4K - 1U) >> 12;
212 ASMBitSetRange(g_Bs3Mem4KLow.Core.bmAllocated, 0, 0x10 + cPages);
213
214 /* Mark any unused pages between BS3TEXT16 and BS3SYSTEM16 as free. */
215 cPages = (Bs3Text16_Size + (uint32_t)_4K - 1U) >> 12;
216 ASMBitClearRange(g_Bs3Mem4KLow.Core.bmAllocated, 0x10U + cPages, 0x20U);
217
218 /* In case the system has less than 640KB of memory, check the BDA variable for it. */
219 cPages = *(uint16_t BS3_FAR *)BS3_FP_MAKE(0x0000, 0x0413); /* KB of low memory */
220 if (cPages < 640)
221 {
222 cPages = 640 - cPages;
223 cPages = RT_ALIGN(cPages, 4);
224 cPages >>= 2;
225 ASMBitSetRange(g_Bs3Mem4KLow.Core.bmAllocated, 0xA0 - cPages, 0xA0);
226 }
227 else
228 ASMBitSet(g_Bs3Mem4KLow.Core.bmAllocated, 0x9F);
229
230 /* Recalc free pages. */
231 cPages = 0;
232 i = g_Bs3Mem4KLow.Core.cChunks;
233 while (i-- > 0)
234 cPages += !ASMBitTest(g_Bs3Mem4KLow.Core.bmAllocated, i);
235 g_Bs3Mem4KLow.Core.cFreeChunks = cPages;
236
237 /*
238 * First 16 MB of memory above 1MB. We start out by marking it all allocated.
239 */
240 Bs3SlabInit(&g_Bs3Mem4KUpperTiled.Core, sizeof(g_Bs3Mem4KUpperTiled), _1M, BS3_SEL_TILED_AREA_SIZE - _1M, _4K);
241
242 ASMBitSetRange(g_Bs3Mem4KUpperTiled.Core.bmAllocated, 0, g_Bs3Mem4KUpperTiled.Core.cChunks);
243 g_Bs3Mem4KUpperTiled.Core.cFreeChunks = 0;
244
245 /* Ask the BIOS about where there's memory, and make pages in between 1MB
246 and BS3_SEL_TILED_AREA_SIZE present. This means we're only interested
247 in entries describing usable memory, ASSUMING of course no overlaps. */
248 if ( (g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386
249 && Bs3BiosInt15hE820_rm_far(&Entry, &cbEntry, &uCont))
250 {
251 unsigned i = 0;
252 do
253 {
254 if (Entry.uType == INT15E820_TYPE_USABLE)
255 {
256 if (!(Entry.uBaseAddr >> 32))
257 /* Convert from 64-bit to 32-bit value and record it. */
258 bs3InitMemoryAddRange32((uint32_t)Entry.uBaseAddr,
259 (Entry.cbRange >> 32) ? UINT32_C(0xfffff000) : (uint32_t)Entry.cbRange);
260 else
261 {
262 uint64_t uEnd = Entry.uBaseAddr + Entry.cbRange;
263 if (uEnd > g_uBs3EndOfRamAbove4G)
264 g_uBs3EndOfRamAbove4G = uEnd;
265 }
266 }
267
268 /* next */
269 Entry.uType = 0;
270 cbEntry = sizeof(Entry);
271 i++;
272 } while ( uCont != 0
273 && i < 2048
274 && Bs3BiosInt15hE820_rm_far(&Entry, &cbEntry, &uCont));
275 }
276 /* Try the 286+ API for getting memory above 1MB and (usually) below 16MB. */
277 else if ( (g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80286
278 && (u32 = Bs3BiosInt15h88()) != UINT32_MAX
279 && u32 > 0)
280 bs3InitMemoryAddRange32(_1M, u32 * _1K);
281
282 /*
283 * Check if we've got the VMMDev MMIO testing memory mapped above 1MB.
284 */
285 pu32Mmio = (uint32_t BS3_FAR *)BS3_FP_MAKE(VMMDEV_TESTING_MMIO_RM_SEL,
286 VMMDEV_TESTING_MMIO_RM_OFF2(VMMDEV_TESTING_MMIO_OFF_NOP));
287 if (*pu32Mmio == VMMDEV_TESTING_NOP_RET)
288 {
289 Bs3Printf("Memory: Found VMMDev MMIO testing region\n");
290 if (!ASMBitTestAndSet(g_Bs3Mem4KUpperTiled.Core.bmAllocated, 1))
291 g_Bs3Mem4KUpperTiled.Core.cFreeChunks--;
292
293 }
294
295 /*
296 * Initialize the slab lists.
297 */
298 for (i = 0; i < BS3_MEM_SLAB_LIST_COUNT; i++)
299 {
300 Bs3SlabListInit(&g_aBs3LowSlabLists[i], g_acbBs3SlabLists[i]);
301 Bs3SlabListInit(&g_aBs3UpperTiledSlabLists[i], g_acbBs3SlabLists[i]);
302 }
303
304#if 0
305 /*
306 * For debugging.
307 */
308 Bs3Printf("Memory-low: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KLow.Core.cFreeChunks, g_Bs3Mem4KLow.Core.cChunks);
309 for (i = 0; i < 20; i++)
310 Bs3Printf("%02x ", g_Bs3Mem4KLow.Core.bmAllocated[i]);
311 Bs3Printf("\n");
312 Bs3Printf("Memory-upt: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KUpperTiled.Core.cFreeChunks, g_Bs3Mem4KUpperTiled.Core.cChunks);
313 for (i = 0; i < 32; i++)
314 Bs3Printf("%02x ", g_Bs3Mem4KUpperTiled.Core.bmAllocated[i]);
315 Bs3Printf("...\n");
316#endif
317}
318
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