[NTVDM]
[reactos.git] / reactos / subsystems / mvdm / ntvdm / dos / dos32krnl / memory.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: dos/dos32krnl/memory.c
5 * PURPOSE: DOS32 Memory Manager
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #define NDEBUG
12
13 #include "ntvdm.h"
14 #include "emulator.h"
15 #include "memory.h"
16
17 #include "dos.h"
18 #include "dos/dem.h"
19
20 /* PUBLIC VARIABLES ***********************************************************/
21
22 BYTE DosAllocStrategy = DOS_ALLOC_BEST_FIT;
23 BOOLEAN DosUmbLinked = FALSE;
24
25 /* PRIVATE FUNCTIONS **********************************************************/
26
27 static VOID DosCombineFreeBlocks(WORD StartBlock)
28 {
29 PDOS_MCB CurrentMcb = SEGMENT_TO_MCB(StartBlock), NextMcb;
30
31 /* If this is the last block or it's not free, quit */
32 if (CurrentMcb->BlockType == 'Z' || CurrentMcb->OwnerPsp != 0) return;
33
34 while (TRUE)
35 {
36 /* Get a pointer to the next MCB */
37 NextMcb = SEGMENT_TO_MCB(StartBlock + CurrentMcb->Size + 1);
38
39 /* Check if the next MCB is free */
40 if (NextMcb->OwnerPsp == 0)
41 {
42 /* Combine them */
43 CurrentMcb->Size += NextMcb->Size + 1;
44 CurrentMcb->BlockType = NextMcb->BlockType;
45 NextMcb->BlockType = 'I';
46 }
47 else
48 {
49 /* No more adjoining free blocks */
50 break;
51 }
52 }
53 }
54
55 /* PUBLIC FUNCTIONS ***********************************************************/
56
57 WORD DosAllocateMemory(WORD Size, WORD *MaxAvailable)
58 {
59 WORD Result = 0, Segment = FIRST_MCB_SEGMENT, MaxSize = 0;
60 PDOS_MCB CurrentMcb;
61 BOOLEAN SearchUmb = FALSE;
62
63 DPRINT("DosAllocateMemory: Size 0x%04X\n", Size);
64
65 if (DosUmbLinked && (DosAllocStrategy & (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW)))
66 {
67 /* Search UMB first */
68 Segment = UMB_START_SEGMENT;
69 SearchUmb = TRUE;
70 }
71
72 while (TRUE)
73 {
74 /* Get a pointer to the MCB */
75 CurrentMcb = SEGMENT_TO_MCB(Segment);
76
77 /* Make sure it's valid */
78 if (CurrentMcb->BlockType != 'M' && CurrentMcb->BlockType != 'Z')
79 {
80 DPRINT("The DOS memory arena is corrupted!\n");
81 DosLastError = ERROR_ARENA_TRASHED;
82 return 0;
83 }
84
85 /* Only check free blocks */
86 if (CurrentMcb->OwnerPsp != 0) goto Next;
87
88 /* Combine this free block with adjoining free blocks */
89 DosCombineFreeBlocks(Segment);
90
91 /* Update the maximum block size */
92 if (CurrentMcb->Size > MaxSize) MaxSize = CurrentMcb->Size;
93
94 /* Check if this block is big enough */
95 if (CurrentMcb->Size < Size) goto Next;
96
97 switch (DosAllocStrategy & 0x3F)
98 {
99 case DOS_ALLOC_FIRST_FIT:
100 {
101 /* For first fit, stop immediately */
102 Result = Segment;
103 goto Done;
104 }
105
106 case DOS_ALLOC_BEST_FIT:
107 {
108 /* For best fit, update the smallest block found so far */
109 if ((Result == 0) || (CurrentMcb->Size < SEGMENT_TO_MCB(Result)->Size))
110 {
111 Result = Segment;
112 }
113
114 break;
115 }
116
117 case DOS_ALLOC_LAST_FIT:
118 {
119 /* For last fit, make the current block the result, but keep searching */
120 Result = Segment;
121 break;
122 }
123 }
124
125 Next:
126 /* If this was the last MCB in the chain, quit */
127 if (CurrentMcb->BlockType == 'Z')
128 {
129 /* Check if nothing was found while searching through UMBs */
130 if ((Result == 0) && SearchUmb && (DosAllocStrategy & DOS_ALLOC_HIGH_LOW))
131 {
132 /* Search low memory */
133 Segment = FIRST_MCB_SEGMENT;
134 SearchUmb = FALSE;
135 continue;
136 }
137
138 break;
139 }
140
141 /* Otherwise, update the segment and continue */
142 Segment += CurrentMcb->Size + 1;
143 }
144
145 Done:
146
147 /* If we didn't find a free block, return 0 */
148 if (Result == 0)
149 {
150 DosLastError = ERROR_NOT_ENOUGH_MEMORY;
151 if (MaxAvailable) *MaxAvailable = MaxSize;
152 return 0;
153 }
154
155 /* Get a pointer to the MCB */
156 CurrentMcb = SEGMENT_TO_MCB(Result);
157
158 /* Check if the block is larger than requested */
159 if (CurrentMcb->Size > Size)
160 {
161 /* It is, split it into two blocks */
162 if ((DosAllocStrategy & 0x3F) != DOS_ALLOC_LAST_FIT)
163 {
164 PDOS_MCB NextMcb = SEGMENT_TO_MCB(Result + Size + 1);
165
166 /* Initialize the new MCB structure */
167 NextMcb->BlockType = CurrentMcb->BlockType;
168 NextMcb->Size = CurrentMcb->Size - Size - 1;
169 NextMcb->OwnerPsp = 0;
170
171 /* Update the current block */
172 CurrentMcb->BlockType = 'M';
173 CurrentMcb->Size = Size;
174 }
175 else
176 {
177 /* Save the location of the current MCB */
178 PDOS_MCB PreviousMcb = CurrentMcb;
179
180 /* Move the current MCB higher */
181 Result += CurrentMcb->Size - Size;
182 CurrentMcb = SEGMENT_TO_MCB(Result);
183
184 /* Initialize the new MCB structure */
185 CurrentMcb->BlockType = PreviousMcb->BlockType;
186 CurrentMcb->Size = Size;
187 CurrentMcb->OwnerPsp = 0;
188
189 /* Update the previous block */
190 PreviousMcb->BlockType = 'M';
191 PreviousMcb->Size -= Size + 1;
192 }
193 }
194
195 /* Take ownership of the block */
196 CurrentMcb->OwnerPsp = CurrentPsp;
197
198 /* Return the segment of the data portion of the block */
199 return Result + 1;
200 }
201
202 BOOLEAN DosResizeMemory(WORD BlockData, WORD NewSize, WORD *MaxAvailable)
203 {
204 BOOLEAN Success = TRUE;
205 WORD Segment = BlockData - 1, ReturnSize = 0, NextSegment;
206 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment), NextMcb;
207
208 DPRINT("DosResizeMemory: BlockData 0x%04X, NewSize 0x%04X\n",
209 BlockData,
210 NewSize);
211
212 /* Make sure this is a valid, allocated block */
213 if (BlockData == 0
214 || (Mcb->BlockType != 'M' && Mcb->BlockType != 'Z')
215 || Mcb->OwnerPsp == 0)
216 {
217 Success = FALSE;
218 DosLastError = ERROR_INVALID_HANDLE;
219 goto Done;
220 }
221
222 ReturnSize = Mcb->Size;
223
224 /* Check if we need to expand or contract the block */
225 if (NewSize > Mcb->Size)
226 {
227 /* We can't expand the last block */
228 if (Mcb->BlockType != 'M')
229 {
230 Success = FALSE;
231 goto Done;
232 }
233
234 /* Get the pointer and segment of the next MCB */
235 NextSegment = Segment + Mcb->Size + 1;
236 NextMcb = SEGMENT_TO_MCB(NextSegment);
237
238 /* Make sure the next segment is free */
239 if (NextMcb->OwnerPsp != 0)
240 {
241 DPRINT("Cannot expand memory block: next segment is not free!\n");
242 DosLastError = ERROR_NOT_ENOUGH_MEMORY;
243 Success = FALSE;
244 goto Done;
245 }
246
247 /* Combine this free block with adjoining free blocks */
248 DosCombineFreeBlocks(NextSegment);
249
250 /* Set the maximum possible size of the block */
251 ReturnSize += NextMcb->Size + 1;
252
253 if (ReturnSize < NewSize)
254 {
255 DPRINT("Cannot expand memory block: insufficient free segments available!\n");
256 DosLastError = ERROR_NOT_ENOUGH_MEMORY;
257 Success = FALSE;
258 goto Done;
259 }
260
261 /* Maximize the current block */
262 Mcb->Size = ReturnSize;
263 Mcb->BlockType = NextMcb->BlockType;
264
265 /* Invalidate the next block */
266 NextMcb->BlockType = 'I';
267
268 /* Check if the block is larger than requested */
269 if (Mcb->Size > NewSize)
270 {
271 DPRINT("Block too large, reducing size from 0x%04X to 0x%04X\n",
272 Mcb->Size,
273 NewSize);
274
275 /* It is, split it into two blocks */
276 NextMcb = SEGMENT_TO_MCB(Segment + NewSize + 1);
277
278 /* Initialize the new MCB structure */
279 NextMcb->BlockType = Mcb->BlockType;
280 NextMcb->Size = Mcb->Size - NewSize - 1;
281 NextMcb->OwnerPsp = 0;
282
283 /* Update the current block */
284 Mcb->BlockType = 'M';
285 Mcb->Size = NewSize;
286 }
287 }
288 else if (NewSize < Mcb->Size)
289 {
290 DPRINT("Shrinking block from 0x%04X to 0x%04X\n",
291 Mcb->Size,
292 NewSize);
293
294 /* Just split the block */
295 NextMcb = SEGMENT_TO_MCB(Segment + NewSize + 1);
296 NextMcb->BlockType = Mcb->BlockType;
297 NextMcb->Size = Mcb->Size - NewSize - 1;
298 NextMcb->OwnerPsp = 0;
299
300 /* Update the MCB */
301 Mcb->BlockType = 'M';
302 Mcb->Size = NewSize;
303 }
304
305 Done:
306 /* Check if the operation failed */
307 if (!Success)
308 {
309 DPRINT("DosResizeMemory FAILED. Maximum available: 0x%04X\n",
310 ReturnSize);
311
312 /* Return the maximum possible size */
313 if (MaxAvailable) *MaxAvailable = ReturnSize;
314 }
315
316 return Success;
317 }
318
319 BOOLEAN DosFreeMemory(WORD BlockData)
320 {
321 PDOS_MCB Mcb = SEGMENT_TO_MCB(BlockData - 1);
322
323 DPRINT("DosFreeMemory: BlockData 0x%04X\n", BlockData);
324 if (BlockData == 0) return FALSE;
325
326 /* Make sure the MCB is valid */
327 if (Mcb->BlockType != 'M' && Mcb->BlockType != 'Z')
328 {
329 DPRINT("MCB block type '%c' not valid!\n", Mcb->BlockType);
330 return FALSE;
331 }
332
333 /* Mark the block as free */
334 Mcb->OwnerPsp = 0;
335
336 return TRUE;
337 }
338
339 BOOLEAN DosLinkUmb(VOID)
340 {
341 DWORD Segment = FIRST_MCB_SEGMENT;
342 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment);
343
344 DPRINT("Linking UMB\n");
345
346 /* Check if UMBs are already linked */
347 if (DosUmbLinked) return FALSE;
348
349 /* Find the last block */
350 while ((Mcb->BlockType == 'M') && (Segment <= 0xFFFF))
351 {
352 Segment += Mcb->Size + 1;
353 Mcb = SEGMENT_TO_MCB(Segment);
354 }
355
356 /* Make sure it's valid */
357 if (Mcb->BlockType != 'Z') return FALSE;
358
359 /* Connect the MCB with the UMB chain */
360 Mcb->BlockType = 'M';
361
362 DosUmbLinked = TRUE;
363 return TRUE;
364 }
365
366 BOOLEAN DosUnlinkUmb(VOID)
367 {
368 DWORD Segment = FIRST_MCB_SEGMENT;
369 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment);
370
371 DPRINT("Unlinking UMB\n");
372
373 /* Check if UMBs are already unlinked */
374 if (!DosUmbLinked) return FALSE;
375
376 /* Find the block preceding the MCB that links it with the UMB chain */
377 while (Segment <= 0xFFFF)
378 {
379 if ((Segment + Mcb->Size) == (FIRST_MCB_SEGMENT + USER_MEMORY_SIZE))
380 {
381 /* This is the last non-UMB segment */
382 break;
383 }
384
385 /* Advance to the next MCB */
386 Segment += Mcb->Size + 1;
387 Mcb = SEGMENT_TO_MCB(Segment);
388 }
389
390 /* Mark the MCB as the last MCB */
391 Mcb->BlockType = 'Z';
392
393 DosUmbLinked = FALSE;
394 return TRUE;
395 }
396
397 VOID DosChangeMemoryOwner(WORD Segment, WORD NewOwner)
398 {
399 PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment - 1);
400
401 /* Just set the owner */
402 Mcb->OwnerPsp = NewOwner;
403 }
404