X-Git-Url: https://code.delx.au/refind/blobdiff_plain/f06fd828a5e1a814986707a9f3b233553995d5f2..0189958c722bdd4e7f323d59f81e25579bb0aad2:/refind/lib.c diff --git a/refind/lib.c b/refind/lib.c index 4989076..a3a8cfe 100644 --- a/refind/lib.c +++ b/refind/lib.c @@ -427,21 +427,31 @@ static CHAR16 *FSTypeName(IN UINT32 TypeCode) { 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; +// Identify the filesystem type and record the filesystem's UUID/serial number, +// if possible. Expects a Buffer containing the first few (normally 4096) bytes +// of the filesystem. Sets the filesystem type code in Volume->FSType and the +// UUID/serial number in Volume->VolUuid. Note that the UUID value is recognized +// differently for each filesystem, and is currently supported only for +// ext2/3/4fs and ReiserFS. If the UUID can't be determined, it's set to 0. Also, the UUID +// is just read directly into memory; it is *NOT* valid when displayed by +// GuidAsString() or used in other GUID/UUID-manipulating functions. (As I +// write, it's being used merely to detect partitions that are part of a +// RAID 1 array.) +static VOID SetFilesystemData(IN UINT8 *Buffer, IN UINTN BufferSize, IN OUT REFIT_VOLUME *Volume) { UINT32 *Ext2Incompat, *Ext2Compat; UINT16 *Magic16; char *MagicString; - if (Buffer != NULL) { + if ((Buffer != NULL) && (Volume != NULL)) { + SetMem(&(Volume->VolUuid), sizeof(EFI_GUID), 0); + Volume->FSType = FS_TYPE_UNKNOWN; if (BufferSize >= 512) { Magic16 = (UINT16*) (Buffer + 510); - if (*Magic16 == FAT_MAGIC) - return FS_TYPE_FAT; + if (*Magic16 == FAT_MAGIC) { + Volume->FSType = FS_TYPE_FAT; + return; + } // if } // search for FAT magic if (BufferSize >= (1024 + 100)) { @@ -450,40 +460,46 @@ static UINT32 IdentifyFilesystemType(IN UINT8 *Buffer, IN UINTN BufferSize) { 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; + Volume->FSType = FS_TYPE_EXT4; } else if (*Ext2Compat & 0x0004) { // check for journal - return FS_TYPE_EXT3; + Volume->FSType = FS_TYPE_EXT3; } else { // none of these features; presume it's ext2... - return FS_TYPE_EXT2; + Volume->FSType = FS_TYPE_EXT2; } + CopyMem(&(Volume->VolUuid), Buffer + 1024 + 104, sizeof(EFI_GUID)); + return; } } // search for ext2/3/4 magic - if (BufferSize >= (65536 + 62)) { + if (BufferSize >= (65536 + 100)) { MagicString = (char*) (Buffer + 65536 + 52); if ((CompareMem(MagicString, REISERFS_SUPER_MAGIC_STRING, 8) == 0) || (CompareMem(MagicString, REISER2FS_SUPER_MAGIC_STRING, 9) == 0) || (CompareMem(MagicString, REISER2FS_JR_SUPER_MAGIC_STRING, 9) == 0)) { - return FS_TYPE_REISERFS; + Volume->FSType = FS_TYPE_REISERFS; + CopyMem(&(Volume->VolUuid), Buffer + 65536 + 84, sizeof(EFI_GUID)); + return; } // if } // search for ReiserFS magic if (BufferSize >= (65536 + 64 + 8)) { MagicString = (char*) (Buffer + 65536 + 64); - if (CompareMem(MagicString, BTRFS_SIGNATURE, 8) == 0) - return FS_TYPE_BTRFS; + if (CompareMem(MagicString, BTRFS_SIGNATURE, 8) == 0) { + Volume->FSType = FS_TYPE_BTRFS; + return; + } // if } // search for Btrfs magic if (BufferSize >= (1024 + 2)) { Magic16 = (UINT16*) (Buffer + 1024); if ((*Magic16 == HFSPLUS_MAGIC1) || (*Magic16 == HFSPLUS_MAGIC2)) { - return FS_TYPE_HFSPLUS; + Volume->FSType = FS_TYPE_HFSPLUS; + return; } } // search for HFS+ magic } // if (Buffer != NULL) - return FoundType; -} // UINT32 IdentifyFilesystemType() +} // UINT32 SetFilesystemData() static VOID ScanVolumeBootcode(REFIT_VOLUME *Volume, BOOLEAN *Bootable) { @@ -509,7 +525,7 @@ static VOID ScanVolumeBootcode(REFIT_VOLUME *Volume, BOOLEAN *Bootable) Volume->BlockIOOffset, SAMPLE_SIZE, Buffer); if (!EFI_ERROR(Status)) { - Volume->FSType = IdentifyFilesystemType(Buffer, SAMPLE_SIZE); + SetFilesystemData(Buffer, SAMPLE_SIZE, Volume); if ((*((UINT16 *)(Buffer + 510)) == 0xaa55 && Buffer[0] != 0) && (FindMem(Buffer, 512, "EXFAT", 5) == -1)) { *Bootable = TRUE; Volume->HasBootCode = TRUE; @@ -950,6 +966,8 @@ VOID ScanVolumes(VOID) UINTN PartitionIndex; UINTN SectorSum, i, VolNumber = 0; UINT8 *SectorBuffer1, *SectorBuffer2; + EFI_GUID *UuidList; + EFI_GUID NullUuid = { 00000000, 0000, 0000, {0000, 0000, 0000, 0000} }; MyFreePool(Volumes); Volumes = NULL; @@ -957,6 +975,7 @@ VOID ScanVolumes(VOID) // get all filesystem handles Status = LibLocateHandle(ByProtocol, &BlockIoProtocol, NULL, &HandleCount, &Handles); + UuidList = AllocateZeroPool(sizeof(EFI_GUID) * HandleCount); // was: &FileSystemProtocol if (Status == EFI_NOT_FOUND) { return; // no filesystems. strange, but true... @@ -969,6 +988,15 @@ VOID ScanVolumes(VOID) Volume = AllocateZeroPool(sizeof(REFIT_VOLUME)); Volume->DeviceHandle = Handles[HandleIndex]; ScanVolume(Volume); + if (UuidList) { + UuidList[HandleIndex] = Volume->VolUuid; + for (i = 0; i < HandleIndex; i++) { + if ((CompareMem(&(Volume->VolUuid), &(UuidList[i]), sizeof(EFI_GUID)) == 0) && + (CompareMem(&(Volume->VolUuid), &NullUuid, sizeof(EFI_GUID)) != 0)) { // Duplicate filesystem UUID + Volume->IsReadable = FALSE; + } // if + } // for + } // if if (Volume->IsReadable) Volume->VolNumber = VolNumber++; else @@ -1520,7 +1548,8 @@ CHAR16 *FindPath(IN CHAR16* FullPath) { LastBackslash = i; } // for PathOnly = StrDuplicate(FullPath); - PathOnly[LastBackslash] = 0; + if (PathOnly != NULL) + PathOnly[LastBackslash] = 0; } // if return (PathOnly); } @@ -1653,6 +1682,61 @@ CHAR16 *FindCommaDelimited(IN CHAR16 *InString, IN UINTN Index) { return (FoundString); } // CHAR16 *FindCommaDelimited() +// Return the position of SmallString within BigString, or -1 if +// not found. +INTN FindSubString(IN CHAR16 *SmallString, IN CHAR16 *BigString) { + INTN Position = -1; + UINTN i = 0, SmallSize, BigSize; + BOOLEAN Found = FALSE; + + if ((SmallString == NULL) || (BigString == NULL)) + return -1; + + SmallSize = StrLen(SmallString); + BigSize = StrLen(BigString); + if ((SmallSize > BigSize) || (SmallSize == 0) || (BigSize == 0)) + return -1; + + while ((i <= (BigSize - SmallSize) && !Found)) { + if (CompareMem(BigString + i, SmallString, SmallSize) == 0) { + Found = TRUE; + Position = i; + } // if + i++; + } // while() + return Position; +} // INTN FindSubString() + +// Take an input path name, which may include a volume specification and/or +// a path, and return separate volume, path, and file names. For instance, +// "BIGVOL:\EFI\ubuntu\grubx64.efi" will return a VolName of "BIGVOL", a Path +// of "EFI\ubuntu", and a Filename of "grubx64.efi". If an element is missing, +// the returned pointer is NULL. The calling function is responsible for +// freeing the allocated memory. +VOID SplitPathName(CHAR16 *InPath, CHAR16 **VolName, CHAR16 **Path, CHAR16 **Filename) { + CHAR16 *Temp = NULL; + + MyFreePool(*VolName); + MyFreePool(*Path); + MyFreePool(*Filename); + *VolName = *Path = *Filename = NULL; + Temp = StrDuplicate(InPath); + SplitVolumeAndFilename(&Temp, VolName); // VolName is NULL or has volume; Temp has rest of path + CleanUpPathNameSlashes(Temp); + *Path = FindPath(Temp); // *Path has path (may be 0-length); Temp unchanged. + *Filename = StrDuplicate(Temp + StrLen(*Path)); + CleanUpPathNameSlashes(*Filename); + if (StrLen(*Path) == 0) { + MyFreePool(*Path); + *Path = NULL; + } + if (StrLen(*Filename) == 0) { + MyFreePool(*Filename); + *Filename = NULL; + } + MyFreePool(Temp); +} // VOID SplitPathName + // Returns TRUE if SmallString is an element in the comma-delimited List, // FALSE otherwise. Performs comparison case-insensitively (except on // buggy EFIs with case-sensitive StriCmp() functions). @@ -1667,9 +1751,63 @@ BOOLEAN IsIn(IN CHAR16 *SmallString, IN CHAR16 *List) { Found = TRUE; } // while } // if - return Found; + return Found; } // BOOLEAN IsIn() +// Returns TRUE if specified Volume, Directory, and Filename correspond to an +// element in the comma-delimited List, FALSE otherwise. Note that Directory and +// Filename must *NOT* include a volume or path specification (that's part of +// the Volume variable), but the List elements may. Performs comparison +// case-insensitively (except on buggy EFIs with case-sensitive StriCmp() +// functions). +BOOLEAN FilenameIn(REFIT_VOLUME *Volume, CHAR16 *Directory, CHAR16 *Filename, CHAR16 *List) { + UINTN i = 0; + BOOLEAN Found = FALSE; + CHAR16 *OneElement; + CHAR16 *TargetVolName = NULL, *TargetPath = NULL, *TargetFilename = NULL; + + if (Filename && List) { + while (!Found && (OneElement = FindCommaDelimited(List, i++))) { + Found = TRUE; + SplitPathName(OneElement, &TargetVolName, &TargetPath, &TargetFilename); + VolumeNumberToName(Volume, &TargetVolName); + if (((TargetVolName != NULL) && ((Volume == NULL) || (StriCmp(TargetVolName, Volume->VolName) != 0))) || + ((TargetPath != NULL) && (StriCmp(TargetPath, Directory) != 0)) || + ((TargetFilename != NULL) && (StriCmp(TargetFilename, Filename) != 0))) { + Found = FALSE; + } // if + MyFreePool(OneElement); + } // while + } // if + + MyFreePool(TargetVolName); + MyFreePool(TargetPath); + MyFreePool(TargetFilename); + return Found; +} // BOOLEAN FilenameIn() + +// If *VolName is of the form "fs#", where "#" is a number, and if Volume points +// to this volume number, returns with *VolName changed to the volume name, as +// stored in the Volume data structure. +// Returns TRUE if this substitution was made, FALSE otherwise. +BOOLEAN VolumeNumberToName(REFIT_VOLUME *Volume, CHAR16 **VolName) { + BOOLEAN MadeSubstitution = FALSE; + UINTN VolNum; + + if ((VolName == NULL) || (*VolName == NULL)) + return FALSE; + + if ((StrLen(*VolName) > 2) && (*VolName[0] == L'f') && (*VolName[1] == L's') && (*VolName[2] >= L'0') && (*VolName[2] <= L'9')) { + VolNum = Atoi(*VolName + 2); + if (VolNum == Volume->VolNumber) { + MyFreePool(*VolName); + *VolName = StrDuplicate(Volume->VolName); + MadeSubstitution = TRUE; + } // if + } // if + return MadeSubstitution; +} // BOOLEAN VolumeMatchesNumber() + // 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 VOID *Pointer) {