[mvdm] Fix missing pointer dereference
[reactos.git] / subsystems / mvdm / ntvdm / bios / umamgr.c
1 /*
2 * COPYRIGHT: GPLv2+ - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: subsystems/mvdm/ntvdm/bios/umamgr.c
5 * PURPOSE: Upper Memory Area Manager
6 * PROGRAMMERS: Hermes Belusca-Maito (hermes.belusca@sfr.fr)
7 *
8 * NOTE: The UMA Manager is used by the DOS XMS Driver (UMB Provider part),
9 * indirectly by the DOS EMS Driver, and by VDD memory management functions.
10 */
11
12 /* INCLUDES *******************************************************************/
13
14 #include "ntvdm.h"
15
16 #define NDEBUG
17 #include <debug.h>
18
19 #include "emulator.h"
20 #include "memory.h"
21
22 #include "umamgr.h"
23
24 /* PRIVATE VARIABLES **********************************************************/
25
26 typedef struct _UMA_DESCRIPTOR
27 {
28 LIST_ENTRY Entry;
29 ULONG Start;
30 ULONG Size;
31 UMA_DESC_TYPE Type;
32 } UMA_DESCRIPTOR, *PUMA_DESCRIPTOR;
33
34 /*
35 * Sorted list of UMA descriptors.
36 *
37 * The descriptor list is (and must always be) sorted by memory addresses,
38 * and all consecutive free descriptors are always merged together, so that
39 * free ones are always separated from each other by descriptors of other types.
40 *
41 * TODO: Add the fact that no blocks of size == 0 are allowed.
42 */
43 static LIST_ENTRY UmaDescriptorList = { &UmaDescriptorList, &UmaDescriptorList };
44
45 /* PRIVATE FUNCTIONS **********************************************************/
46
47 static PUMA_DESCRIPTOR
48 CreateUmaDescriptor(IN OUT PLIST_ENTRY ListHead,
49 IN ULONG Address,
50 IN ULONG Size,
51 IN UMA_DESC_TYPE Type)
52 {
53 PUMA_DESCRIPTOR UmaDesc;
54
55 ASSERT(Size > 0);
56
57 UmaDesc = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*UmaDesc));
58 if (!UmaDesc) return NULL;
59
60 UmaDesc->Start = Address;
61 UmaDesc->Size = Size;
62 UmaDesc->Type = Type;
63
64 /*
65 * We use the trick of http://www.osronline.com/article.cfm?article=499 to insert
66 * the new descriptor just after the current entry that we specify via 'ListHead'.
67 * If 'ListHead' is NULL then we insert the descriptor at the tail of 'UmaDescriptorList'
68 * (which is equivalent to inserting it at the head of 'UmaDescriptorList.Blink').
69 */
70 if (ListHead == NULL) ListHead = UmaDescriptorList.Blink;
71 InsertHeadList(ListHead, &UmaDesc->Entry);
72
73 return UmaDesc;
74 }
75
76 static VOID FreeUmaDescriptor(PUMA_DESCRIPTOR UmaDesc)
77 {
78 RemoveEntryList(&UmaDesc->Entry);
79 RtlFreeHeap(RtlGetProcessHeap(), 0, UmaDesc);
80 }
81
82 /* PUBLIC FUNCTIONS ***********************************************************/
83
84 BOOLEAN UmaDescReserve(IN OUT PUSHORT Segment, IN OUT PUSHORT Size)
85 {
86 ULONG Address = (*Segment << 4); // Convert segment number into address.
87 ULONG RequestSize = (*Size << 4); // Convert size in paragraphs into size in bytes.
88 ULONG MaxSize = 0;
89 PLIST_ENTRY Entry;
90 PUMA_DESCRIPTOR UmaDesc, NewUmaDesc;
91 PUMA_DESCRIPTOR FoundUmaDesc = NULL;
92
93 // FIXME: Check! What to do?
94 if (RequestSize == 0) DPRINT1("Requesting UMA descriptor with null size?!\n");
95
96 Entry = UmaDescriptorList.Flink;
97 while (Entry != &UmaDescriptorList)
98 {
99 UmaDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(Entry, UMA_DESCRIPTOR, Entry);
100 Entry = Entry->Flink;
101
102 /* Only check free descriptors */
103 if (UmaDesc->Type != UMA_FREE) continue;
104
105 /* Update the maximum descriptor size */
106 if (UmaDesc->Size > MaxSize) MaxSize = UmaDesc->Size;
107
108 /* Descriptor too small, continue... */
109 if (UmaDesc->Size < RequestSize) continue;
110
111 /* Do we want to reserve the descriptor at a precise address? */
112 if (Address)
113 {
114 /* If the descriptor ends before the desired region, try again */
115 if (UmaDesc->Start + UmaDesc->Size <= Address) continue;
116
117 /*
118 * If we have a descriptor, but one of its boundaries crosses the
119 * desired region (it starts after the desired region, or ends
120 * before the end of the desired region), this means that there
121 * is already something inside the region, so that we cannot
122 * allocate the region here. Bail out.
123 */
124 if (UmaDesc->Start > Address ||
125 UmaDesc->Start + UmaDesc->Size < Address + RequestSize)
126 {
127 goto Fail;
128 }
129
130 /* We now have a free descriptor that overlaps our desired region: split it */
131
132 /*
133 * Here, UmaDesc->Start == Address or UmaDesc->Start < Address,
134 * in which case we need to split the descriptor to the left.
135 */
136 if (UmaDesc->Start < Address)
137 {
138 /* Create a new free descriptor and insert it after the current one */
139 NewUmaDesc = CreateUmaDescriptor(&UmaDesc->Entry,
140 Address,
141 UmaDesc->Size - (Address - UmaDesc->Start),
142 UmaDesc->Type); // UMA_FREE
143 if (!NewUmaDesc)
144 {
145 DPRINT1("CreateUmaDescriptor failed, UMA descriptor list possibly corrupted!\n");
146 goto Fail;
147 }
148
149 /* Reduce the size of the splitted left descriptor */
150 UmaDesc->Size = (Address - UmaDesc->Start);
151
152 /* Current descriptor is now the new created one */
153 UmaDesc = NewUmaDesc;
154 }
155
156 /* Here, UmaDesc->Start == Address */
157 }
158
159 /* Descriptor of large enough size: split it to the right if needed */
160 // FIXME: It might be needed to consider a minimum size starting which we need to split.
161 // if (UmaDesc->Size - RequestSize > (3 << 4))
162 if (UmaDesc->Size > RequestSize)
163 {
164 /*
165 * Create a new free descriptor and insert it after the current one.
166 * Because consecutive free descriptors are always merged together,
167 * the descriptor following 'UmaDesc' cannot be free, so that this
168 * new free descriptor does not need to be merged with some others.
169 */
170 NewUmaDesc = CreateUmaDescriptor(&UmaDesc->Entry,
171 UmaDesc->Start + RequestSize,
172 UmaDesc->Size - RequestSize,
173 UmaDesc->Type); // UMA_FREE
174 if (!NewUmaDesc)
175 {
176 DPRINT1("CreateUmaDescriptor failed, UMA descriptor list possibly corrupted!\n");
177 goto Fail;
178 }
179
180 /* Reduce the size of the splitted left descriptor */
181 UmaDesc->Size = RequestSize;
182 }
183
184 /* We have a descriptor of correct size, initialize it */
185 UmaDesc->Type = UMA_UMB;
186 FoundUmaDesc = UmaDesc;
187 break;
188 }
189
190 if (FoundUmaDesc)
191 {
192 /* Returned address is a segment and size is in paragraphs */
193 *Segment = (FoundUmaDesc->Start >> 4);
194 *Size = (FoundUmaDesc->Size >> 4);
195 return TRUE;
196 }
197 else
198 {
199 Fail:
200 /* Returned address is a segment and size is in paragraphs */
201 *Segment = 0x0000;
202 *Size = (MaxSize >> 4);
203 return FALSE;
204 }
205 }
206
207 BOOLEAN UmaDescRelease(IN USHORT Segment)
208 {
209 ULONG Address = (Segment << 4); // Convert segment number into address.
210 PLIST_ENTRY Entry, PrevEntry, NextEntry;
211 PUMA_DESCRIPTOR UmaDesc, PrevDesc = NULL, NextDesc = NULL;
212 PUMA_DESCRIPTOR FoundUmaDesc = NULL;
213
214 Entry = UmaDescriptorList.Flink;
215 while (Entry != &UmaDescriptorList)
216 {
217 UmaDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(Entry, UMA_DESCRIPTOR, Entry);
218 Entry = Entry->Flink;
219
220 /* Search for the descriptor in the list */
221 if (UmaDesc->Start == Address && UmaDesc->Type == UMA_UMB)
222 {
223 /* We found it */
224 FoundUmaDesc = UmaDesc;
225 break;
226 }
227 }
228
229 if (FoundUmaDesc)
230 {
231 FoundUmaDesc->Type = UMA_FREE;
232
233 /* Combine free descriptors adjacent to this one */
234 PrevEntry = FoundUmaDesc->Entry.Blink;
235 NextEntry = FoundUmaDesc->Entry.Flink;
236
237 if (PrevEntry != &UmaDescriptorList)
238 PrevDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(PrevEntry, UMA_DESCRIPTOR, Entry);
239 if (NextEntry != &UmaDescriptorList)
240 NextDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(NextEntry, UMA_DESCRIPTOR, Entry);
241
242 if (NextDesc && NextDesc->Type == FoundUmaDesc->Type) // UMA_FREE
243 {
244 FoundUmaDesc->Size += NextDesc->Size;
245 FreeUmaDescriptor(NextDesc);
246 }
247
248 if (PrevDesc && PrevDesc->Type == FoundUmaDesc->Type) // UMA_FREE
249 {
250 PrevDesc->Size += FoundUmaDesc->Size;
251 FreeUmaDescriptor(FoundUmaDesc);
252 }
253
254 return TRUE;
255 }
256
257 return FALSE;
258 }
259
260 BOOLEAN UmaDescReallocate(IN USHORT Segment, IN OUT PUSHORT Size)
261 {
262 ULONG Address = (Segment << 4); // Convert segment number into address.
263 ULONG RequestSize = (*Size << 4); // Convert size in paragraphs into size in bytes.
264 ULONG MaxSize = 0;
265 PLIST_ENTRY Entry, NextEntry;
266 PUMA_DESCRIPTOR UmaDesc, NextDesc = NULL, NewUmaDesc;
267 PUMA_DESCRIPTOR FoundUmaDesc = NULL;
268
269 // FIXME: Check! What to do?
270 if (RequestSize == 0) DPRINT1("Resizing UMA descriptor %04X to null size?!\n", Segment);
271
272 Entry = UmaDescriptorList.Flink;
273 while (Entry != &UmaDescriptorList)
274 {
275 UmaDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(Entry, UMA_DESCRIPTOR, Entry);
276 Entry = Entry->Flink;
277
278 /* Only get the maximum size of free descriptors */
279 if (UmaDesc->Type == UMA_FREE)
280 {
281 /* Update the maximum descriptor size */
282 if (UmaDesc->Size > MaxSize) MaxSize = UmaDesc->Size;
283 }
284
285 /* Search for the descriptor in the list */
286 if (UmaDesc->Start == Address && UmaDesc->Type == UMA_UMB)
287 {
288 /* We found it */
289 FoundUmaDesc = UmaDesc;
290 break;
291 }
292 }
293
294 if (FoundUmaDesc)
295 {
296 /* If we do not resize anything, just quit with success */
297 if (FoundUmaDesc->Size == RequestSize) goto Success;
298
299 NextEntry = FoundUmaDesc->Entry.Flink;
300
301 if (NextEntry != &UmaDescriptorList)
302 NextDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(NextEntry, UMA_DESCRIPTOR, Entry);
303
304 /* Check for reduction or enlargement */
305 if (FoundUmaDesc->Size > RequestSize)
306 {
307 /* Reduction */
308
309 /*
310 * Check if the next descriptor is free, in which case we
311 * extend it, otherwise we create a new free descriptor.
312 */
313 if (NextDesc && NextDesc->Type == UMA_FREE)
314 {
315 /* Yes it is, expand its size and move it down */
316 NextDesc->Size += (FoundUmaDesc->Size - RequestSize);
317 NextDesc->Start -= (FoundUmaDesc->Size - RequestSize);
318 }
319 else
320 {
321 // FIXME: It might be needed to consider a minimum size starting which we need to split.
322 // if (FoundUmaDesc->Size - RequestSize > (3 << 4))
323
324 /* Create a new free descriptor and insert it after the current one */
325 NewUmaDesc = CreateUmaDescriptor(&FoundUmaDesc->Entry,
326 FoundUmaDesc->Start + RequestSize,
327 FoundUmaDesc->Size - RequestSize,
328 FoundUmaDesc->Type);
329 if (!NewUmaDesc)
330 {
331 DPRINT1("CreateUmaDescriptor failed, UMA descriptor list possibly corrupted!\n");
332 MaxSize = 0;
333 goto Fail;
334 }
335 }
336 }
337 else // if (FoundUmaDesc->Size <= RequestSize)
338 {
339 /* Enlargement */
340
341 /* Check whether the next descriptor is free and large enough for merging */
342 if (NextDesc && NextDesc->Type == UMA_FREE &&
343 FoundUmaDesc->Size + NextDesc->Size >= RequestSize)
344 {
345 /* Yes it is, reduce its size and move it up, and enlarge the reallocated descriptor */
346 NextDesc->Size -= (RequestSize - FoundUmaDesc->Size);
347 NextDesc->Start += (RequestSize - FoundUmaDesc->Size);
348
349 if (NextDesc->Size == 0) FreeUmaDescriptor(NextDesc);
350 }
351 else
352 {
353 MaxSize = 0;
354 goto Fail;
355 }
356 }
357
358 /* Finally, resize the descriptor */
359 FoundUmaDesc->Size = RequestSize;
360
361 Success:
362 /* Returned size is in paragraphs */
363 *Size = (FoundUmaDesc->Size >> 4);
364 return TRUE;
365 }
366 else
367 {
368 Fail:
369 /* Returned size is in paragraphs */
370 *Size = (MaxSize >> 4);
371 return FALSE;
372 }
373 }
374
375 BOOLEAN UmaMgrInitialize(VOID)
376 {
377 // See bios/rom.h
378 #define ROM_AREA_START 0xE0000
379 #define ROM_AREA_END 0xFFFFF
380
381 #define OPTION_ROM_SIGNATURE 0xAA55
382
383 PUMA_DESCRIPTOR UmaDesc = NULL;
384 ULONG StartAddress = 0;
385 ULONG Size = 0;
386 UMA_DESC_TYPE Type = UMA_FREE;
387
388 UINT i;
389
390 ULONG Start, End;
391 ULONG Increment;
392
393 ULONG Address;
394
395 // ULONG RomStart[] = {};
396 // ULONG RomEnd[] = {};
397 ULONG RomBoundaries[] = {0xA0000, 0xC0000, /*0xC8000, 0xE0000,*/ 0xF0000, 0x100000};
398 ULONG SizeIncrement[] = {0x20000, 0x00800, /*0x00800, 0x10000,*/ 0x10000, 0x0000 };
399
400 // InitializeListHead(&UmaDescriptorList);
401
402 /* NOTE: There must be always one UMA descriptor at least */
403 // FIXME: Maybe it should be a static object?
404
405 for (i = 0; i < ARRAYSIZE(RomBoundaries) - 1; i++)
406 {
407 Start = RomBoundaries[i]; // RomStart[i]
408 End = RomBoundaries[i+1]; // RomEnd[i]
409 Increment = SizeIncrement[i];
410
411 for (Address = Start; Address < End; Address += Increment)
412 {
413 if (StartAddress == 0)
414 {
415 /* Initialize data for a new descriptor */
416 StartAddress = Address;
417 Size = 0;
418 Type = UMA_FREE;
419 }
420
421 /* Is it a normal system zone/user-excluded zone? */
422 if (Address >= 0xA0000 && Address < 0xC0000)
423 {
424 // StartAddress = Address;
425 Size = Increment;
426 Type = UMA_SYSTEM;
427
428 /* Create descriptor */
429 UmaDesc = CreateUmaDescriptor(NULL, StartAddress, Size, Type);
430 if (!UmaDesc) return FALSE;
431
432 StartAddress = 0;
433 continue;
434 }
435 /* Is it the PC ROM BIOS? */
436 else if (Address >= 0xF0000)
437 {
438 // StartAddress = Address;
439 Size = 0x10000; // Increment;
440 Type = UMA_ROM;
441
442 /* Create descriptor */
443 UmaDesc = CreateUmaDescriptor(NULL, StartAddress, Size, Type);
444 if (!UmaDesc) return FALSE;
445
446 StartAddress = 0;
447 continue;
448 }
449 /* Is it an option ROM? */
450 else if (Address >= 0xC0000 && Address < 0xF0000)
451 {
452 ULONG RomSize;
453 ULONG PrevRomAddress = 0;
454 ULONG PrevRomSize = 0;
455
456 // while (Address < 0xF0000)
457 for (; Address < 0xF0000; Address += Increment)
458 {
459
460 #if 0 // FIXME: Is this block, better here...
461 {
462 // We may be looping inside a ROM block, if: Type == 2 and:
463 // (StartAddress <= Address &&) StartAddress + Size > Address.
464 // In this case, do nothing (do not increase size either)
465 // But if we are now outside of a ROM block, then we need
466 // to create the previous block, and initialize a new empty one!
467 // (and following the next passages, increase its size).
468
469 // if (StartAddress < Address && Type != 2)
470 if (Type == UMA_ROM && StartAddress + Size > Address)
471 {
472 /* We are inside ROM, do nothing */
473 }
474 else if (Type == UMA_ROM && StartAddress + Size <= Address)
475 {
476 /* We finished a ROM descriptor */
477
478 /* Create descriptor */
479 UmaDesc = CreateUmaDescriptor(NULL, StartAddress, Size, Type);
480 if (!UmaDesc) return FALSE;
481
482 StartAddress = 0;
483 // goto Restart;
484 }
485 else if (Type != UMA_ROM)
486 {
487 Size += Increment;
488 }
489 }
490 #endif
491
492 Restart:
493 /// if (Address >= 0xE0000) { Increment = 0x10000; }
494
495 if (StartAddress == 0)
496 {
497 /* Initialize data for a new descriptor */
498 StartAddress = Address;
499 Size = 0;
500 Type = UMA_FREE;
501
502 PrevRomAddress = 0;
503 PrevRomSize = 0;
504 }
505
506 if (*(PUSHORT)REAL_TO_PHYS(Address) == OPTION_ROM_SIGNATURE)
507 {
508 /*
509 * If this is an adapter ROM (Start: C8000, End: E0000),
510 * its reported size is stored in byte 2 of the ROM.
511 *
512 * If this is an expansion ROM (Start: E0000, End: F0000),
513 * its real length is 64kB.
514 */
515 RomSize = *(PUCHAR)REAL_TO_PHYS(Address + 2) * 512;
516 // if (Address >= 0xE0000) RomSize = 0x10000;
517 if (Address >= 0xE0000) { RomSize = 0x10000; Increment = RomSize; }
518
519 DPRINT1("ROM present @ address 0x%p\n", Address);
520
521 if (StartAddress != 0 && Size != 0 &&
522 StartAddress + Size <= Address)
523 {
524 /* Finish old descriptor */
525 UmaDesc = CreateUmaDescriptor(NULL, StartAddress, Size, Type);
526 if (!UmaDesc) return FALSE;
527 }
528
529 /*
530 * We may have overlapping ROMs, when PrevRomAddress + PrevRomSize > RomAddress.
531 * They must be put inside the same UMA descriptor.
532 */
533 if (PrevRomAddress + PrevRomSize > /*Rom*/Address)
534 {
535 // Overlapping ROM
536
537 /*
538 * PrevRomAddress remains the same, but adjust
539 * PrevRomSize (ROM descriptors merging).
540 */
541 PrevRomSize = max(PrevRomSize, RomSize + Address - PrevRomAddress);
542
543 // FIX: Confirm that the start address is really
544 // the one of the previous descriptor.
545 StartAddress = PrevRomAddress;
546 Size = PrevRomSize;
547 Type = UMA_ROM;
548 }
549 else
550 {
551 // Non-overlapping ROM
552
553 PrevRomAddress = Address;
554 PrevRomSize = RomSize;
555
556 /* Initialize a new descriptor. We will create it when it's OK */
557 StartAddress = Address;
558 Size = RomSize;
559 Type = UMA_ROM;
560 // continue;
561 }
562 }
563 #if 1 // FIXME: ...or there??
564 else
565 {
566 // We may be looping inside a ROM block, if: Type == 2 and:
567 // (StartAddress <= Address &&) StartAddress + Size > Address.
568 // In this case, do nothing (do not increase size either)
569 // But if we are now outside of a ROM block, then we need
570 // to create the previous block, and initialize a new empty one!
571 // (and following the next passages, increase its size).
572
573 // if (StartAddress < Address && Type != UMA_ROM)
574 if (Type == UMA_ROM && StartAddress + Size > Address)
575 {
576 // We are inside ROM, do nothing
577 }
578 else if (Type == UMA_ROM && StartAddress + Size <= Address)
579 {
580 // We finished a ROM descriptor.
581
582 /* Create descriptor */
583 UmaDesc = CreateUmaDescriptor(NULL, StartAddress, Size, Type);
584 if (!UmaDesc) return FALSE;
585
586 StartAddress = 0;
587 goto Restart;
588 }
589 else if (Type != UMA_ROM)
590 {
591 Size += Increment;
592 }
593 }
594 #endif
595
596 // Fixed incroment; we may encounter again overlapping ROMs, etc.
597 // Address += Increment;
598 }
599
600 if (StartAddress != 0 && Size != 0)
601 {
602 /* Create descriptor */
603 UmaDesc = CreateUmaDescriptor(NULL, StartAddress, Size, Type);
604 if (!UmaDesc) return FALSE;
605
606 StartAddress = 0;
607 }
608
609 }
610 }
611 }
612
613 return TRUE;
614 }
615
616 VOID UmaMgrCleanup(VOID)
617 {
618 PUMA_DESCRIPTOR UmaDesc;
619
620 while (!IsListEmpty(&UmaDescriptorList))
621 {
622 UmaDesc = (PUMA_DESCRIPTOR)CONTAINING_RECORD(UmaDescriptorList.Flink, UMA_DESCRIPTOR, Entry);
623 FreeUmaDescriptor(UmaDesc);
624 }
625 }
626
627 /* EOF */