//#define EndDevicePath DevicePath
#endif
+// "Magic" signatures for various filesystems
+#define FAT_MAGIC 0xAA55
+#define EXT2_SUPER_MAGIC 0xEF53
+#define HFSPLUS_MAGIC1 0x2B48
+#define HFSPLUS_MAGIC2 0x5848
+#define REISERFS_SUPER_MAGIC 0x52654973
+#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
+#define REISER2FS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"
+
// variables
EFI_HANDLE SelfImageHandle;
} // if allocation OK
} // CleanUpPathNameSlashes()
+// Splits an EFI device path into device and filename components. For instance, if InString is
+// PciRoot(0x0)/Pci(0x1f,0x2)/Ata(Secondary,Master,0x0)/HD(2,GPT,8314ae90-ada3-48e9-9c3b-09a88f80d921,0x96028,0xfa000)/\bzImage-3.5.1.efi,
+// this function will truncate that input to
+// PciRoot(0x0)/Pci(0x1f,0x2)/Ata(Secondary,Master,0x0)/HD(2,GPT,8314ae90-ada3-48e9-9c3b-09a88f80d921,0x96028,0xfa000)
+// and return bzImage-3.5.1.efi as its return value.
+// It does this by searching for the last ")" character in InString, copying everything
+// after that string (after some cleanup) as the return value, and truncating the original
+// input value.
+// If InString contains no ")" character, this function leaves the original input string
+// unmodified and also returns that string.
+static CHAR16* SplitDeviceString(IN OUT CHAR16 *InString) {
+ INTN i;
+ CHAR16 *FileName = NULL;
+ BOOLEAN Found = FALSE;
+
+ i = StrLen(InString) - 1;
+ while ((i >= 0) && (!Found)) {
+ if (InString[i] == L')') {
+ Found = TRUE;
+ FileName = StrDuplicate(&InString[i + 1]);
+ CleanUpPathNameSlashes(FileName);
+ InString[i + 1] = '\0';
+ } // if
+ i--;
+ } // while
+ if (FileName == NULL)
+ FileName = StrDuplicate(InString);
+ return FileName;
+} // static CHAR16* SplitDeviceString()
+
EFI_STATUS InitRefitLib(IN EFI_HANDLE ImageHandle)
{
EFI_STATUS Status;
- CHAR16 *DevicePathAsString;
+ CHAR16 *DevicePathAsString, *Temp;
SelfImageHandle = ImageHandle;
Status = refit_call3_wrapper(BS->HandleProtocol, SelfImageHandle, &LoadedImageProtocol, (VOID **) &SelfLoadedImage);
// find the current directory
DevicePathAsString = DevicePathToStr(SelfLoadedImage->FilePath);
CleanUpPathNameSlashes(DevicePathAsString);
- if (SelfDirPath != NULL)
- FreePool(SelfDirPath);
- SelfDirPath = FindPath(DevicePathAsString);
- FreePool(DevicePathAsString);
+ MyFreePool(SelfDirPath);
+ Temp = FindPath(DevicePathAsString);
+ SelfDirPath = SplitDeviceString(Temp);
+ MyFreePool(DevicePathAsString);
+ MyFreePool(Temp);
return FinishInitRefitLib();
}
{
UINTN i;
- if (*ElementCount > 0) {
+ if ((*ElementCount > 0) && (**ListPtr != NULL)) {
for (i = 0; i < *ElementCount; i++) {
// TODO: call a user-provided routine for each element here
- FreePool((*ListPtr)[i]);
+ MyFreePool((*ListPtr)[i]);
}
- FreePool(*ListPtr);
+ MyFreePool(*ListPtr);
}
-}
+} // VOID FreeList()
//
// firmware device path discovery
PathList[PathCount++] = AppendDevicePath(DevicePath, LegacyLoaderMediaPath);
}
- FreePool(Handles);
+ MyFreePool(Handles);
if (HardcodedPathList) {
for (HardcodedIndex = 0; HardcodedPathList[HardcodedIndex] && PathCount < MaxPaths; HardcodedIndex++)
// volume functions
//
+// Return a pointer to a string containing a filesystem type name. If the
+// filesystem type is unknown, a blank (but non-null) string is returned.
+// The returned variable is a constant that should NOT be freed.
+static CHAR16 *FSTypeName(IN UINT32 TypeCode) {
+ CHAR16 *retval = NULL;
+
+ switch (TypeCode) {
+ case FS_TYPE_FAT:
+ retval = L" FAT";
+ break;
+ case FS_TYPE_HFSPLUS:
+ retval = L" HFS+";
+ break;
+ case FS_TYPE_EXT2:
+ retval = L" ext2";
+ break;
+ case FS_TYPE_EXT3:
+ retval = L" ext3";
+ break;
+ case FS_TYPE_EXT4:
+ retval = L" ext4";
+ break;
+ case FS_TYPE_REISERFS:
+ retval = L" ReiserFS";
+ break;
+ case FS_TYPE_ISO9660:
+ retval = L" ISO-9660";
+ break;
+ default:
+ retval = L"";
+ break;
+ } // switch
+ return retval;
+} // CHAR16 *FSTypeName()
+
+// Identify the filesystem type, if possible. Expects a Buffer containing
+// the first few (normally 4096) bytes of the filesystem, and outputs a
+// code representing the identified filesystem type.
+static UINT32 IdentifyFilesystemType(IN UINT8 *Buffer, IN UINTN BufferSize) {
+ UINT32 FoundType = FS_TYPE_UNKNOWN;
+ UINT32 *Ext2Incompat, *Ext2Compat;
+ UINT16 *Magic16;
+
+ if (Buffer != NULL) {
+
+ if (BufferSize >= (1024 + 100)) {
+ Magic16 = (UINT16*) (Buffer + 1024 + 56);
+ if (*Magic16 == EXT2_SUPER_MAGIC) { // ext2/3/4
+ Ext2Compat = (UINT32*) (Buffer + 1024 + 92);
+ Ext2Incompat = (UINT32*) (Buffer + 1024 + 96);
+ if ((*Ext2Incompat & 0x0040) || (*Ext2Incompat & 0x0200)) { // check for extents or flex_bg
+ return FS_TYPE_EXT4;
+ } else if (*Ext2Compat & 0x0004) { // check for journal
+ return FS_TYPE_EXT3;
+ } else { // none of these features; presume it's ext2...
+ return FS_TYPE_EXT2;
+ }
+ }
+ } // search for ext2/3/4 magic
+
+ if (BufferSize >= 512) {
+ Magic16 = (UINT16*) (Buffer + 510);
+ if (*Magic16 == FAT_MAGIC)
+ return FS_TYPE_FAT;
+ } // search for FAT magic
+
+ if (BufferSize >= (1024 + 2)) {
+ Magic16 = (UINT16*) (Buffer + 1024);
+ if ((*Magic16 == HFSPLUS_MAGIC1) || (*Magic16 == HFSPLUS_MAGIC2)) {
+ return FS_TYPE_HFSPLUS;
+ }
+ } // search for HFS+ magic
+ } // if (Buffer != NULL)
+
+ return FoundType;
+}
+
static VOID ScanVolumeBootcode(IN OUT REFIT_VOLUME *Volume, OUT BOOLEAN *Bootable)
{
EFI_STATUS Status;
Volume->BlockIOOffset, SECTOR_SIZE, SectorBuffer);
if (!EFI_ERROR(Status)) {
+ Volume->FSType = IdentifyFilesystemType(SectorBuffer, SECTOR_SIZE);
if (*((UINT16 *)(SectorBuffer + 510)) == 0xaa55 && SectorBuffer[0] != 0) {
*Bootable = TRUE;
Volume->HasBootCode = TRUE;
} // switch()
}
-static VOID ScanVolume(IN OUT REFIT_VOLUME *Volume)
+// Return a string representing the input size in IEEE-1541 units.
+// The calling function is responsible for freeing the allocated memory.
+static CHAR16 *SizeInIEEEUnits(UINT64 SizeInBytes) {
+ float SizeInIeee;
+ UINTN Index = 0;
+ CHAR16 *Units, *Prefixes = L" KMGTPEZ";
+ CHAR16 *TheValue;
+
+ TheValue = AllocateZeroPool(sizeof(CHAR16) * 80);
+ if (TheValue != NULL) {
+ SizeInIeee = (float) SizeInBytes;
+ while ((SizeInIeee > 1024.0) && (Index < (StrLen(Prefixes) - 1))) {
+ Index++;
+ SizeInIeee /= 1024.0;
+ } // while
+ if (Prefixes[Index] == ' ') {
+ Units = StrDuplicate(L"-byte");
+ } else {
+ Units = StrDuplicate(L" iB");
+ Units[1] = Prefixes[Index];
+ } // if/else
+ SPrint(TheValue, 79, L"%d%s", (UINTN) SizeInIeee, Units);
+ } // if
+ return TheValue;
+} // CHAR16 *SizeInSIUnits()
+
+// Return a name for the volume. Ideally this should be the label for the
+// filesystem it contains, but this function falls back to describing the
+// filesystem by size (200 MiB, etc.) and/or type (ext2, HFS+, etc.), if
+// this information can be extracted.
+// The calling function is responsible for freeing the memory allocated
+// for the name string.
+static CHAR16 *GetVolumeName(IN REFIT_VOLUME *Volume) {
+ EFI_FILE_SYSTEM_INFO *FileSystemInfoPtr;
+ CHAR16 *FoundName = NULL;
+ CHAR16 *SISize, *TypeName;
+
+ FileSystemInfoPtr = LibFileSystemInfo(Volume->RootDir);
+ if (FileSystemInfoPtr != NULL) {
+ if ((FileSystemInfoPtr->VolumeLabel != NULL) && (StrLen(FileSystemInfoPtr->VolumeLabel) > 0)) {
+ FoundName = StrDuplicate(FileSystemInfoPtr->VolumeLabel);
+ }
+
+ // Special case: rEFInd HFS+ driver always returns label of "HFS+ volume", so wipe
+ // this so that we can build a new name that includes the size....
+ if ((FoundName != NULL) && (StrCmp(FoundName, L"HFS+ volume") == 0) && (Volume->FSType == FS_TYPE_HFSPLUS)) {
+ MyFreePool(FoundName);
+ FoundName = NULL;
+ } // if rEFInd HFS+ driver suspected
+
+ if (FoundName == NULL) { // filesystem has no name....
+ FoundName = AllocateZeroPool(sizeof(CHAR16) * 256);
+ if (FoundName != NULL) {
+ SISize = SizeInIEEEUnits(FileSystemInfoPtr->VolumeSize);
+ SPrint(FoundName, 255, L"%s%s volume", SISize, FSTypeName(Volume->FSType));
+ MyFreePool(SISize);
+ } // if allocated memory OK
+ } // if (FoundName == NULL)
+
+ FreePool(FileSystemInfoPtr);
+
+ } else {
+ FoundName = AllocateZeroPool(sizeof(CHAR16) * 256);
+ if (FoundName != NULL) {
+ TypeName = FSTypeName(Volume->FSType); // NOTE: Don't free TypeName; fn returns constant
+ if (StrLen(TypeName) > 0)
+ SPrint(FoundName, 255, L"%s volume", FSTypeName(Volume->FSType));
+ else
+ SPrint(FoundName, 255, L"unknown volume");
+ } // if allocated memory OK
+ } // if
+
+ // TODO: Above could be improved/extended, in case filesystem name is not found,
+ // such as:
+ // - use partition label
+ // - use or add disk/partition number (e.g., "(hd0,2)")
+
+ // Desperate fallback name....
+ if (FoundName == NULL) {
+ FoundName = StrDuplicate(L"unknown volume");
+ }
+ return FoundName;
+} // static CHAR16 *GetVolumeName()
+
+VOID ScanVolume(IN OUT REFIT_VOLUME *Volume)
{
EFI_STATUS Status;
EFI_DEVICE_PATH *DevicePath, *NextDevicePath;
EFI_DEVICE_PATH *DiskDevicePath, *RemainingDevicePath;
EFI_HANDLE WholeDiskHandle;
UINTN PartialLength;
- EFI_FILE_SYSTEM_INFO *FileSystemInfoPtr;
BOOLEAN Bootable;
// get device path
// get the handle for that path
RemainingDevicePath = DiskDevicePath;
- //Print(L" * looking at %s\n", DevicePathToStr(RemainingDevicePath));
Status = refit_call3_wrapper(BS->LocateDevicePath, &BlockIoProtocol, &RemainingDevicePath, &WholeDiskHandle);
- //Print(L" * remaining: %s\n", DevicePathToStr(RemainingDevicePath));
FreePool(DiskDevicePath);
if (!EFI_ERROR(Status)) {
Volume->IsReadable = TRUE;
}
- // get volume name
- FileSystemInfoPtr = LibFileSystemInfo(Volume->RootDir);
- if (FileSystemInfoPtr != NULL) {
- Volume->VolName = StrDuplicate(FileSystemInfoPtr->VolumeLabel);
- FreePool(FileSystemInfoPtr);
- }
-
- if (Volume->VolName == NULL) {
- Volume->VolName = StrDuplicate(L"Unknown");
- }
- // TODO: if no official volume name is found or it is empty, use something else, e.g.:
- // - name from bytes 3 to 10 of the boot sector
- // - partition number
- // - name derived from file system type or partition type
+ Volume->VolName = GetVolumeName(Volume);
// get custom volume icon if present
if (FileExists(Volume->RootDir, VOLUME_BADGE_NAME))
UINT8 *SectorBuffer1, *SectorBuffer2;
UINTN SectorSum, i;
- FreePool(Volumes);
+ MyFreePool(Volumes);
Volumes = NULL;
VolumesCount = 0;
if (Volume->DeviceHandle == SelfLoadedImage->DeviceHandle)
SelfVolume = Volume;
}
- FreePool(Handles);
+ MyFreePool(Handles);
if (SelfVolume == NULL)
Print(L"WARNING: SelfVolume not found");
break;
}
- FreePool(SectorBuffer1);
- FreePool(SectorBuffer2);
+ MyFreePool(SectorBuffer1);
+ MyFreePool(SectorBuffer2);
}
}
// free pointer from last call
if (*DirEntry != NULL) {
- FreePool(*DirEntry);
- *DirEntry = NULL;
+ FreePool(*DirEntry);
+ *DirEntry = NULL;
}
// read next directory entry
CHAR16 *OnePattern;
if (DirIter->LastFileInfo != NULL) {
- FreePool(DirIter->LastFileInfo);
- DirIter->LastFileInfo = NULL;
+ FreePool(DirIter->LastFileInfo);
+ DirIter->LastFileInfo = NULL;
}
if (EFI_ERROR(DirIter->LastStatus))
EFI_STATUS DirIterClose(IN OUT REFIT_DIR_ITER *DirIter)
{
- if (DirIter->LastFileInfo != NULL) {
- FreePool(DirIter->LastFileInfo);
- DirIter->LastFileInfo = NULL;
- }
- if (DirIter->CloseDirHandle)
- refit_call1_wrapper(DirIter->DirHandle->Close, DirIter->DirHandle);
- return DirIter->LastStatus;
+ if (DirIter->LastFileInfo != NULL) {
+ FreePool(DirIter->LastFileInfo);
+ DirIter->LastFileInfo = NULL;
+ }
+ if (DirIter->CloseDirHandle)
+ refit_call1_wrapper(DirIter->DirHandle->Close, DirIter->DirHandle);
+ return DirIter->LastStatus;
}
//
while ((!Found) && (StartPoint < NumCompares)) {
Found = (StrnCmp(SmallCopy, &BigCopy[StartPoint++], SmallLen) == 0);
} // while
- FreePool(SmallCopy);
- FreePool(BigCopy);
+ MyFreePool(SmallCopy);
+ MyFreePool(BigCopy);
} // if
return (Found);
StrCat(NewString, *First);
if (AddChar) {
NewString[Length1] = AddChar;
- NewString[Length1 + 1] = 0;
+ NewString[Length1 + 1] = '\0';
} // if (AddChar)
} // if (*First != NULL)
if (Second != NULL)
StrCat(NewString, Second);
- FreePool(*First);
+ MyFreePool(*First);
*First = NewString;
} else {
Print(L"Error! Unable to allocate memory in MergeStrings()!\n");
return (PathOnly);
}
+// Takes an input loadpath, splits it into disk and filename components, finds a matching
+// DeviceVolume, and returns that and the filename (*loader).
+VOID FindVolumeAndFilename(IN EFI_DEVICE_PATH *loadpath, OUT REFIT_VOLUME **DeviceVolume, OUT CHAR16 **loader) {
+ CHAR16 *DeviceString, *VolumeDeviceString, *Temp;
+ UINTN i = 0;
+ BOOLEAN Found = FALSE;
+
+ MyFreePool(*loader);
+ MyFreePool(*DeviceVolume);
+ *DeviceVolume = NULL;
+ DeviceString = DevicePathToStr(loadpath);
+ *loader = SplitDeviceString(DeviceString);
+
+ while ((i < VolumesCount) && (!Found)) {
+ VolumeDeviceString = DevicePathToStr(Volumes[i]->DevicePath);
+ Temp = SplitDeviceString(VolumeDeviceString);
+ if (StriCmp(DeviceString, VolumeDeviceString) == 0) {
+ Found = TRUE;
+ *DeviceVolume = Volumes[i];
+ }
+ MyFreePool(Temp);
+ MyFreePool(VolumeDeviceString);
+ i++;
+ } // while
+
+ MyFreePool(DeviceString);
+} // VOID FindVolumeAndFilename()
+
// Returns all the digits in the input string, including intervening
// non-digit characters. For instance, if InString is "foo-3.3.4-7.img",
// this function returns "3.3.4-7". If InString contains no digits,
return Found;
} // BOOLEAN IsIn()
+// Implement FreePool the way it should have been done to begin with, so that
+// it doesn't throw an ASSERT message if fed a NULL pointer....
+VOID MyFreePool(IN OUT VOID *Pointer) {
+ if (Pointer != NULL)
+ FreePool(Pointer);
+}
+
static EFI_GUID AppleRemovableMediaGuid = APPLE_REMOVABLE_MEDIA_PROTOCOL_GUID;
// Eject all removable media.
if (!EFI_ERROR(Status))
Ejected++;
}
- FreePool(Handles);
+ MyFreePool(Handles);
return (Ejected > 0);
} // VOID EjectMedia()
+
+// // Return the GUID as a string, suitable for display to the user. Note that the calling
+// // function is responsible for freeing the allocated memory.
+// CHAR16 * GuidAsString(EFI_GUID *GuidData) {
+// CHAR16 *TheString;
+//
+// TheString = AllocateZeroPool(42 * sizeof(CHAR16));
+// if (TheString != 0) {
+// SPrint (TheString, 82, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+// (UINTN)GuidData->Data1, (UINTN)GuidData->Data2, (UINTN)GuidData->Data3,
+// (UINTN)GuidData->Data4[0], (UINTN)GuidData->Data4[1], (UINTN)GuidData->Data4[2],
+// (UINTN)GuidData->Data4[3], (UINTN)GuidData->Data4[4], (UINTN)GuidData->Data4[5],
+// (UINTN)GuidData->Data4[6], (UINTN)GuidData->Data4[7]);
+// }
+// return TheString;
+// } // GuidAsString(EFI_GUID *GuidData)