FatPkg: Clean up source files
[mirror_edk2.git] / FatPkg / FatPei / Part.c
1 /** @file
2 Routines supporting partition discovery and
3 logical device reading
4
5 Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
6
7 This program and the accompanying materials are licensed and made available
8 under the terms and conditions of the BSD License which accompanies this
9 distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17 #include <IndustryStandard/Mbr.h>
18 #include <IndustryStandard/ElTorito.h>
19 #include "FatLitePeim.h"
20
21 /**
22 This function finds Eltorito partitions. Main algorithm
23 is ported from DXE partition driver.
24
25 @param PrivateData The global memory map
26 @param ParentBlockDevNo The parent block device
27
28 @retval TRUE New partitions are detected and logical block devices
29 are added to block device array
30 @retval FALSE No New partitions are added;
31
32 **/
33 BOOLEAN
34 FatFindEltoritoPartitions (
35 IN PEI_FAT_PRIVATE_DATA *PrivateData,
36 IN UINTN ParentBlockDevNo
37 );
38
39 /**
40 This function finds Mbr partitions. Main algorithm
41 is ported from DXE partition driver.
42
43 @param PrivateData The global memory map
44 @param ParentBlockDevNo The parent block device
45
46 @retval TRUE New partitions are detected and logical block devices
47 are added to block device array
48 @retval FALSE No New partitions are added;
49
50 **/
51 BOOLEAN
52 FatFindMbrPartitions (
53 IN PEI_FAT_PRIVATE_DATA *PrivateData,
54 IN UINTN ParentBlockDevNo
55 );
56
57
58 /**
59 This function finds partitions (logical devices) in physical block devices.
60
61 @param PrivateData Global memory map for accessing global variables.
62
63 **/
64 VOID
65 FatFindPartitions (
66 IN PEI_FAT_PRIVATE_DATA *PrivateData
67 )
68 {
69 BOOLEAN Found;
70 UINTN Index;
71
72 do {
73 Found = FALSE;
74
75 for (Index = 0; Index < PrivateData->BlockDeviceCount; Index++) {
76 if (!PrivateData->BlockDevice[Index].PartitionChecked) {
77 Found = FatFindMbrPartitions (PrivateData, Index);
78 if (!Found) {
79 Found = FatFindEltoritoPartitions (PrivateData, Index);
80 }
81 }
82 }
83 } while (Found && PrivateData->BlockDeviceCount <= PEI_FAT_MAX_BLOCK_DEVICE);
84 }
85
86
87 /**
88 This function finds Eltorito partitions. Main algorithm
89 is ported from DXE partition driver.
90
91 @param PrivateData The global memory map
92 @param ParentBlockDevNo The parent block device
93
94 @retval TRUE New partitions are detected and logical block devices
95 are added to block device array
96 @retval FALSE No New partitions are added;
97
98 **/
99 BOOLEAN
100 FatFindEltoritoPartitions (
101 IN PEI_FAT_PRIVATE_DATA *PrivateData,
102 IN UINTN ParentBlockDevNo
103 )
104 {
105 EFI_STATUS Status;
106 BOOLEAN Found;
107 PEI_FAT_BLOCK_DEVICE *BlockDev;
108 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
109 UINT32 VolDescriptorLba;
110 UINT32 Lba;
111 CDROM_VOLUME_DESCRIPTOR *VolDescriptor;
112 ELTORITO_CATALOG *Catalog;
113 UINTN Check;
114 UINTN Index;
115 UINTN MaxIndex;
116 UINT16 *CheckBuffer;
117 UINT32 SubBlockSize;
118 UINT32 SectorCount;
119 UINT32 VolSpaceSize;
120
121 if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
122 return FALSE;
123 }
124
125 Found = FALSE;
126 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
127 VolSpaceSize = 0;
128
129 //
130 // CD_ROM has the fixed block size as 2048 bytes
131 //
132 if (ParentBlockDev->BlockSize != 2048) {
133 return FALSE;
134 }
135
136 VolDescriptor = (CDROM_VOLUME_DESCRIPTOR *) PrivateData->BlockData;
137 Catalog = (ELTORITO_CATALOG *) VolDescriptor;
138
139 //
140 // the ISO-9660 volume descriptor starts at 32k on the media
141 // and CD_ROM has the fixed block size as 2048 bytes, so...
142 //
143 VolDescriptorLba = 15;
144 //
145 // ((16*2048) / Media->BlockSize) - 1;
146 //
147 // Loop: handle one volume descriptor per time
148 //
149 while (TRUE) {
150
151 VolDescriptorLba += 1;
152 if (VolDescriptorLba > ParentBlockDev->LastBlock) {
153 //
154 // We are pointing past the end of the device so exit
155 //
156 break;
157 }
158
159 Status = FatReadBlock (
160 PrivateData,
161 ParentBlockDevNo,
162 VolDescriptorLba,
163 ParentBlockDev->BlockSize,
164 VolDescriptor
165 );
166 if (EFI_ERROR (Status)) {
167 break;
168 }
169 //
170 // Check for valid volume descriptor signature
171 //
172 if (VolDescriptor->Unknown.Type == CDVOL_TYPE_END ||
173 CompareMem (VolDescriptor->Unknown.Id, CDVOL_ID, sizeof (VolDescriptor->Unknown.Id)) != 0
174 ) {
175 //
176 // end of Volume descriptor list
177 //
178 break;
179 }
180 //
181 // Read the Volume Space Size from Primary Volume Descriptor 81-88 byte
182 //
183 if (VolDescriptor->Unknown.Type == CDVOL_TYPE_CODED) {
184 VolSpaceSize = VolDescriptor->PrimaryVolume.VolSpaceSize[1];
185 }
186 //
187 // Is it an El Torito volume descriptor?
188 //
189 if (CompareMem (
190 VolDescriptor->BootRecordVolume.SystemId,
191 CDVOL_ELTORITO_ID,
192 sizeof (CDVOL_ELTORITO_ID) - 1
193 ) != 0) {
194 continue;
195 }
196 //
197 // Read in the boot El Torito boot catalog
198 //
199 Lba = UNPACK_INT32 (VolDescriptor->BootRecordVolume.EltCatalog);
200 if (Lba > ParentBlockDev->LastBlock) {
201 continue;
202 }
203
204 Status = FatReadBlock (
205 PrivateData,
206 ParentBlockDevNo,
207 Lba,
208 ParentBlockDev->BlockSize,
209 Catalog
210 );
211 if (EFI_ERROR (Status)) {
212 continue;
213 }
214 //
215 // We don't care too much about the Catalog header's contents, but we do want
216 // to make sure it looks like a Catalog header
217 //
218 if (Catalog->Catalog.Indicator != ELTORITO_ID_CATALOG || Catalog->Catalog.Id55AA != 0xAA55) {
219 continue;
220 }
221
222 Check = 0;
223 CheckBuffer = (UINT16 *) Catalog;
224 for (Index = 0; Index < sizeof (ELTORITO_CATALOG) / sizeof (UINT16); Index += 1) {
225 Check += CheckBuffer[Index];
226 }
227
228 if ((Check & 0xFFFF) != 0) {
229 continue;
230 }
231
232 MaxIndex = ParentBlockDev->BlockSize / sizeof (ELTORITO_CATALOG);
233 for (Index = 1; Index < MaxIndex; Index += 1) {
234 //
235 // Next entry
236 //
237 Catalog += 1;
238
239 //
240 // Check this entry
241 //
242 if (Catalog->Boot.Indicator != ELTORITO_ID_SECTION_BOOTABLE || Catalog->Boot.Lba == 0) {
243 continue;
244 }
245
246 SubBlockSize = 512;
247 SectorCount = Catalog->Boot.SectorCount;
248
249 switch (Catalog->Boot.MediaType) {
250
251 case ELTORITO_NO_EMULATION:
252 SubBlockSize = ParentBlockDev->BlockSize;
253 SectorCount = Catalog->Boot.SectorCount;
254 break;
255
256 case ELTORITO_HARD_DISK:
257 break;
258
259 case ELTORITO_12_DISKETTE:
260 SectorCount = 0x50 * 0x02 * 0x0F;
261 break;
262
263 case ELTORITO_14_DISKETTE:
264 SectorCount = 0x50 * 0x02 * 0x12;
265 break;
266
267 case ELTORITO_28_DISKETTE:
268 SectorCount = 0x50 * 0x02 * 0x24;
269 break;
270
271 default:
272 SectorCount = 0;
273 SubBlockSize = ParentBlockDev->BlockSize;
274 break;
275 }
276
277 if (SectorCount < 2) {
278 SectorCount = (VolSpaceSize > ParentBlockDev->LastBlock + 1) ? (UINT32) (ParentBlockDev->LastBlock - Catalog->Boot.Lba + 1) : (UINT32) (VolSpaceSize - Catalog->Boot.Lba);
279 }
280 //
281 // Register this partition
282 //
283 if (PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE) {
284
285 Found = TRUE;
286
287 BlockDev = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);
288
289 BlockDev->BlockSize = SubBlockSize;
290 BlockDev->LastBlock = SectorCount - 1;
291 BlockDev->IoAlign = ParentBlockDev->IoAlign;
292 BlockDev->Logical = TRUE;
293 BlockDev->PartitionChecked = FALSE;
294 BlockDev->StartingPos = MultU64x32 (Catalog->Boot.Lba, ParentBlockDev->BlockSize);
295 BlockDev->ParentDevNo = ParentBlockDevNo;
296
297 PrivateData->BlockDeviceCount++;
298 }
299 }
300 }
301
302 ParentBlockDev->PartitionChecked = TRUE;
303
304 return Found;
305
306 }
307
308
309 /**
310 Test to see if the Mbr buffer is a valid MBR
311
312 @param Mbr Parent Handle
313 @param LastLba Last Lba address on the device.
314
315 @retval TRUE Mbr is a Valid MBR
316 @retval FALSE Mbr is not a Valid MBR
317
318 **/
319 BOOLEAN
320 PartitionValidMbr (
321 IN MASTER_BOOT_RECORD *Mbr,
322 IN EFI_PEI_LBA LastLba
323 )
324 {
325 UINT32 StartingLBA;
326 UINT32 EndingLBA;
327 UINT32 NewEndingLBA;
328 INTN Index1;
329 INTN Index2;
330 BOOLEAN MbrValid;
331
332 if (Mbr->Signature != MBR_SIGNATURE) {
333 return FALSE;
334 }
335 //
336 // The BPB also has this signature, so it can not be used alone.
337 //
338 MbrValid = FALSE;
339 for (Index1 = 0; Index1 < MAX_MBR_PARTITIONS; Index1++) {
340 if (Mbr->Partition[Index1].OSIndicator == 0x00 || UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) == 0) {
341 continue;
342 }
343
344 MbrValid = TRUE;
345 StartingLBA = UNPACK_UINT32 (Mbr->Partition[Index1].StartingLBA);
346 EndingLBA = StartingLBA + UNPACK_UINT32 (Mbr->Partition[Index1].SizeInLBA) - 1;
347 if (EndingLBA > LastLba) {
348 //
349 // Compatability Errata:
350 // Some systems try to hide drive space with thier INT 13h driver
351 // This does not hide space from the OS driver. This means the MBR
352 // that gets created from DOS is smaller than the MBR created from
353 // a real OS (NT & Win98). This leads to BlockIo->LastBlock being
354 // wrong on some systems FDISKed by the OS.
355 //
356 // return FALSE Because no block devices on a system are implemented
357 // with INT 13h
358 //
359 return FALSE;
360 }
361
362 for (Index2 = Index1 + 1; Index2 < MAX_MBR_PARTITIONS; Index2++) {
363 if (Mbr->Partition[Index2].OSIndicator == 0x00 || UNPACK_INT32 (Mbr->Partition[Index2].SizeInLBA) == 0) {
364 continue;
365 }
366
367 NewEndingLBA = UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) + UNPACK_UINT32 (Mbr->Partition[Index2].SizeInLBA) - 1;
368 if (NewEndingLBA >= StartingLBA && UNPACK_UINT32 (Mbr->Partition[Index2].StartingLBA) <= EndingLBA) {
369 //
370 // This region overlaps with the Index1'th region
371 //
372 return FALSE;
373 }
374 }
375 }
376 //
377 // Non of the regions overlapped so MBR is O.K.
378 //
379 return MbrValid;
380 }
381
382
383 /**
384 This function finds Mbr partitions. Main algorithm
385 is ported from DXE partition driver.
386
387 @param PrivateData The global memory map
388 @param ParentBlockDevNo The parent block device
389
390 @retval TRUE New partitions are detected and logical block devices
391 are added to block device array
392 @retval FALSE No New partitions are added;
393
394 **/
395 BOOLEAN
396 FatFindMbrPartitions (
397 IN PEI_FAT_PRIVATE_DATA *PrivateData,
398 IN UINTN ParentBlockDevNo
399 )
400 {
401 EFI_STATUS Status;
402 MASTER_BOOT_RECORD *Mbr;
403 UINTN Index;
404 BOOLEAN Found;
405 PEI_FAT_BLOCK_DEVICE *ParentBlockDev;
406 PEI_FAT_BLOCK_DEVICE *BlockDev;
407
408 if (ParentBlockDevNo > PEI_FAT_MAX_BLOCK_DEVICE - 1) {
409 return FALSE;
410 }
411
412 ParentBlockDev = &(PrivateData->BlockDevice[ParentBlockDevNo]);
413
414 Found = FALSE;
415 Mbr = (MASTER_BOOT_RECORD *) PrivateData->BlockData;
416
417 Status = FatReadBlock (
418 PrivateData,
419 ParentBlockDevNo,
420 0,
421 ParentBlockDev->BlockSize,
422 Mbr
423 );
424
425 if (EFI_ERROR (Status) || !PartitionValidMbr (Mbr, ParentBlockDev->LastBlock)) {
426 goto Done;
427 }
428 //
429 // We have a valid mbr - add each partition
430 //
431 for (Index = 0; Index < MAX_MBR_PARTITIONS; Index++) {
432 if (Mbr->Partition[Index].OSIndicator == 0x00 || UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) == 0) {
433 //
434 // Don't use null MBR entries
435 //
436 continue;
437 }
438 //
439 // Register this partition
440 //
441 if (PrivateData->BlockDeviceCount < PEI_FAT_MAX_BLOCK_DEVICE) {
442
443 Found = TRUE;
444
445 BlockDev = &(PrivateData->BlockDevice[PrivateData->BlockDeviceCount]);
446
447 BlockDev->BlockSize = MBR_SIZE;
448 BlockDev->LastBlock = UNPACK_INT32 (Mbr->Partition[Index].SizeInLBA) - 1;
449 BlockDev->IoAlign = ParentBlockDev->IoAlign;
450 BlockDev->Logical = TRUE;
451 BlockDev->PartitionChecked = FALSE;
452 BlockDev->StartingPos = MultU64x32 (
453 UNPACK_INT32 (Mbr->Partition[Index].StartingLBA),
454 ParentBlockDev->BlockSize
455 );
456 BlockDev->ParentDevNo = ParentBlockDevNo;
457
458 PrivateData->BlockDeviceCount++;
459 }
460 }
461
462 Done:
463
464 ParentBlockDev->PartitionChecked = TRUE;
465 return Found;
466 }