[BOOTLIB] Fix 64 bit issues (#433)
[reactos.git] / boot / environ / lib / mm / blkalloc.c
1 /*
2 * COPYRIGHT: See COPYING.ARM in the top level directory
3 * PROJECT: ReactOS UEFI Boot Library
4 * FILE: boot/environ/lib/mm/blkalloc.c
5 * PURPOSE: Boot Library Memory Manager Block Allocator
6 * PROGRAMMER: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "bl.h"
12
13 /* DATA VARIABLES ************************************************************/
14
15 PVOID* MmBlockAllocatorTable;
16 ULONG MmBlockAllocatorTableEntries;
17 BOOLEAN MmBlockAllocatorInitialized;
18
19 typedef struct _BL_BLOCK_DESCRIPTOR
20 {
21 LIST_ENTRY ListHead;
22 ULONG Unknown;
23 BL_MEMORY_TYPE Type;
24 ULONG Attributes;
25 ULONG Unknown2;
26 ULONG Count;
27 ULONG Count2;
28 ULONG Size;
29 ULONG BlockId;
30 ULONG ReferenceCount;
31 } BL_BLOCK_DESCRIPTOR, *PBL_BLOCK_DESCRIPTOR;
32
33 typedef struct _BL_BLOCK_ENTRY
34 {
35 LIST_ENTRY ListEntry;
36 ULONG Todo;
37 } BL_BLOCK_ENTRY, *PBL_BLOCK_ENTRY;
38
39 /* FUNCTIONS *****************************************************************/
40
41 BOOLEAN
42 MmBapCompareBlockAllocatorTableEntry (
43 _In_ PVOID Entry,
44 _In_ PVOID Argument1,
45 _In_ PVOID Argument2,
46 _In_ PVOID Argument3,
47 _In_ PVOID Argument4
48 )
49 {
50 PBL_BLOCK_DESCRIPTOR BlockInfo = (PBL_BLOCK_DESCRIPTOR)Entry;
51 ULONG BlockId = PtrToUlong(Argument1);
52
53 /* Check if the block ID matches */
54 return BlockInfo->BlockId == BlockId;
55 }
56
57 PBL_BLOCK_DESCRIPTOR
58 MmBapFindBlockInformation (
59 ULONG BlockId
60 )
61 {
62 ULONG EntryId;
63
64 /* Find the block that matches */
65 EntryId = BlockId;
66 return BlTblFindEntry(MmBlockAllocatorTable,
67 MmBlockAllocatorTableEntries,
68 &EntryId,
69 MmBapCompareBlockAllocatorTableEntry,
70 UlongToPtr(EntryId),
71 NULL,
72 NULL,
73 NULL);
74 }
75
76 NTSTATUS
77 MmBapFreeBlockAllocatorDescriptor (
78 _In_ PBL_BLOCK_DESCRIPTOR BlockInfo,
79 _In_ PBL_BLOCK_ENTRY BlockEntry
80 )
81 {
82 /* @TODO FIXME: Later */
83 EfiPrintf(L"Block free not yet implemented\r\n");
84 return STATUS_NOT_IMPLEMENTED;
85 }
86
87 NTSTATUS
88 BlpMmDeleteBlockAllocator (
89 _In_ ULONG BlockId
90 )
91 {
92 NTSTATUS Status, LocalStatus;
93 PBL_BLOCK_DESCRIPTOR BlockInfo;
94 PLIST_ENTRY ListHead, NextEntry;
95 PBL_BLOCK_ENTRY BlockEntry;
96
97 /* Nothing to delete if we're not initialized */
98 if (!MmBlockAllocatorInitialized)
99 {
100 return STATUS_UNSUCCESSFUL;
101 }
102
103 /* Find the block descriptor */
104 BlockInfo = MmBapFindBlockInformation(BlockId);
105 if (BlockInfo)
106 {
107 /* Assume success for now */
108 Status = STATUS_SUCCESS;
109
110 /* Do we have at least one reference? */
111 if (BlockInfo->ReferenceCount)
112 {
113 /* Iterate over the allocated blocks */
114 ListHead = &BlockInfo->ListHead;
115 NextEntry = ListHead->Flink;
116 while (NextEntry != ListHead)
117 {
118 /* Free each one */
119 BlockEntry = CONTAINING_RECORD(NextEntry,
120 BL_BLOCK_ENTRY,
121 ListEntry);
122 LocalStatus = MmBapFreeBlockAllocatorDescriptor(BlockInfo,
123 BlockEntry);
124 if (!NT_SUCCESS(LocalStatus))
125 {
126 /* Remember status on failure only */
127 Status = LocalStatus;
128 }
129 }
130
131 /* Drop a reference */
132 BlockInfo->ReferenceCount--;
133 }
134 else
135 {
136 /* There aren't any references, so why are we being called? */
137 Status = STATUS_INVALID_PARAMETER;
138 }
139 }
140 else
141 {
142 /* No block exists with this ID */
143 Status = STATUS_UNSUCCESSFUL;
144 }
145
146 /* Return back */
147 return Status;
148 }
149
150 NTSTATUS
151 MmBapFreeBlockAllocatorTableEntry (
152 _In_ PVOID Entry,
153 _In_ ULONG Index
154 )
155 {
156 PBL_BLOCK_DESCRIPTOR BlockInfo = (PBL_BLOCK_DESCRIPTOR)Entry;
157 NTSTATUS Status, LocalStatus;
158
159 /* Assume success */
160 Status = STATUS_SUCCESS;
161
162 /* Check if there was at least one reference */
163 if (BlockInfo->ReferenceCount > 1)
164 {
165 /* Try to delete the allocator */
166 LocalStatus = BlpMmDeleteBlockAllocator(BlockInfo->BlockId);
167 if (!NT_SUCCESS(LocalStatus))
168 {
169 /* Remember status on failure only */
170 Status = LocalStatus;
171 }
172 }
173
174 /* Now destroy the allocator's descriptor */
175 LocalStatus = BlMmFreeHeap(BlockInfo);
176 if (!NT_SUCCESS(LocalStatus))
177 {
178 /* Remember status on failure only */
179 Status = LocalStatus;
180 }
181
182 /* Free the entry, and return failure, if any */
183 MmBlockAllocatorTable[Index] = NULL;
184 return Status;
185 }
186
187 NTSTATUS
188 MmBapPurgeBlockAllocatorTableEntry (
189 _In_ PVOID Entry
190 )
191 {
192 PBL_BLOCK_DESCRIPTOR BlockInfo = (PBL_BLOCK_DESCRIPTOR)Entry;
193 NTSTATUS Status;
194
195 /* Check if there's a reference on the block descriptor */
196 if (BlockInfo->ReferenceCount)
197 {
198 /* Don't allow purging */
199 Status = STATUS_UNSUCCESSFUL;
200 }
201 else
202 {
203 /* Free the entry */
204 Status = MmBapFreeBlockAllocatorTableEntry(BlockInfo,
205 BlockInfo->BlockId);
206 }
207
208 /* Return purge status */
209 return Status;
210 }
211
212 NTSTATUS
213 BlpMmCreateBlockAllocator (
214 VOID
215 )
216 {
217 PBL_BLOCK_DESCRIPTOR BlockInfo;
218 ULONG BlockId;
219 NTSTATUS Status;
220
221 /* If the block allocator isn't initialized, bail out */
222 BlockId = -1;
223 if (!MmBlockAllocatorInitialized)
224 {
225 goto Quickie;
226 }
227
228 /* Allocate a block descriptor and zero it out */
229 BlockInfo = BlMmAllocateHeap(sizeof(*BlockInfo));
230 if (!BlockInfo)
231 {
232 goto Quickie;
233 }
234 RtlZeroMemory(BlockInfo, sizeof(*BlockInfo));
235
236 /* Setup the block descriptor */
237 BlockInfo->Attributes = 0;
238 BlockInfo->Type = BlLoaderBlockMemory;
239 BlockInfo->Unknown = 1;
240 BlockInfo->Unknown2 = 1;
241 BlockInfo->Size = PAGE_SIZE;
242 BlockInfo->Count = 128;
243 BlockInfo->Count2 = 128;
244 InitializeListHead(&BlockInfo->ListHead);
245
246 /* Add it to the list of block descriptors */
247 Status = BlTblSetEntry(&MmBlockAllocatorTable,
248 &MmBlockAllocatorTableEntries,
249 BlockInfo,
250 &BlockId,
251 MmBapPurgeBlockAllocatorTableEntry);
252 if (NT_SUCCESS(Status))
253 {
254 /* Add the initial reference and store the block ID */
255 BlockInfo->ReferenceCount = 1;
256 BlockInfo->BlockId = BlockId;
257 }
258
259 Quickie:
260 /* On failure, free the block descriptor */
261 if (BlockId == -1)
262 {
263 BlMmFreeHeap(BlockInfo);
264 }
265
266 /* Return the block descriptor ID, or -1 on failure */
267 return BlockId;
268 }
269
270 NTSTATUS
271 MmBaInitialize (
272 VOID
273 )
274 {
275 NTSTATUS Status;
276 ULONG Size;
277
278 /* Allocate 8 table entries */
279 MmBlockAllocatorTableEntries = 8;
280 Size = sizeof(BL_BLOCK_DESCRIPTOR) * MmBlockAllocatorTableEntries;
281 MmBlockAllocatorTable = BlMmAllocateHeap(Size);
282 if (MmBlockAllocatorTable)
283 {
284 /* Zero them out -- we're all done */
285 Status = STATUS_SUCCESS;
286 RtlZeroMemory(MmBlockAllocatorTable, Size);
287 MmBlockAllocatorInitialized = 1;
288 }
289 else
290 {
291 /* Bail out since we're out of memory */
292 Status = STATUS_NO_MEMORY;
293 MmBlockAllocatorInitialized = 0;
294 }
295
296 /* Return initialization status */
297 return Status;
298 }