util.c File Reference

#include "bl.h"

Include dependency graph for util.c:

Go to the source code of this file.

Functions
NTSTATUS	BlUtlGetAcpiTable (_Out_ PVOID *TableAddress, _In_ ULONG Signature)
VOID	BlUtlUpdateProgress (_In_ ULONG Percentage, _Out_opt_ PBOOLEAN Completed)
NTSTATUS	BlUtlInitialize (VOID)
VOID	BmUpdateProgressInfo (_In_ PVOID Unknown, _In_ PWCHAR ProgressInfo)
VOID	BmUpdateProgress (_In_ PVOID Unknown, _In_ ULONG Percent, _Out_ PBOOLEAN Completed)
NTSTATUS	BlUtlRegisterProgressRoutine (VOID)
PVOID	BlTblFindEntry (_In_ PVOID *Table, _In_ ULONG Count, _Out_ PULONG EntryIndex, _In_ PBL_TBL_LOOKUP_ROUTINE Callback, _In_ PVOID Argument1, _In_ PVOID Argument2, _In_ PVOID Argument3, _In_ PVOID Argument4)
NTSTATUS	BlTblSetEntry (_Inout_ PVOID **Table, _Inout_ PULONG Count, _In_ PVOID Entry, _Out_ PULONG EntryIndex, _In_ PBL_TBL_SET_ROUTINE Callback)
NTSTATUS	BlTblMap (_In_ PVOID *Table, _In_ ULONG Count, _In_ PBL_TBL_MAP_ROUTINE MapCallback)
ULONG	DefaultHashFunction (_In_ PBL_HASH_ENTRY Entry, _In_ ULONG TableSize)
BOOLEAN	HtpCompareKeys (_In_ PBL_HASH_ENTRY Entry1, _In_ PBL_HASH_ENTRY Entry2)
NTSTATUS	TblDoNotPurgeEntry (_In_ PVOID Entry)
NTSTATUS	BlHtCreate (_In_ ULONG Size, _In_ PBL_HASH_TABLE_HASH_FUNCTION HashFunction, _In_ PBL_HASH_TABLE_COMPARE_FUNCTION CompareFunction, _Out_ PULONG Id)
NTSTATUS	BlHtLookup (_In_ ULONG TableId, _In_ PBL_HASH_ENTRY Entry, _Out_opt_ PBL_HASH_VALUE *Value)
NTSTATUS	BlHtStore (_In_ ULONG TableId, _In_ PBL_HASH_ENTRY Entry, _In_ PVOID Data, _In_ ULONG DataSize)
NTSTATUS	BlHtDelete (_In_ ULONG TableId, _In_ PBL_HASH_ENTRY Entry)
ULONG	BlUtlCheckSum (_In_ ULONG PartialSum, _In_ PUCHAR Buffer, _In_ ULONG Length, _In_ ULONG Flags)
BOOLEAN	BlArchIsCpuIdFunctionSupported (_In_ ULONG Function)
ULONGLONG	BlArchGetPerformanceCounter (VOID)
VOID	BlArchCpuId (_In_ ULONG Function, _In_ ULONG SubFunction, _Out_ PCPU_INFO Result)
CPU_VENDORS	BlArchGetCpuVendor (VOID)

Variables
PRSDT	UtlRsdt
PXSDT	UtlXsdt
PVOID	UtlMcContext
PVOID	UtlMcDisplayMessageRoutine
PVOID	UtlMcUpdateMessageRoutine
PVOID	UtlProgressRoutine
PVOID	UtlProgressContext
PVOID	UtlProgressInfoRoutine
ULONG	UtlProgressGranularity
ULONG	UtlCurrentPercentComplete
ULONG	UtlNextUpdatePercentage
BOOLEAN	UtlProgressNeedsInfoUpdate
PVOID	UtlProgressInfo
ULONG	HtTableSize
PBL_HASH_TABLE *	HtTableArray
ULONG	HtTableEntries

Function Documentation

BlArchCpuId()

VOID BlArchCpuId	(	_In_ ULONG	Function,
		_In_ ULONG	SubFunction,
		_Out_ PCPU_INFO	Result
	)

Definition at line 924 of file util.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    /* Use the intrinsic */
    __cpuidex((INT*)Result->AsUINT32, Function, SubFunction);
#endif
}

Referenced by BlArchGetCpuVendor(), BlArchGetPerformanceCounter(), MmArchInitialize(), OslMain(), and OslpMain().

BlArchGetCpuVendor()

CPU_VENDORS BlArchGetCpuVendor

(

VOID

)

Definition at line 937 of file util.c.

{
    CPU_INFO CpuInfo;
    INT Temp;
 
    /* Get the CPU Vendor */
    BlArchCpuId(0, 0, &CpuInfo);
#if defined(_M_IX86) || defined(_M_X64)
    Temp = CpuInfo.Ecx;
    CpuInfo.Ecx = CpuInfo.Edx;
    CpuInfo.Edx = Temp;
 
    /* Check against supported values */
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "GenuineIntel", 12))
    {
        return CPU_INTEL;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "AuthenticAMD", 12))
    {
        return CPU_AMD;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "CentaurHauls", 12))
    {
        return CPU_VIA;
    }
#ifdef _M_IX86
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "CyrixInstead", 12))
    {
        return CPU_CYRIX;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "GenuineTMx86", 12))
    {
        return CPU_TRANSMETA;
    }
    if (!strncmp((PCHAR)&CpuInfo.Ebx, "RiseRiseRise", 12))
    {
        return CPU_RISE;
    }
#endif // _M_IX86
#else // defined(_M_IX86) || defined(_M_X64)
    EfiPrintf(L"BlArchGetCpuVendor not implemented for this platform.\r\n");
#endif
    /* Other */
    return CPU_UNKNOWN;
}

Referenced by OslpMain().

BlArchGetPerformanceCounter()

ULONGLONG BlArchGetPerformanceCounter

(

VOID

)

Definition at line 902 of file util.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    CPU_INFO CpuInfo;
 
    /* Serialize with CPUID, if it exists */
    if (Archx86IsCpuidSupported())
    {
        BlArchCpuId(0, 0, &CpuInfo);
    }
 
    /* Read the TSC */
    return __rdtsc();
#else
    EfiPrintf(L"BlArchGetPerformanceCounter not implemented for this platform.\r\n");
    return 0;
#endif
}

Referenced by MmArchInitialize(), and OslPrepareTarget().

BlArchIsCpuIdFunctionSupported()

BOOLEAN BlArchIsCpuIdFunctionSupported

(

_In_ ULONG

Function

)

Definition at line 856 of file util.c.

{
#if defined(_M_IX86) || defined(_M_X64)
    BOOLEAN Supported;
    INT CpuInfo[4];
 
    /* Check if the CPU supports this instruction */
    Supported = Archx86IsCpuidSupported();
    if (!Supported)
    {
        return FALSE;
    }
 
    /* Check if it's the extended function */
    if (Function >= 0x80000000)
    {
        /* Check if extended functions are supported */
        __cpuid(CpuInfo, 0x80000000);
        if ((CpuInfo[0] & 0xFFFFFF00) != 0x80000000)
        {
            /* Nope */
            return FALSE;
        }
    }
    else
    {
        /* It's a regular function, get the maximum one supported */
        __cpuid(CpuInfo, 0);
    }
 
    /* Check if our function is within bounds */
    if (Function <= CpuInfo[0])
    {
        return TRUE;
    }
#else
    EfiPrintf(L"BlArchIsCpuIdFunctionSupported not implemented for this platform.\r\n");
#endif
 
    /* Nope */
    return FALSE;
}

Referenced by MmArchInitialize(), and OslMain().

BlHtCreate()

NTSTATUS BlHtCreate	(	_In_ ULONG	Size,
		_In_ PBL_HASH_TABLE_HASH_FUNCTION	HashFunction,
		_In_ PBL_HASH_TABLE_COMPARE_FUNCTION	CompareFunction,
		_Out_ PULONG	Id
	)

Definition at line 504 of file util.c.

{
    NTSTATUS Status;
    PBL_HASH_TABLE HashTable;
    ULONG i;
 
    /* Assume failure */
    HashTable = NULL;
 
    /* Can't create a table with no ID */
    if (!Id)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Check if we don't already have a hash table table */
    if (!HtTableSize)
    {
        /* Allocate it and zero it out */
        HtTableSize = 4;
        HtTableArray = BlMmAllocateHeap(HtTableSize * sizeof(PVOID));
        if (!HtTableArray)
        {
            Status = STATUS_NO_MEMORY;
            goto Quickie;
        }
        RtlZeroMemory(HtTableArray, HtTableSize * sizeof(PVOID));
        HtTableEntries = 0;
    }
 
    /* Allocate the hash table */
    HashTable = BlMmAllocateHeap(sizeof(*HashTable));
    if (!HashTable)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Fill it out */
    HashTable->HashFunction = HashFunction ? HashFunction : DefaultHashFunction;
    HashTable->CompareFunction = CompareFunction ? CompareFunction : HtpCompareKeys;
    HashTable->Size = Size ? Size : 13;
 
    /* Allocate the hash links, one for each bucket */
    HashTable->HashLinks = BlMmAllocateHeap(sizeof(LIST_ENTRY) * HashTable->Size);
    if (!HashTable->HashLinks)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Initialize the hash links */
    for (i = 0; i < HashTable->Size; i++)
    {
        InitializeListHead(&HashTable->HashLinks[i]);
    }
 
    /* Save us in the table of hash tables */
    Status = BlTblSetEntry((PVOID**)&HtTableArray,
                           &Size,
                           HashTable,
                           Id,
                           TblDoNotPurgeEntry);
    if (NT_SUCCESS(Status))
    {
        /* One more -- we're done */
        ++HtTableEntries;
        return Status;
    }
 
Quickie:
    /* Check if we just allocated the table array now */
    if (!(HtTableEntries) && (HtTableArray))
    {
        /* Free it */
        BlMmFreeHeap(HtTableArray);
        HtTableArray = NULL;
        HtTableSize = 0;
    }
 
    /* Check if we allocated a hash table*/
    if (HashTable)
    {
        /* With links? */
        if (HashTable->HashLinks)
        {
            /* Free them */
            BlMmFreeHeap(HashTable->HashLinks);
        }
 
        /* Free the table*/
        BlMmFreeHeap(HashTable);
    }
 
    /* We're done */
    return Status;
}

Referenced by BcInitialize(), BlockIopInitialize(), and EfiVmOpenProtocol().

BlHtDelete()

NTSTATUS BlHtDelete	(	_In_ ULONG	TableId,
		_In_ PBL_HASH_ENTRY	Entry
	)

Definition at line 722 of file util.c.

{
    PBL_HASH_TABLE HashTable;
    ULONG HashValue;
    NTSTATUS Status;
    PLIST_ENTRY HashLinkHead, HashLink;
    PBL_HASH_NODE HashNode;
 
    /* Check if the table ID is invalid, or we have no entry, or it's malformed */
    if ((HtTableSize <= TableId) ||
        !(Entry) ||
        !(Entry->Size) ||
        !(Entry->Value) ||
        ((Entry->Flags & BL_HT_VALUE_IS_INLINE) && (Entry->Size != sizeof(ULONG))))
    {
        /* Fail */
        Status = STATUS_INVALID_PARAMETER;
    }
    else
    {
        /* Otherwise, get the hash table for this index */
        HashTable = HtTableArray[TableId];
 
        /* Get the hash bucket */
        HashValue = HashTable->HashFunction(Entry, HashTable->Size);
 
        /* Start iterating each entry in the bucket, assuming failure */
        Status = STATUS_NOT_FOUND;
        HashLinkHead = &HashTable->HashLinks[HashValue];
        HashLink = HashLinkHead->Flink;
        while (HashLink != HashLinkHead)
        {
            /* Get a node in this bucket, and compare the value */
            HashNode = CONTAINING_RECORD(HashLink, BL_HASH_NODE, ListEntry);
            if (HashTable->CompareFunction(&HashNode->Entry, Entry))
            {
                /* Remove it from the list and free it */
                RemoveEntryList(&HashNode->ListEntry);
                BlMmFreeHeap(HashNode);
                return STATUS_SUCCESS;
            }
 
            /* Try the next node */
            HashLink = HashLink->Flink;
        }
    }
 
    /* Return back to the caller */
    return Status;
}

Referenced by BlockIoFirmwareOpen(), and EfiVmpFreeInterfaceEntry().

BlHtLookup()

NTSTATUS BlHtLookup	(	_In_ ULONG	TableId,
		_In_ PBL_HASH_ENTRY	Entry,
		_Out_opt_ PBL_HASH_VALUE *	Value
	)

Definition at line 608 of file util.c.

{
    PBL_HASH_TABLE HashTable;
    ULONG HashValue;
    NTSTATUS Status;
    PLIST_ENTRY HashLinkHead, HashLink;
    PBL_HASH_NODE HashNode;
 
    /* Check if the table ID is invalid, or we have no entry, or it's malformed */
    if ((HtTableSize <= TableId) ||
        !(Entry) ||
        ((Entry->Flags & BL_HT_VALUE_IS_INLINE) && (Entry->Size != sizeof(ULONG))))
    {
        /* Fail */
        Status = STATUS_INVALID_PARAMETER;
    }
    else
    {
        /* Otherwise, get the hash table for this index */
        HashTable = HtTableArray[TableId];
 
        /* Get the hash bucket */
        HashValue = HashTable->HashFunction(Entry, HashTable->Size);
 
        /* Start iterating each entry in the bucket, assuming failure */
        Status = STATUS_NOT_FOUND;
        HashLinkHead = &HashTable->HashLinks[HashValue];
        HashLink = HashLinkHead->Flink;
        while (HashLink != HashLinkHead)
        {
            /* Get a node in this bucket, and compare the value */
            HashNode = CONTAINING_RECORD(HashLink, BL_HASH_NODE, ListEntry);
            if (HashTable->CompareFunction(&HashNode->Entry, Entry))
            {
                /* Does the caller want the value? */
                if (Value)
                {
                    /* Return it */
                    *Value = &HashNode->Value;
                }
 
                /* Return success and stop scanning */
                Status = STATUS_SUCCESS;
                break;
            }
 
            /* Try the next node */
            HashLink = HashLink->Flink;
        }
    }
 
    /* Return back to the caller */
    return Status;
}

BlHtStore()

NTSTATUS BlHtStore	(	_In_ ULONG	TableId,
		_In_ PBL_HASH_ENTRY	Entry,
		_In_ PVOID	Data,
		_In_ ULONG	DataSize
	)

Definition at line 668 of file util.c.

{
    PBL_HASH_NODE HashNode;
    NTSTATUS Status;
    PLIST_ENTRY HashLinkHead;
    PBL_HASH_TABLE HashTable;
 
    /* Check for invalid table ID, missing arguments, or malformed entry */
    if ((HtTableSize <= TableId) ||
        !(Entry) ||
        !(Data) ||
        !(Entry->Size) ||
        !(Entry->Value) ||
        !(DataSize) ||
        ((Entry->Flags & BL_HT_VALUE_IS_INLINE) && (Entry->Size != sizeof(ULONG))))
    {
        /* Fail the call */
        Status = STATUS_INVALID_PARAMETER;
        goto Quickie;
    }
 
    /* Get the hash table for this ID */
    HashTable = HtTableArray[TableId];
 
    /* Allocate a hash node */
    HashNode = BlMmAllocateHeap(sizeof(*HashNode));
    if (!HashNode)
    {
        Status = STATUS_NO_MEMORY;
        goto Quickie;
    }
 
    /* Capture all the data*/
    HashNode->Entry.Size = Entry->Size;
    HashNode->Entry.Flags = Entry->Flags;
    HashNode->Entry.Value = Entry->Value;
    HashNode->Value.DataSize = DataSize;
    HashNode->Value.Data = Data;
 
    /* Insert it into the bucket list and return success */
    HashLinkHead = &HashTable->HashLinks[HashTable->HashFunction(Entry, HashTable->Size)];
    InsertTailList(HashLinkHead, &HashNode->ListEntry);
    Status = STATUS_SUCCESS;
 
Quickie:
    return Status;
}

Referenced by BlockIoFirmwareOpen(), and EfiVmOpenProtocol().

BlTblFindEntry()

PVOID BlTblFindEntry	(	_In_ PVOID *	Table,
		_In_ ULONG	Count,
		_Out_ PULONG	EntryIndex,
		_In_ PBL_TBL_LOOKUP_ROUTINE	Callback,
		_In_ PVOID	Argument1,
		_In_ PVOID	Argument2,
		_In_ PVOID	Argument3,
		_In_ PVOID	Argument4
	)

Definition at line 273 of file util.c.

{
    PVOID Entry = NULL;
    ULONG Index;
    BOOLEAN Result;
 
    /* Check for invalid parameters */
    if (!(Table) || !(EntryIndex))
    {
        return Entry;
    }
 
    /* Loop each entry in the table */
    for (Index = 0; Index < Count;  Index++)
    {
        /* Check if this entry is filled out */
        if (Table[Index])
        {
            /* Call the comparison function */
            Result = Callback(Table[Index],
                              Argument1,
                              Argument2,
                              Argument3,
                              Argument4);
            if (Result)
            {
                /* Entry found return it */
                *EntryIndex = Index;
                Entry = Table[Index];
                break;
            }
        }
    }
 
    /* Return the entry that was (or wasn't) found */
    return Entry;
}

Referenced by BlockIoOpen(), BlpDeviceOpen(), FileIoOpen(), and MmBapFindBlockInformation().

BlTblMap()

NTSTATUS BlTblMap	(	_In_ PVOID *	Table,
		_In_ ULONG	Count,
		_In_ PBL_TBL_MAP_ROUTINE	MapCallback
	)

Definition at line 399 of file util.c.

{
    NTSTATUS Status, LocalStatus;
    PVOID Entry;
    ULONG Index;
 
    /* Bail out if there's no table */
    if (!Table)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Assume success and loop each index */
    Status = STATUS_SUCCESS;
    for (Index = 0; Index < Count; Index++)
    {
        /* See if an entry exists at this index */
        Entry = Table[Index];
        if (Entry)
        {
            /* Call the map routine for this entry */
            LocalStatus = MapCallback(Entry, Index);
            if (!NT_SUCCESS(LocalStatus))
            {
                /* Propagate failure only */
                Status = LocalStatus;
            }
        }
    }
 
    /* Return status to caller */
    return Status;
}

Referenced by BlockIoDeviceTableDestroy().

BlTblSetEntry()

NTSTATUS BlTblSetEntry	(	_Inout_ PVOID **	Table,
		_Inout_ PULONG	Count,
		_In_ PVOID	Entry,
		_Out_ PULONG	EntryIndex,
		_In_ PBL_TBL_SET_ROUTINE	Callback
	)

Definition at line 321 of file util.c.

{
    ULONG NewCount;
    NTSTATUS Status = STATUS_SUCCESS;
    ULONG Index = 0;
    PVOID* NewTable;
 
    /* Make sure all the parameters were specified */
    if (!(Table) || !(*Table) || !(Count) || !(Callback))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Read the current table */
    NewTable = *Table;
    NewCount = *Count;
 
    /* Iterate over it */
    while (Index < NewCount)
    {
        /* Look for a free index */
        if (!NewTable[Index])
        {
            goto SetIndex;
        }
 
        /* No free index yet, keep going */
        ++Index;
    }
 
    /* No free index was found, try to purge some entries */
    Index = 0;
    while (Index < NewCount)
    {
        /* Call each purge callback, trying to make space */
        Status = Callback(NewTable[Index]);
        if (NT_SUCCESS(Status))
        {
            /* We should have this slot available now */
            goto SetIndex;
        }
 
        /* Keep trying to purge more */
        ++Index;
    }
 
    /* Double the table */
    NewTable = BlMmAllocateHeap(2 * sizeof(PVOID) * NewCount);
    if (!NewTable)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* Clear the new table, and copy the old entries */
    RtlZeroMemory(&NewTable[NewCount], sizeof(PVOID) * NewCount);
    RtlCopyMemory(NewTable, *Table, sizeof(PVOID) * NewCount);
 
    /* Free the old table */
    BlMmFreeHeap(*Table);
 
    /* Return the new table and count */
    *Count = 2 * NewCount;
    *Table = NewTable;
 
SetIndex:
    /* Set the index and return */
    NewTable[Index] = Entry;
    *EntryIndex = Index;
    return Status;
}

Referenced by BlHtCreate(), BlImgLoadBootApplication(), BlockIoFirmwareOpen(), BlpDeviceOpen(), BlpIoRegisterDestroyRoutine(), BlpMmCreateBlockAllocator(), EtfsMount(), and FileIoOpen().

BlUtlCheckSum()

ULONG BlUtlCheckSum	(	_In_ ULONG	PartialSum,
		_In_ PUCHAR	Buffer,
		_In_ ULONG	Length,
		_In_ ULONG	Flags
	)

Definition at line 777 of file util.c.

{
    ULONG i;
 
    if (Flags & BL_UTL_CHECKSUM_UCHAR_BUFFER)
    {
        EfiPrintf(L"Not supported\r\n");
        return 0;
    }
    else if (Flags & BL_UTL_CHECKSUM_USHORT_BUFFER)
    {
        PartialSum = (unsigned __int16)PartialSum;
        Length &= ~1;
 
        for (i = 0; i < Length; i += 2)
        {
            PartialSum += *(unsigned __int16 *)&Buffer[i];
            if (Flags & BL_UTL_CHECKSUM_COMPLEMENT)
            {
                PartialSum = (unsigned __int16)((PartialSum >> 16) + PartialSum);
            }
        }
 
        if (i != Length)
        {
            PartialSum += (unsigned __int8)Buffer[Length];
            if (Flags & BL_UTL_CHECKSUM_COMPLEMENT)
            {
                PartialSum = (unsigned __int16)((PartialSum >> 16) + PartialSum);
            }
        }
 
        if (Flags & BL_UTL_CHECKSUM_NEGATE)
        {
            return ~PartialSum;
        }
 
        PartialSum = (unsigned __int16)PartialSum;
    }
    else
    {
        /* Invalid mode */
        return 0;
    }
 
    if (Flags & BL_UTL_CHECKSUM_NEGATE)
    {
        return ~PartialSum;
    }
 
    return PartialSum;
}

Referenced by ImgpLoadPEImage().

BlUtlGetAcpiTable()

NTSTATUS BlUtlGetAcpiTable	(	_Out_ PVOID *	TableAddress,
		_In_ ULONG	Signature
	)

Definition at line 34 of file util.c.

{
    ULONG i, TableCount, HeaderLength;
    NTSTATUS Status;
    PRSDT Rsdt;
    PXSDT Xsdt;
    PHYSICAL_ADDRESS PhysicalAddress;
    PDESCRIPTION_HEADER Header;
 
    Header = 0;
 
    /* Make sure there's an output parameter */
    if (!TableAddress)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Get the currently known RSDT and XSDT */
    Rsdt = (PRSDT)UtlRsdt;
    Xsdt = (PXSDT)UtlXsdt;
 
    /* Is there an RSDT? */
    if (!Rsdt)
    {
        /* No -- is there an XSDT? */
        if (!Xsdt)
        {
            /* No. Look up the RSDT */
            Status = EfipGetRsdt(&PhysicalAddress);
            if (!NT_SUCCESS(Status))
            {
                EfiPrintf(L"no rsdp found\r\n");
                return Status;
            }
 
            /* Map the header */
            Status = BlMmMapPhysicalAddressEx((PVOID)&Header,
                                              0,
                                              sizeof(*Header),
                                              PhysicalAddress);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Unmap the header */
            BlMmUnmapVirtualAddressEx(Header, sizeof(*Header));
 
            /* Map the whole table */
            Status = BlMmMapPhysicalAddressEx((PVOID)&Header,
                                              0,
                                              Header->Length,
                                              PhysicalAddress);
            if (!NT_SUCCESS(Status))
            {
                return Status;
            }
 
            /* Check if its an XSDT or an RSDT */
            if (Header->Signature == XSDT_SIGNATURE)
            {
                /* It's an XSDT */
                Xsdt = (PXSDT)Header;
                UtlXsdt = Xsdt;
            }
            else
            {
                /* It's an RSDT */
                Rsdt = (PRSDT)Header;
                UtlRsdt = Rsdt;
            }
        }
    }
 
    /* OK, so do we have an XSDT after all? */
    if (Xsdt)
    {
        /* Yes... how big is it? */
        HeaderLength = Xsdt->Header.Length;
        if (HeaderLength >= sizeof(*Header))
        {
            HeaderLength = sizeof(*Header);
        }
 
        /* Based on that, how many tables are there? */
        TableCount = (Xsdt->Header.Length - HeaderLength) / sizeof(PHYSICAL_ADDRESS);
    }
    else
    {
        /* Nope, we have an RSDT. How big is it? */
        HeaderLength = Rsdt->Header.Length;
        if (HeaderLength >= sizeof(*Header))
        {
            HeaderLength = sizeof(*Header);
        }
 
        /* Based on that, how many tables are there? */
        TableCount = (Rsdt->Header.Length - HeaderLength) / sizeof(ULONG);
    }
 
    /* Loop through the ACPI tables */
    for (i = 0; i < TableCount; i++)
    {
        /* For an XSDT, read the 64-bit address directly */
        if (Xsdt)
        {
            PhysicalAddress = Xsdt->Tables[i];
        }
        else
        {
            /* For RSDT, cast it */
            PhysicalAddress.QuadPart = Rsdt->Tables[i];
        }
 
        /* Map the header */
        Status = BlMmMapPhysicalAddressEx((PVOID)&Header,
                                          0,
                                          sizeof(*Header),
                                          PhysicalAddress);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Is it the right one? */
        if (Header->Signature == Signature)
        {
            /* Unmap the header */
            BlMmUnmapVirtualAddressEx(Header, sizeof(*Header));
 
            /* Map the whole table */
            return BlMmMapPhysicalAddressEx(TableAddress,
                                            0,
                                            Header->Length,
                                            PhysicalAddress);
        }
    }
 
    /* Requested table does not exist */
    return STATUS_NOT_FOUND;
}

Referenced by BlDisplayGetOemBitmap(), and BlDisplayInvalidateOemBitmap().

BlUtlInitialize()

NTSTATUS BlUtlInitialize

(

VOID

)

Definition at line 197 of file util.c.

{
    UtlRsdt = 0;
    UtlXsdt = 0;
 
    UtlMcContext = 0;
    UtlMcDisplayMessageRoutine = 0;
    UtlMcUpdateMessageRoutine = 0;
 
    UtlProgressRoutine = 0;
    UtlProgressContext = 0;
    UtlProgressInfoRoutine = 0;
    UtlProgressGranularity = 0;
    UtlCurrentPercentComplete = 0;
    UtlNextUpdatePercentage = 0;
    UtlProgressNeedsInfoUpdate = 0;
    UtlProgressInfo = 0;
 
    return STATUS_SUCCESS;
}

Referenced by InitializeLibrary().

BlUtlRegisterProgressRoutine()

NTSTATUS BlUtlRegisterProgressRoutine

(

VOID

)

Definition at line 244 of file util.c.

{
    /* One shouldn't already exist */
    if (UtlProgressRoutine)
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Set the routine, and no context */
    UtlProgressRoutine = BmUpdateProgress;
    UtlProgressContext = NULL;
 
    /* Progress increases by one */
    UtlProgressGranularity = 1;
 
    /* Set progress to zero for now */
    UtlCurrentPercentComplete = 0;
    UtlNextUpdatePercentage = 0;
 
    /* Set the info routine if there is one */
    UtlProgressInfoRoutine = BmUpdateProgressInfo;
 
    /* All good */
    return STATUS_SUCCESS;
}

Referenced by BmMain().

BlUtlUpdateProgress()

VOID BlUtlUpdateProgress	(	_In_ ULONG	Percentage,
		_Out_opt_ PBOOLEAN	Completed
	)

Definition at line 181 of file util.c.

{
    if (UtlProgressRoutine)
    {
        EfiPrintf(L"Unimplemented\r\n");
    }
    else if (*Completed)
    {
        *Completed = TRUE;
    }
}

Referenced by BlImgLoadImageWithProgress2().

BmUpdateProgress()

VOID BmUpdateProgress	(	_In_ PVOID	Unknown,
		_In_ ULONG	Percent,
		_Out_ PBOOLEAN	Completed
	)

Definition at line 230 of file util.c.

{
    EfiPrintf(L"Progress: %d\r\n", Percent);
    if (Completed)
    {
        *Completed = TRUE;
    }
}

Referenced by BlUtlRegisterProgressRoutine().

BmUpdateProgressInfo()

VOID BmUpdateProgressInfo	(	_In_ PVOID	Unknown,
		_In_ PWCHAR	ProgressInfo
	)

Definition at line 221 of file util.c.

{
    EfiPrintf(L"Progress Info: %s\r\n", ProgressInfo);
}

Referenced by BlUtlRegisterProgressRoutine().

DefaultHashFunction()

ULONG DefaultHashFunction	(	_In_ PBL_HASH_ENTRY	Entry,
		_In_ ULONG	TableSize
	)

Definition at line 442 of file util.c.

{
    PUCHAR Value;
    ULONG KeyHash, i;
 
    /* Check if the value is a pointer, or embedded inline */
    Value = (Entry->Flags & BL_HT_VALUE_IS_INLINE) ? Entry->Value : (PUCHAR)&Entry->Value;
 
    /* Iterate over each byte, and sum it */
    for (i = 0, KeyHash = 0; i < Entry->Size; i++)
    {
        KeyHash += Value[i++];
    }
 
    /* Modulo the number of buckets */
    return KeyHash % TableSize;
}

Referenced by BlHtCreate().

HtpCompareKeys()

BOOLEAN HtpCompareKeys	(	_In_ PBL_HASH_ENTRY	Entry1,
		_In_ PBL_HASH_ENTRY	Entry2
	)

Definition at line 464 of file util.c.

{
    ULONG Flags;
    BOOLEAN ValueMatch;
 
    /* Check if the flags or sizes are not matching */
    Flags = Entry1->Flags;
    if ((Entry1->Size != Entry2->Size) || (Flags != Entry2->Flags))
    {
        ValueMatch = FALSE;
    }
    else if (Flags & BL_HT_VALUE_IS_INLINE)
    {
        /* Check if this is an in-line value, compare it */
        ValueMatch = Entry1->Value == Entry2->Value;
    }
    else
    {
        /* This is a pointer value, compare it */
        ValueMatch = (RtlCompareMemory(Entry1->Value, Entry2->Value, Entry1->Size) ==
                      Entry1->Size);
    }
 
    /* Return if it matched */
    return ValueMatch;
}

Referenced by BlHtCreate().

TblDoNotPurgeEntry()

NTSTATUS TblDoNotPurgeEntry

(

_In_ PVOID

Entry

)

Definition at line 495 of file util.c.

{
    /* Never purge this entry */
    return STATUS_UNSUCCESSFUL;
}

Referenced by BlHtCreate(), BlImgLoadBootApplication(), BlockIoFirmwareOpen(), BlpIoRegisterDestroyRoutine(), and EtfsMount().

Variable Documentation

HtTableArray

PBL_HASH_TABLE* HtTableArray

Definition at line 438 of file util.c.

Referenced by BlHtCreate(), BlHtDelete(), BlHtLookup(), and BlHtStore().

HtTableEntries

ULONG HtTableEntries

Definition at line 439 of file util.c.

Referenced by BlHtCreate().

HtTableSize

ULONG HtTableSize

Definition at line 437 of file util.c.

Referenced by BlHtCreate(), BlHtDelete(), BlHtLookup(), and BlHtStore().

UtlCurrentPercentComplete

ULONG UtlCurrentPercentComplete

Definition at line 26 of file util.c.

Referenced by BlUtlInitialize(), and BlUtlRegisterProgressRoutine().

UtlMcContext

PVOID UtlMcContext

Definition at line 18 of file util.c.

Referenced by BlUtlInitialize().

UtlMcDisplayMessageRoutine

PVOID UtlMcDisplayMessageRoutine

Definition at line 19 of file util.c.

Referenced by BlUtlInitialize().

UtlMcUpdateMessageRoutine

PVOID UtlMcUpdateMessageRoutine

Definition at line 20 of file util.c.

Referenced by BlUtlInitialize().

UtlNextUpdatePercentage

ULONG UtlNextUpdatePercentage

Definition at line 27 of file util.c.

Referenced by BlUtlInitialize(), and BlUtlRegisterProgressRoutine().

UtlProgressContext

PVOID UtlProgressContext

Definition at line 23 of file util.c.

Referenced by BlUtlInitialize(), and BlUtlRegisterProgressRoutine().

UtlProgressGranularity

ULONG UtlProgressGranularity

Definition at line 25 of file util.c.

Referenced by BlUtlInitialize(), and BlUtlRegisterProgressRoutine().

UtlProgressInfo

PVOID UtlProgressInfo

Definition at line 29 of file util.c.

Referenced by BlUtlInitialize().

UtlProgressInfoRoutine

PVOID UtlProgressInfoRoutine

Definition at line 24 of file util.c.

Referenced by BlUtlInitialize(), and BlUtlRegisterProgressRoutine().

UtlProgressNeedsInfoUpdate

BOOLEAN UtlProgressNeedsInfoUpdate

Definition at line 28 of file util.c.

Referenced by BlUtlInitialize().

UtlProgressRoutine

PVOID UtlProgressRoutine

Definition at line 22 of file util.c.

Referenced by BlUtlInitialize(), BlUtlRegisterProgressRoutine(), and BlUtlUpdateProgress().

UtlRsdt

PRSDT UtlRsdt

Definition at line 15 of file util.c.

Referenced by BlUtlGetAcpiTable(), and BlUtlInitialize().

UtlXsdt

PXSDT UtlXsdt

Definition at line 16 of file util.c.

Referenced by BlUtlGetAcpiTable(), and BlUtlInitialize().