bs3-rm-InitMemory.c@ 61183

Last change on this file since 61183 was 60686, checked in by vboxsync, 9 years ago
bs3kit: Enabled full gdt base address loading (and testing).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.8 KB

Line
1	/* $Id: bs3-rm-InitMemory.c 60686 2016-04-25 12:51:41Z 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	#define BS3_USE_RM_TEXT_SEG 1
31	#include "bs3kit-template-header.h"
32	#include "bs3-cmn-memory.h"
33	#include <iprt/asm.h>
34
35
36	/*********************************************************************************************************************************
37	* Structures and Typedefs *
38	*********************************************************************************************************************************/
39
40	typedef struct INT15E820ENTRY
41	{
42	uint64_t uBaseAddr;
43	uint64_t cbRange;
44	/** Memory type this entry describes, see INT15E820_TYPE_XXX. */
45	uint32_t uType;
46	uint32_t fAcpi3;
47	} INT15E820ENTRY;
48	AssertCompileSize(INT15E820ENTRY,24);
49
50
51	/** @name INT15E820_TYPE_XXX - Memory types returned by int 15h function 0xe820.
52	* @{ */
53	#define INT15E820_TYPE_USABLE 1 /*< Usable RAM. /
54	#define INT15E820_TYPE_RESERVED 2 /*< Reserved by the system, unusable. /
55	#define INT15E820_TYPE_ACPI_RECLAIMABLE 3 /*< ACPI reclaimable memory, whatever that means. /
56	#define INT15E820_TYPE_ACPI_NVS 4 /*< ACPI non-volatile storage? /
57	#define INT15E820_TYPE_BAD 5 /*< Bad memory, unusable. /
58	/** @} */
59
60
61	/**
62	* Performs a int 15h function 0xe820 call.
63	*
64	* @returns Continuation value on success, 0 on failure.
65	* (Because of the way the API works, EBX should never be zero when
66	* data is returned.)
67	* @param pEntry The return buffer.
68	* @param cbEntry The size of the buffer (min 20 bytes).
69	* @param uContinuationValue Zero the first time, the return value from the
70	* previous call after that.
71	*/
72	BS3_DECL(uint32_t) Bs3BiosInt15hE820(INT15E820ENTRY BS3_FAR *pEntry, size_t cbEntry, uint32_t uContinuationValue);
73	#pragma aux Bs3BiosInt15hE820 = \
74	".386" \
75	"shl ebx, 10h" \
76	"mov bx, ax" /* ebx = continutation */ \
77	"movzx ecx, cx" \
78	"movzx edi, di" \
79	"mov edx, 0534d4150h" /SMAP/ \
80	"mov eax, 0xe820" \
81	"int 15h" \
82	"jc failed" \
83	"cmp eax, 0534d4150h" \
84	"jne failed" \
85	"cmp cx, 20" \
86	"jb failed" \
87	"mov ax, bx" \
88	"shr ebx, 10h" /* ax:bx = continuation */ \
89	"jmp done" \
90	"failed:" \
91	"xor ax, ax" \
92	"xor bx, bx" \
93	"done:" \
94	parm [es di] [cx] [ax bx] \
95	value [ax bx] \
96	modify exact [ax bx cx dx di es];
97
98	/**
99	* Performs a int 15h function 0x88 call.
100	*
101	* @returns UINT32_MAX on failure, number of KBs above 1MB otherwise.
102	*/
103	BS3_DECL(uint32_t) Bs3BiosInt15h88(void);
104	#pragma aux Bs3BiosInt15h88 = \
105	".286" \
106	"clc" \
107	"mov ax, 08800h" \
108	"int 15h" \
109	"jc failed" \
110	"xor dx, dx" \
111	"jmp done" \
112	"failed:" \
113	"xor ax, ax" \
114	"dec ax" \
115	"mov dx, ax" \
116	"done:" \
117	value [ax dx] \
118	modify exact [ax bx cx dx es];
119
120
121	/*********************************************************************************************************************************
122	* Global Variables *
123	*********************************************************************************************************************************/
124	/** Slab control structure for the 4K management of low memory (< 1MB). */
125	BS3SLABCTLLOW g_Bs3Mem4KLow;
126	/** Slab control structure for the 4K management of tiled upper memory,
127	* between 1 MB and 16MB. */
128	BS3SLABCTLUPPERTILED g_Bs3Mem4KUpperTiled;
129
130
131	/** Translates a power of two request size to an slab list index. */
132	uint8_t const g_aiBs3SlabListsByPowerOfTwo[12] =
133	{
134	/* 2^0 = 1 */ 0,
135	/* 2^1 = 2 */ 0,
136	/* 2^2 = 4 */ 0,
137	/* 2^3 = 8 */ 0,
138	/* 2^4 = 16 */ 0,
139	/* 2^5 = 32 */ 1,
140	/* 2^6 = 64 */ 2,
141	/* 2^7 = 128 */ 3,
142	/* 2^8 = 256 */ 4,
143	/* 2^9 = 512 */ 5,
144	/* 2^10 = 1024 */ -1
145	/* 2^11 = 2048 */ -1
146	};
147
148	/** The slab list chunk sizes. */
149	uint16_t const g_acbBs3SlabLists[BS3_MEM_SLAB_LIST_COUNT] =
150	{
151	16,
152	32,
153	64,
154	128,
155	256,
156	512,
157	};
158
159	/** Low memory slab lists, sizes given by g_acbBs3SlabLists. */
160	BS3SLABHEAD g_aBs3LowSlabLists[BS3_MEM_SLAB_LIST_COUNT];
161	/** Upper tiled memory slab lists, sizes given by g_acbBs3SlabLists. */
162	BS3SLABHEAD g_aBs3UpperTiledSlabLists[BS3_MEM_SLAB_LIST_COUNT];
163
164	/** Slab control structure sizes for the slab lists.
165	* This is to help the allocator when growing a list. */
166	uint16_t const g_cbBs3SlabCtlSizesforLists[BS3_MEM_SLAB_LIST_COUNT] =
167	{
168	RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 16 / 8 /=32/), 16),
169	RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 32 / 8 /=16/), 32),
170	RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 64 / 8 /=8/), 64),
171	RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 128 / 8 /=4/), 128),
172	RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 256 / 8 /=2/), 256),
173	RT_ALIGN(sizeof(BS3SLABCTL) - 4 + (4096 / 512 / 8 /=1/), 512),
174	};
175
176
177	/** The last RAM address below 4GB (approximately). */
178	uint32_t g_uBs3EndOfRamBelow4G = 0;
179
180
181
182	/**
183	* Adds a range of memory to the tiled slabs.
184	*
185	* @param uRange Start of range.
186	* @param cbRange Size of range.
187	*/
188	static void bs3InitMemoryAddRange32(uint32_t uRange, uint32_t cbRange)
189	{
190	uint32_t uRangeEnd = uRange + cbRange;
191	if (uRangeEnd < uRange)
192	uRangeEnd = UINT32_MAX;
193
194	/* Raise the end-of-ram-below-4GB marker? */
195	if (uRangeEnd > g_uBs3EndOfRamBelow4G)
196	g_uBs3EndOfRamBelow4G = uRangeEnd;
197
198	/* Applicable to tiled memory? */
199	if ( uRange < BS3_SEL_TILED_AREA_SIZE
200	&& ( uRange >= _1M
201	\|\| uRangeEnd >= _1M))
202	{
203	uint16_t cPages;
204
205	/* Adjust the start of the range such that it's at or above 1MB and page aligned. */
206	if (uRange < _1M)
207	{
208	cbRange -= _1M - uRange;
209	uRange = _1M;
210	}
211	else if (uRange & (_4K - 1U))
212	{
213	cbRange -= uRange & (_4K - 1U);
214	uRange = RT_ALIGN_32(uRange, _4K);
215	}
216
217	/* Adjust the end/size of the range such that it's page aligned and not beyond the tiled area. */
218	if (uRangeEnd > BS3_SEL_TILED_AREA_SIZE)
219	{
220	cbRange -= uRangeEnd - BS3_SEL_TILED_AREA_SIZE;
221	uRangeEnd = BS3_SEL_TILED_AREA_SIZE;
222	}
223	else if (uRangeEnd & (_4K - 1U))
224	{
225	cbRange -= uRangeEnd & (_4K - 1U);
226	uRangeEnd &= ~(uint32_t)(_4K - 1U);
227	}
228
229	/* If there is still something, enable it.
230	(We're a bit paranoid here don't trust the BIOS to only report a page once.) */
231	cPages = cbRange >> 12; /div 4K/
232	if (cPages)
233	{
234	unsigned i;
235	uRange -= _1M;
236	i = uRange >> 12; /div _4K/
237	while (cPages-- > 0)
238	{
239	uint16_t uLineToLong = ASMBitTestAndClear(g_Bs3Mem4KUpperTiled.Core.bmAllocated, i);
240	g_Bs3Mem4KUpperTiled.Core.cFreeChunks += uLineToLong;
241	i++;
242	}
243	}
244	}
245	}
246
247
248	BS3_DECL(void) BS3_FAR_CODE Bs3InitMemory_rm_far(void)
249	{
250	uint16_t i;
251	uint16_t cPages;
252	uint32_t u32;
253	INT15E820ENTRY Entry;
254
255	/*
256	* Enable the A20 gate.
257	*/
258	Bs3A20Enable();
259
260	/*
261	* Low memory (4K chunks).
262	* - 0x00000 to 0x004ff - Interrupt Vector table, BIOS data area.
263	* - 0x01000 to 0x0ffff - Stacks.
264	* - 0x10000 to 0x1yyyy - BS3TEXT16
265	* - 0x20000 to 0x26fff - BS3SYSTEM16
266	* - 0x29000 to 0xzzzzz - BS3DATA16, BS3TEXT32, BS3TEXT64, BS3DATA32, BS3DATA64 (in that order).
267	* - 0xzzzzZ to 0x9fdff - Free conventional memory.
268	* - 0x9fc00 to 0x9ffff - Extended BIOS data area (exact start may vary).
269	* - 0xa0000 to 0xbffff - VGA MMIO
270	* - 0xc0000 to 0xc7fff - VGA BIOS
271	* - 0xc8000 to 0xeffff - ROMs, tables, unusable.
272	* - 0xf0000 to 0xfffff - PC BIOS.
273	*/
274	Bs3SlabInit(&g_Bs3Mem4KLow.Core, sizeof(g_Bs3Mem4KLow), 0 /uFlatSlabPtr/, 0xA0000 /* 640 KB*/, _4K);
275
276	/* Mark the stacks and whole image as allocated. */
277	cPages = (Bs3TotalImageSize + _4K - 1U) >> 12;
278	ASMBitSetRange(g_Bs3Mem4KLow.Core.bmAllocated, 0, 0x10 + cPages);
279
280	/* Mark any unused pages between BS3TEXT16 and BS3SYSTEM16 as free. */
281	cPages = (Bs3Text16_Size + _4K - 1U) >> 12;
282	ASMBitClearRange(g_Bs3Mem4KLow.Core.bmAllocated, 0x10U + cPages, 0x20U);
283
284	/* In case the system has less than 640KB of memory, check the BDA variable for it. */
285	cPages = (uint16_t BS3_FAR )BS3_FP_MAKE(0x0000, 0x0413); /* KB of low memory */
286	if (cPages < 640)
287	{
288	cPages = 640 - cPages;
289	cPages = RT_ALIGN(cPages, 4);
290	cPages >>= 2;
291	ASMBitSetRange(g_Bs3Mem4KLow.Core.bmAllocated, 0xA0 - cPages, 0xA0);
292	}
293	else
294	ASMBitSet(g_Bs3Mem4KLow.Core.bmAllocated, 0x9F);
295
296	/* Recalc free pages. */
297	cPages = 0;
298	i = g_Bs3Mem4KLow.Core.cChunks;
299	while (i-- > 0)
300	cPages += !ASMBitTest(g_Bs3Mem4KLow.Core.bmAllocated, i);
301	g_Bs3Mem4KLow.Core.cFreeChunks = cPages;
302
303	/*
304	* First 16 MB of memory above 1MB. We start out by marking it all allocated.
305	*/
306	Bs3SlabInit(&g_Bs3Mem4KUpperTiled.Core, sizeof(g_Bs3Mem4KUpperTiled), _1M, BS3_SEL_TILED_AREA_SIZE - _1M, _4K);
307
308	ASMBitSetRange(g_Bs3Mem4KUpperTiled.Core.bmAllocated, 0, g_Bs3Mem4KUpperTiled.Core.cChunks);
309	g_Bs3Mem4KUpperTiled.Core.cFreeChunks = 0;
310
311	/* Ask the BIOS about where there's memory, and make pages in between 1MB
312	and BS3_SEL_TILED_AREA_SIZE present. This means we're only interested
313	in entries describing usable memory, ASSUMING of course no overlaps. */
314	if ( (g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386
315	&& Bs3BiosInt15hE820(&Entry, sizeof(Entry), 0) != 0)
316	{
317	uint32_t uCont = 0;
318	i = 0;
319	while ( (uCont = Bs3BiosInt15hE820(&Entry, sizeof(Entry), uCont)) != 0
320	&& i++ < 2048)
321	if (Entry.uType == INT15E820_TYPE_USABLE)
322	if (!(Entry.uBaseAddr >> 32))
323	/* Convert from 64-bit to 32-bit value and record it. */
324	bs3InitMemoryAddRange32((uint32_t)Entry.uBaseAddr,
325	(Entry.cbRange >> 32) ? UINT32_C(0xfffff000) : (uint32_t)Entry.cbRange);
326	}
327	/* Try the 286+ API for getting memory above 1MB and (usually) below 16MB. */
328	else if ( (g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386
329	&& (u32 = Bs3BiosInt15h88()) != UINT32_MAX
330	&& u32 > 0)
331	bs3InitMemoryAddRange32(_1M, u32 * _1K);
332
333	/*
334	* Initialize the slab lists.
335	*/
336	for (i = 0; i < BS3_MEM_SLAB_LIST_COUNT; i++)
337	{
338	Bs3SlabListInit(&g_aBs3LowSlabLists[i], g_acbBs3SlabLists[i]);
339	Bs3SlabListInit(&g_aBs3UpperTiledSlabLists[i], g_acbBs3SlabLists[i]);
340	}
341
342	#if 0
343	/*
344	* For debugging.
345	*/
346	Bs3Printf("Memory-low: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KLow.Core.cFreeChunks, g_Bs3Mem4KLow.Core.cChunks);
347	for (i = 0; i < 20; i++)
348	Bs3Printf("%02x ", g_Bs3Mem4KLow.Core.bmAllocated[i]);
349	Bs3Printf("\n");
350	Bs3Printf("Memory-upt: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KUpperTiled.Core.cFreeChunks, g_Bs3Mem4KUpperTiled.Core.cChunks);
351	for (i = 0; i < 32; i++)
352	Bs3Printf("%02x ", g_Bs3Mem4KUpperTiled.Core.bmAllocated[i]);
353	Bs3Printf("...\n");
354	#endif
355	}
356

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: