bs3-rm-InitMemory.c@ 60676

Last change on this file since 60676 was 60578, checked in by vboxsync, 9 years ago
bs3kit: made it easier to move 16-bit templated C code to other segments.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 13.0 KB

Line
1	/* $Id: bs3-rm-InitMemory.c 60578 2016-04-19 15:26:34Z 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	/**
178	* Adds a range of memory to the tiled slabs.
179	*
180	* @param uRange Start of range.
181	* @param cbRange Size of range.
182	*/
183	static void bs3InitMemoryAddRange(uint32_t uRange, uint32_t cbRange)
184	{
185	if (uRange < BS3_SEL_TILED_AREA_SIZE)
186	{
187	uint32_t uRangeEnd = uRange + cbRange;
188	if ( uRange >= _1M
189	\|\| uRangeEnd > _1M)
190	{
191	uint16_t cPages;
192
193	/* Adjust the start of the range such that it's at or above 1MB and page aligned. */
194	if (uRange < _1M)
195	{
196	cbRange -= _1M - uRange;
197	uRange = _1M;
198	}
199	else if (uRange & (_4K - 1U))
200	{
201	cbRange -= uRange & (_4K - 1U);
202	uRange = RT_ALIGN_32(uRange, _4K);
203	}
204
205	/* Adjust the end/size of the range such that it's page aligned and not beyond the tiled area. */
206	if (uRangeEnd > BS3_SEL_TILED_AREA_SIZE)
207	{
208	cbRange -= uRangeEnd - BS3_SEL_TILED_AREA_SIZE;
209	uRangeEnd = BS3_SEL_TILED_AREA_SIZE;
210	}
211	else if (uRangeEnd & (_4K - 1U))
212	{
213	cbRange -= uRangeEnd & (_4K - 1U);
214	uRangeEnd &= ~(uint32_t)(_4K - 1U);
215	}
216
217	/* If there is still something, enable it.
218	(We're a bit paranoid here don't trust the BIOS to only report a page once.) */
219	cPages = cbRange >> 12; /div 4K/
220	if (cPages)
221	{
222	unsigned i;
223	uRange -= _1M;
224	i = uRange >> 12; /div _4K/
225	while (cPages-- > 0)
226	{
227	uint16_t uLineToLong = ASMBitTestAndClear(g_Bs3Mem4KUpperTiled.Core.bmAllocated, i);
228	g_Bs3Mem4KUpperTiled.Core.cFreeChunks += uLineToLong;
229	i++;
230	}
231	}
232	}
233	}
234	}
235
236
237	BS3_DECL(void) BS3_FAR_CODE Bs3InitMemory_rm_far(void)
238	{
239	uint16_t i;
240	uint16_t cPages;
241	uint32_t u32;
242	INT15E820ENTRY Entry;
243
244	/*
245	* Enable the A20 gate.
246	*/
247	Bs3A20Enable();
248
249	/*
250	* Low memory (4K chunks).
251	* - 0x00000 to 0x004ff - Interrupt Vector table, BIOS data area.
252	* - 0x01000 to 0x0ffff - Stacks.
253	* - 0x10000 to 0x1yyyy - BS3TEXT16
254	* - 0x20000 to 0x26fff - BS3SYSTEM16
255	* - 0x29000 to 0xzzzzz - BS3DATA16, BS3TEXT32, BS3TEXT64, BS3DATA32, BS3DATA64 (in that order).
256	* - 0xzzzzZ to 0x9fdff - Free conventional memory.
257	* - 0x9fc00 to 0x9ffff - Extended BIOS data area (exact start may vary).
258	* - 0xa0000 to 0xbffff - VGA MMIO
259	* - 0xc0000 to 0xc7fff - VGA BIOS
260	* - 0xc8000 to 0xeffff - ROMs, tables, unusable.
261	* - 0xf0000 to 0xfffff - PC BIOS.
262	*/
263	Bs3SlabInit(&g_Bs3Mem4KLow.Core, sizeof(g_Bs3Mem4KLow), 0 /uFlatSlabPtr/, 0xA0000 /* 640 KB*/, _4K);
264
265	/* Mark the stacks and whole image as allocated. */
266	cPages = (Bs3TotalImageSize + _4K - 1U) >> 12;
267	ASMBitSetRange(g_Bs3Mem4KLow.Core.bmAllocated, 0, 0x10 + cPages);
268
269	/* Mark any unused pages between BS3TEXT16 and BS3SYSTEM16 as free. */
270	cPages = (Bs3Text16_Size + _4K - 1U) >> 12;
271	ASMBitClearRange(g_Bs3Mem4KLow.Core.bmAllocated, 0x10U + cPages, 0x20U);
272
273	/* In case the system has less than 640KB of memory, check the BDA variable for it. */
274	cPages = (uint16_t BS3_FAR )BS3_FP_MAKE(0x0000, 0x0413); /* KB of low memory */
275	if (cPages < 640)
276	{
277	cPages = 640 - cPages;
278	cPages = RT_ALIGN(cPages, 4);
279	cPages >>= 2;
280	ASMBitSetRange(g_Bs3Mem4KLow.Core.bmAllocated, 0xA0 - cPages, 0xA0);
281	}
282	else
283	ASMBitSet(g_Bs3Mem4KLow.Core.bmAllocated, 0x9F);
284
285	/* Recalc free pages. */
286	cPages = 0;
287	i = g_Bs3Mem4KLow.Core.cChunks;
288	while (i-- > 0)
289	cPages += !ASMBitTest(g_Bs3Mem4KLow.Core.bmAllocated, i);
290	g_Bs3Mem4KLow.Core.cFreeChunks = cPages;
291
292	/*
293	* First 16 MB of memory above 1MB. We start out by marking it all allocated.
294	*/
295	Bs3SlabInit(&g_Bs3Mem4KUpperTiled.Core, sizeof(g_Bs3Mem4KUpperTiled), _1M, BS3_SEL_TILED_AREA_SIZE - _1M, _4K);
296
297	ASMBitSetRange(g_Bs3Mem4KUpperTiled.Core.bmAllocated, 0, g_Bs3Mem4KUpperTiled.Core.cChunks);
298	g_Bs3Mem4KUpperTiled.Core.cFreeChunks = 0;
299
300	/* Ask the BIOS about where there's memory, and make pages in between 1MB
301	and BS3_SEL_TILED_AREA_SIZE present. This means we're only interested
302	in entries describing usable memory, ASSUMING of course no overlaps. */
303	if ( (g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386
304	&& Bs3BiosInt15hE820(&Entry, sizeof(Entry), 0) != 0)
305	{
306	uint32_t uCont = 0;
307	i = 0;
308	while ( (uCont = Bs3BiosInt15hE820(&Entry, sizeof(Entry), uCont)) != 0
309	&& i++ < 2048)
310	{
311	if ( Entry.uType == INT15E820_TYPE_USABLE
312	&& Entry.uBaseAddr < BS3_SEL_TILED_AREA_SIZE)
313	{
314	/* Entry concerning tiled memory. Convert from 64-bit to 32-bit
315	values and check whether it's concerning anything at or above 1MB */
316	uint32_t uRange = (uint32_t)Entry.uBaseAddr;
317	uint32_t cbRange = Entry.cbRange >= BS3_SEL_TILED_AREA_SIZE
318	? BS3_SEL_TILED_AREA_SIZE : (uint32_t)Entry.cbRange;
319	AssertCompile(BS3_SEL_TILED_AREA_SIZE <= _512M /* the range of 16-bit cPages. */ );
320	bs3InitMemoryAddRange(uRange, cbRange);
321	}
322	}
323	}
324	/* Try the 286+ API for getting memory above 1MB and (usually) below 16MB. */
325	else if ( (g_uBs3CpuDetected & BS3CPU_TYPE_MASK) >= BS3CPU_80386
326	&& (u32 = Bs3BiosInt15h88()) != UINT32_MAX
327	&& u32 > 0)
328	bs3InitMemoryAddRange(_1M, u32 * _1K);
329
330	/*
331	* Initialize the slab lists.
332	*/
333	for (i = 0; i < BS3_MEM_SLAB_LIST_COUNT; i++)
334	{
335	Bs3SlabListInit(&g_aBs3LowSlabLists[i], g_acbBs3SlabLists[i]);
336	Bs3SlabListInit(&g_aBs3UpperTiledSlabLists[i], g_acbBs3SlabLists[i]);
337	}
338
339	#if 0
340	/*
341	* For debugging.
342	*/
343	Bs3Printf("Memory-low: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KLow.Core.cFreeChunks, g_Bs3Mem4KLow.Core.cChunks);
344	for (i = 0; i < 20; i++)
345	Bs3Printf("%02x ", g_Bs3Mem4KLow.Core.bmAllocated[i]);
346	Bs3Printf("\n");
347	Bs3Printf("Memory-upt: %u/%u chunks bmAllocated[]=", g_Bs3Mem4KUpperTiled.Core.cFreeChunks, g_Bs3Mem4KUpperTiled.Core.cChunks);
348	for (i = 0; i < 32; i++)
349	Bs3Printf("%02x ", g_Bs3Mem4KUpperTiled.Core.bmAllocated[i]);
350	Bs3Printf("...\n");
351	#endif
352	}
353

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

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

Download in other formats: