OS_Develop/WindowsXP
OS_Develop/WindowsXP
1
0
Fork 0
Code Pull Requests Activity
master
WindowsXP/Source/XPSP1/NT/base/efiutil/diskpart/diskpart.c

1973 lines
47 KiB
C
Raw Permalink Normal View History

Initial commit
2024-08-03 16:30:48 +02:00
/*
Module Name:
DiskPart - GUID Partition Table scheme disk partitioning program.
(The GPT version of FDISK, if you will)
Abstract:
Revision History
*/
#include "DiskPart.h"
#include "symbols.h"
#include "helpmsg.h"
//
// Globals
//
UINTN DebugLevel = DEBUG_NONE;
//UINTN DebugLevel = DEBUG_OPPROMPT;
EFI_STATUS status;
EFI_HANDLE *DiskHandleList = NULL;
INTN DiskHandleCount = 0;
INTN SelectedDisk = -1;
EFI_HANDLE SavedImageHandle;
EFI_STATUS ParseAndExecuteCommands();
BOOLEAN ExecuteSingleCommand(CHAR16 *Token[]);
VOID DumpGPT(
EFI_HANDLE DiskHandle,
PGPT_HEADER Header,
PGPT_TABLE Table,
BOOLEAN Raw,
BOOLEAN Verbose
);
VOID
PrintGptEntry(
GPT_ENTRY *Entry,
UINTN Index
);
EFI_GUID
GetGUID(
);
#define CLEAN_RANGE (1024*1024)
CHAR16 *TokenChar =
L"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()-_+[]{}':;/?.>,<\\|";
VOID CmdInspectMBR(CHAR16 **Token);
VOID CmdCreateMBR(CHAR16 **Token);
VOID CmdNewMBR(CHAR16 **Token);
VOID CmdDeleteMBR(CHAR16 **Token);
//
// Worker function type
//
typedef
BOOLEAN
(*PCMD_FUNCTION)(
CHAR16 **Token
);
EFI_STATUS
ReinstallFSDStack(
);
//
// The parse table structure
//
typedef struct {
CHAR16 *Name;
PCMD_FUNCTION Function;
CHAR16 *HelpSummary;
} CMD_ENTRY;
//
// The parse/command table
//
CMD_ENTRY CmdTable[] = {
{ STR_LIST, CmdList, MSG_LIST },
{ STR_SELECT, CmdSelect, MSG_SELECT },
{ STR_INSPECT, CmdInspect, MSG_INSPECT },
{ STR_CLEAN, CmdClean, MSG_CLEAN },
{ STR_NEW, CmdNew, MSG_NEW },
{ STR_FIX, CmdFix, MSG_FIX },
{ STR_CREATE, CmdCreate, MSG_CREATE },
{ STR_DELETE, CmdDelete, MSG_DELETE },
{ STR_HELP, CmdHelp, MSG_HELP },
{ STR_HELP2, CmdHelp, MSG_ABBR_HELP },
{ STR_HELP3, CmdHelp, MSG_ABBR_HELP },
{ STR_EXIT, CmdExit, MSG_EXIT },
{ STR_SYMBOLS, CmdSymbols, MSG_SYMBOLS },
{ STR_REMARK, CmdRemark, MSG_REMARK },
{ STR_MAKE, CmdMake, MSG_MAKE },
{ STR_DEBUG, CmdDebug, NULL },
{ STR_ABOUT, CmdAbout, MSG_ABOUT },
{ NULL, NULL, NULL }
};
EFI_STATUS
EfiMain(
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
//
// Initialize the Library.
//
SavedImageHandle = ImageHandle;
InitializeLib (ImageHandle, SystemTable);
Print(L"DiskPart Version 0.2\n");
Print(L"Based on EFI core release ");
Print(MSG_ABOUT02,
EFI_SPECIFICATION_MAJOR_REVISION,
EFI_SPECIFICATION_MINOR_REVISION,
EFI_FIRMWARE_MAJOR_REVISION,
EFI_FIRMWARE_MINOR_REVISION
);
//
// See if there are any disks that look like candidates to be partitioned
//
status = FindPartitionableDevices(&DiskHandleList, &DiskHandleCount);
if (EFI_ERROR(status)) {
Print(L"%s\n", MSG_NO_DISKS);
return EFI_NOT_FOUND;
}
//
// Start Parse Loop
//
ParseAndExecuteCommands();
ReinstallFSDStack();
DoFree(DiskHandleList);
return status;
}
EFI_STATUS
ReinstallFSDStack(
)
/*++
Make sure that the partition driver is alerted to the changes in the
the file system structures. One way to effect this end is to
reinstall all of the blkio interfaces such that the partition driver
will receive a notification and probe the partition tables to reconstruct
the file system stack.
--*/
{
INTN Index;
EFI_STATUS Status;
EFI_BLOCK_IO *IBlkIo;
Status = EFI_SUCCESS;
for (Index = 0; Index < DiskHandleCount; Index++) {
Status = BS->HandleProtocol(
DiskHandleList[Index],
&BlockIoProtocol,
&IBlkIo
);
if (!EFI_ERROR(Status)) {
Status = BS->ReinstallProtocolInterface (
DiskHandleList[Index],
&BlockIoProtocol,
IBlkIo,
IBlkIo
);
}
}
return Status;
}
EFI_STATUS
ParseAndExecuteCommands()
/*
ParseAndExecuteCommands reads 1 line at a time from stdin.
Lines are parsed for commands and arguments.
The symbol ";" (semicolon) is used to mark the end of a command
and start a new one.
\ is the escape, \\ => '\'
All commands are upper cased before parsing to give us
case insensitive operations. This does not apply to literal
strings.
Any white space is treated a token separator.
Commandline is set quite long.
*/
{
CHAR16 *Prompt = MSG_PROMPT;
CHAR16 CommandLine[COMMAND_LINE_MAX];
CHAR16 *Token[TOKEN_COUNT_MAX];
UINTN i;
NewLine:
while (TRUE) {
for (i = 0; i < COMMAND_LINE_MAX; i++ ) {
CommandLine[i] = NUL;
}
Input(Prompt, CommandLine, COMMAND_LINE_MAX);
Print(L"\n");
if (CommandLine[0] == NUL) {
continue;
}
StrUpr(CommandLine);
Tokenize(CommandLine, Token);
if (Token[0] == (CHAR16 *)-1) {
//
// syntax error
//
Print(L"???\n");
goto NewLine;
}
if (ExecuteSingleCommand(Token) == TRUE) {
return TRUE;
}
if (DebugLevel >= DEBUG_ERRPRINT) {
if (EFI_ERROR(status)) {
Print(L"status = %x %r\n", status, status);
}
}
}
return EFI_SUCCESS;
}
VOID
Tokenize(
CHAR16 *CommandLine,
CHAR16 *Token[]
)
/*
Tokenize -
find the tokens, where a token is any string of letter & numbers.
tokens to contain blanks, etc, must begin end with "
return
Token[] set. if Token[0] = NULL, nothing in THIS command
*/
{
CHAR16 *ch;
UINTN tx;
//
// init the token array
//
for (tx = 0; tx < TOKEN_COUNT_MAX; tx++) {
Token[tx] = NULL;
}
tx = 0;
//
// sweep for tokens
//
ch = CommandLine;
while (TRUE) {
//
// if we see a quote, advance to the closing quote
// and call the result a token.
//
if (*ch == '"') {
ch++;
Token[tx] = ch;
while ((*ch != '"') && (*ch != NUL)) {
ch++;
}
if (*ch == '"') {
//
// we have the closing ", we have a token
//
*ch = NUL; // mark end of token
ch++;
tx++;
} else {
Token[0] = (CHAR16 *)-1; // report error
return;
}
} else {
//
// not a quoted string, so pick off a normal token
//
// Start by finding start of token
//
for ( ; *ch != NUL; ch++) {
if (IsIn(*ch, TokenChar)) {
Token[tx] = ch;
tx++;
break;
}
}
while (IsIn(*ch, TokenChar)) {
ch++;
}
//
// if we're at the end of the command line, we're done
// else, trim off token and go on
//
if (*ch == NUL) {
//
// we hit the end
//
Token[tx] = NULL;
return;
} else {
*ch = NUL;
ch++;
}
} // else
} // while
}
BOOLEAN
ExecuteSingleCommand(
CHAR16 *Token[]
)
/*
Returns TRUE to tell program to exit, else FALSE
*/
{
UINTN i;
for (i = 0; CmdTable[i].Name != NULL; i++) {
if (StrCmp(CmdTable[i].Name, Token[0]) == 0) {
return CmdTable[i].Function(Token);
}
}
//
// If we're here, we didn't understand the command
//
Print(L"%s\n%s\n", MSG_BAD_CMD, MSG_GET_HELP);
return FALSE;
}
BOOLEAN
CmdAbout(
CHAR16 **Token
)
{
Print(MSG_ABOUT02,
EFI_FIRMWARE_MAJOR_REVISION,
EFI_FIRMWARE_MINOR_REVISION,
EFI_FIRMWARE_MAJOR_REVISION,
EFI_FIRMWARE_MINOR_REVISION
);
return FALSE;
}
BOOLEAN
CmdList(
CHAR16 **Token
)
/*
CmdList - print the list of Partionable Disks
Globals: DiskHandleList, DiskHandleCount
Cmd Args: None.
*/
{
INTN i;
EFI_BLOCK_IO *BlkIo;
CHAR16 c;
Print(MSG_LIST01);
Print(MSG_LIST01B);
for (i = 0; i < DiskHandleCount; i++) {
status = BS->HandleProtocol(DiskHandleList[i], &BlockIoProtocol, &BlkIo);
if (i == SelectedDisk) {
c = '*';
} else {
c = ' ';
}
if (EFI_ERROR(status)) {
Print(MSG_LIST03, i);
} else {
Print(
MSG_LIST02,
c,
i,
BlkIo->Media->BlockSize,
BlkIo->Media->LastBlock+1
);
}
}
return FALSE;
}
BOOLEAN
CmdSelect(
CHAR16 **Token
)
/*
CmdSelect - Select the disk that most commands operate on.
Globals: SelectedDisk, DiskHandleCount
Options: None.
Cmd Args: none for display, number to select
*/
{
INTN NewSelect;
if (Token[1] == NULL) {
if (SelectedDisk == -1) {
Print(MSG_SELECT01);
} else {
Print(MSG_SELECT02, SelectedDisk);
}
} else {
NewSelect = Atoi(Token[1]);
if ((NewSelect >= 0) &&
(NewSelect < DiskHandleCount) &&
(IsIn(*Token[1], L"0123456789")) )
{
SelectedDisk = NewSelect;
Print(MSG_SELECT02, SelectedDisk);
} else {
Print(MSG_SELECT03);
}
}
return FALSE;
}
BOOLEAN
CmdInspect(
CHAR16 **Token
)
/*
CmdInspect - report data on the currently selected disk
Globals: SelectedDisk, DiskHandleList
Cmd Args: [RAW] [VER]
*/
{
EFI_HANDLE DiskHandle;
UINTN DiskType = 0;
PGPT_HEADER Header = NULL;
PGPT_TABLE Table = NULL;
PLBA_BLOCK LbaBlock = NULL;
BOOLEAN Raw;
BOOLEAN Verbose;
UINTN i;
if (SelectedDisk == -1) {
Print(MSG_INSPECT01);
return FALSE;
}
Print(MSG_SELECT02, SelectedDisk);
DiskHandle = DiskHandleList[SelectedDisk];
status = ReadGPT(DiskHandle, &Header, &Table, &LbaBlock, &DiskType);
if (EFI_ERROR(status)) {
return FALSE;
}
if (DiskType == DISK_RAW) {
Print(MSG_INSPECT04);
goto Exit;
} else if (DiskType == DISK_MBR) {
CmdInspectMBR(Token);
goto Exit;
} else if (DiskType == DISK_GPT_BAD) {
Print(MSG_INSPECT06);
goto Exit;
} else if ( (DiskType != DISK_GPT_UPD) &&
(DiskType != DISK_GPT))
{
TerribleError(L"Bad Disk Type returnted to Inspect!");
goto Exit;
}
if (DiskType == DISK_GPT_UPD) {
Print(MSG_INSPECT03);
}
if ( (Token[1]) &&
(StrCmp(Token[1], STR_HELP) == 0) )
{
PrintHelp(InspectHelpText);
goto Exit;
}
Raw = FALSE;
Verbose = FALSE;
for (i = 1; Token[i]; i++) {
if (StrCmp(Token[i], STR_RAW) == 0) {
Raw = TRUE;
} else if (StrCmp(Token[i], STR_VER) == 0) {
Verbose = TRUE;
} else {
PrintHelp(InspectHelpText);
goto Exit;
}
}
DumpGPT(DiskHandle, Header, Table, Raw, Verbose);
Exit:
DoFree(Header);
DoFree(Table);
DoFree(LbaBlock);
return FALSE;
}
typedef struct {
UINTN Slot;
EFI_LBA StartingLBA;
} SORT_SLOT_ENTRY;
VOID
DumpGPT(
EFI_HANDLE DiskHandle,
PGPT_HEADER Header,
PGPT_TABLE Table,
BOOLEAN Raw,
BOOLEAN Verbose
)
/*
DumpGPT - print out the GPT passed in via Header and Table
if (Raw) print slot order, all slots, table order.
else print only allocated slots, StartingLBA order.
if (Verbose) print out the Header data.
*/
{
EFI_BLOCK_IO *BlkIo;
UINTN i;
UINTN AllocatedSlots;
CHAR16 Buffer[PART_NAME_LEN+1];
BOOLEAN changed;
SORT_SLOT_ENTRY *SortSlot;
GPT_ENTRY Entry;
UINTN tslot;
EFI_LBA tlba;
SortSlot = DoAllocate(Header->EntriesAllocated * sizeof(SORT_SLOT_ENTRY));
if (SortSlot == NULL) {
status = EFI_OUT_OF_RESOURCES;
Print(MSG_INSPECT02);
return;
}
//
// Dump the handle data just as List would
//
BS->HandleProtocol(DiskHandle, &BlockIoProtocol, &BlkIo);
Print(MSG_LIST01);
Print(MSG_LIST01B);
Print(MSG_LIST02, '*', SelectedDisk, BlkIo->Media->BlockSize, BlkIo->Media->LastBlock+1);
if (Verbose) {
//
// Dump the header
//
Print(L"\nHeader Structure\n");
Print(L" Signature= %16lx Revision=%8X\n",
Header->Signature, Header->Revision);
Print(L" HeaderSize=%8x HeaderCRC32=%8x\n",
Header->HeaderSize, Header->HeaderCRC32);
Print(L" MyLBA=%16lx AlternateLBA=%16lx\n",
Header->MyLBA, Header->AlternateLBA);
Print(L" FirstUsableLBA=%16lx LastUsableLBA=%16lx\n",
Header->FirstUsableLBA, Header->LastUsableLBA);
Print(L" TableLBA=%16lx\n", Header->TableLBA);
Print(L" EntrySize=%8x EntriesAllowed=%8x TableCRC=%8x\n\n",
Header->SizeOfGPT_ENTRY, Header->EntriesAllocated, Header->TableCRC32);
}
//
// Print the Table of GPT entries
//
if (!Raw) {
//
// !Raw == Cooked -> Print the Allocated entries in StartingLBA
// SORTED order...
//
// Find ALL of the allocated entries
//
AllocatedSlots = 0;
for (i = 0; i < Header->EntriesAllocated; i++) {
CopyMem(&Entry, &Table->Entry[i], sizeof(GPT_ENTRY));
if (CompareMem(&(Entry.PartitionType), &GuidNull, sizeof(EFI_GUID)) != 0) {
SortSlot[AllocatedSlots].Slot = i;
SortSlot[AllocatedSlots].StartingLBA = Entry.StartingLBA;
AllocatedSlots++;
}
}
// j has the count of allocated entries
//
// Sort them - yes this is a bubble sort, but the list is probably
// in order and probably small, so for the vastly typical case
// this is actually optimal
//
if (AllocatedSlots > 0) {
do {
changed = FALSE;
for (i = 0; i < AllocatedSlots-1; i++) {
if (SortSlot[i].StartingLBA > SortSlot[i+1].StartingLBA) {
tslot = SortSlot[i+1].Slot;
tlba = SortSlot[i+1].StartingLBA;
changed = TRUE;
SortSlot[i+1].Slot = SortSlot[i].Slot;
SortSlot[i+1].StartingLBA = SortSlot[i].StartingLBA;
SortSlot[i].Slot = tslot;
SortSlot[i].StartingLBA = tlba;
}
}
} while (changed);
//
// Print them, but print the SLOT number, not the row number.
// This is to make Delete be reliable.
//
for (i = 0; i < AllocatedSlots; i++) {
PrintGptEntry(&Table->Entry[SortSlot[i].Slot], SortSlot[i].Slot);
if (((i+1) % 4) == 0) {
Input(MSG_MORE, Buffer, PART_NAME_LEN);
}
}
}
} else {
//
// Raw -> Print ALL of the entries in Table order
// (mostly for test, debug, looking at cratered disks
//
Print(L"RAW RAW RAW\n");
for (i = 0; i < Header->EntriesAllocated; i++) {
PrintGptEntry(&Table->Entry[i], i);
if (((i+1) % 4) == 0) {
Input(MSG_MORE, Buffer, PART_NAME_LEN);
}
}
Print(L"RAW RAW RAW\n");
}
DoFree(SortSlot);
return;
}
VOID
PrintGptEntry(
GPT_ENTRY *Entry,
UINTN Index
)
{
CHAR16 Buffer[PART_NAME_LEN+1];
UINTN j;
Print(L"\n%3d: ", Index);
ZeroMem(Buffer, (PART_NAME_LEN+1)*sizeof(CHAR16));
CopyMem(Buffer, &(Entry->PartitionName), PART_NAME_LEN*sizeof(CHAR16));
Print(L"%s\n ", Buffer);
PrintGuidString(&(Entry->PartitionType));
for (j = 0; SymbolList[j].SymName; j++) {
if (CompareMem(&(Entry->PartitionType), SymbolList[j].Value, sizeof(EFI_GUID)) == 0) {
Print(L" = %s", SymbolList[j].SymName);
}
}
if (CompareMem(&(Entry->PartitionType), &GuidNull, sizeof(EFI_GUID)) == 0) {
Print(L" = UNALLOCATED SLOT");
}
Print(L"\n ");
PrintGuidString(&(Entry->PartitionID));
Print(L" @%16x\n", Entry->Attributes);
Print(L" %16lx - %16lx\n",
Entry->StartingLBA,
Entry->EndingLBA
);
}
BOOLEAN
CmdClean(
CHAR16 **Token
)
/*
CmdClean - Clean off the disk
Globals: SelectedDisk, DiskHandleList
Cmd Args: ALL to clean whole disk, rather than just 1st and last megabyte
We write out 1 block at a time. While this is slow, it avoids wondering
about the Block protocol write size limit, and about how big a buffer
we can allocate.
*/
{
EFI_HANDLE DiskHandle;
CHAR16 Answer[COMMAND_LINE_MAX];
BOOLEAN CleanAll;
UINT32 BlockSize;
UINT64 DiskSize;
UINT64 DiskBytes;
UINT64 RangeBlocks;
UINT64 EndRange;
UINT64 i;
CHAR8 *zbuf;
if (SelectedDisk == -1) {
Print(MSG_INSPECT01);
return FALSE;
}
DiskHandle = DiskHandleList[SelectedDisk];
BlockSize = GetBlockSize(DiskHandle);
DiskSize = GetDiskSize(DiskHandle);
DiskBytes = MultU64x32(DiskSize, BlockSize);
zbuf = DoAllocate(CLEAN_RANGE);
if (zbuf == NULL) return FALSE;
ZeroMem(zbuf, CLEAN_RANGE);
//
// Are you sure?
//
Print(MSG_CLEAN01, SelectedDisk);
Input(STR_CLEAN_PROMPT, Answer, COMMAND_LINE_MAX);
StrUpr(Answer);
Print(L"\n");
if (StrCmp(Answer, L"Y") != 0) {
DoFree(zbuf);
return FALSE;
}
//
// Are you REALLY Sure?
//
Print(MSG_CLEAN02);
Input(STR_CLEAN_PROMPT, Answer, COMMAND_LINE_MAX);
Print(L"\n");
if (StrCmp(Answer, STR_CLEAN_ANS) != 0) {
DoFree(zbuf);
return FALSE;
}
//
// OK, the user really wants to do this
//
//
// All? or just start and end?
//
CleanAll = FALSE;
if (Token[1]) {
if (StrCmp(Token[1], STR_CLEAN03) == 0) {
CleanAll = TRUE;
}
}
if (DiskBytes > (2 * CLEAN_RANGE)) {
RangeBlocks = CLEAN_RANGE / BlockSize;
WriteBlock(DiskHandle, zbuf, 0, CLEAN_RANGE);
EndRange = DiskSize - RangeBlocks;
if (CleanAll) {
for (i=RangeBlocks; i < DiskSize; i += RangeBlocks) {
WriteBlock(DiskHandle, zbuf, i, CLEAN_RANGE);
}
}
WriteBlock(DiskHandle, zbuf, EndRange, CLEAN_RANGE);
} else {
//
// Kind of a small disk, clean it all always
//
for (i = 0; i < DiskSize; i++) {
WriteBlock(DiskHandle, zbuf, i, BlockSize);
}
}
FlushBlock(DiskHandle);
DoFree(zbuf);
return FALSE;
}
BOOLEAN
CmdNew(
CHAR16 **Token
)
/*
CmdNew [mbr | [gpt=numentry]
Changes a RAW disk into either an MBR (well, somebody) or GPT disk
"new mbr" - you want an mbr disk (not implemented)
"new gpt" - you want a gpt disk, you get a default table
"new gpt=xyz" - you want a gpt disk, with at least xyz entries
(you will get less than xyz if exceeds sanity threshold)
anything else - try again with right syntax
*/
{
EFI_HANDLE DiskHandle;
PGPT_HEADER Header;
PGPT_TABLE Table;
PLBA_BLOCK LbaBlock;
UINTN DiskType;
UINTN GptOptSize;
if (SelectedDisk == -1) {
Print(MSG_INSPECT01);
return FALSE;
}
DiskHandle = DiskHandleList[SelectedDisk];
status = ReadGPT(DiskHandle, &Header, &Table, &LbaBlock, &DiskType);
if (EFI_ERROR(status)) {
return FALSE;
}
if (DiskType != DISK_RAW) {
Print(MSG_NEW01, SelectedDisk);
Print(MSG_NEW02);
return FALSE;
}
//
// OK, it's a raw disk...
//
GptOptSize = 0;
if (Token[1]) {
if (StrCmp(Token[1], STR_GPT) == 0) {
if (Token[2]) {
GptOptSize = Atoi(Token[2]);
}
CreateGPT(DiskHandle, GptOptSize);
} else if (StrCmp(Token[1], STR_MBR) == 0) {
CmdNewMBR(Token);
}
} else {
Print(MSG_NEW03);
}
return FALSE;
}
BOOLEAN
CmdFix(
CHAR16 **Token
)
/*
CmdFix - very basic tool to try to fix up GPT disks.
Basic strategy is to read the GPT, if it seems to be a
GPT disk (not MBR, RAW, or totally dead) then call
WriteGPT, which will write both GPTs (and thus sync them)
and rebuild the shadow MBR, all as a matter of course.
*/
{
EFI_HANDLE DiskHandle;
PGPT_HEADER Header = NULL;
PGPT_TABLE Table = NULL;
PLBA_BLOCK LbaBlock = NULL;
UINTN DiskType;
//
// Setup parameters and error handling
//
if (SelectedDisk == -1) {
Print(MSG_INSPECT01);
return FALSE;
}
if ( (Token[1]) &&
(StrCmp(Token[1], STR_HELP) == 0) )
{
PrintHelp(FixHelpText);
return FALSE;
}
DiskHandle = DiskHandleList[SelectedDisk];
status = ReadGPT(DiskHandle, &Header, &Table, &LbaBlock, &DiskType);
if (EFI_ERROR(status)) {
Print(MSG_FIX05);
return FALSE;
}
//
// From this point on, must exit this Procedure with a goto Exit
// to free up allocated stuff, otherwise we leak pool...
//
if (DiskType == DISK_RAW) {
Print(MSG_FIX01);
goto Exit;
}
if (DiskType == DISK_MBR) {
Print(MSG_FIX02);
goto Exit;
}
if ((DiskType != DISK_GPT) &&
(DiskType != DISK_GPT_UPD)) {
if (DebugLevel >= DEBUG_ERRPRINT) {
Print(L"DiskType = %d\n", DiskType);
}
Print(MSG_FIX03);
goto Exit;
}
status = WriteGPT(DiskHandle, Header, Table, LbaBlock);
if (EFI_ERROR(status)) {
Print(MSG_FIX04);
}
Exit:
DoFree(Header);
DoFree(Table);
DoFree(LbaBlock);
return FALSE;
}
//
// ----- Create and sub procs thereof
//
BOOLEAN
CmdCreate(
CHAR16 **Token
)
/*
CmdCreate - Create a new partition
(Actually, this routine is a GPT only partition creator)
create name="name string" size=sss type=name typeguid=<guid> attributes=hex
name is label string
offset is in megabytes, or start at the end of the last partition if absent
size is in megabytes, or "fill the disk" if 0 or absent or > free space
type is any named symbol type (symbols gives list)
typeguid is an arbitrary type guid
attributes is hex 32bit flag
if "help" is first arg, print better help data
name, type or typeguid, required
if all that parses out OK, read the gpt, edit it, write it back,
and voila, we have a new partition.
*/
{
EFI_HANDLE DiskHandle;
PGPT_HEADER Header = NULL;
PGPT_TABLE Table = NULL;
PLBA_BLOCK LbaBlock = NULL;
UINTN DiskType;
UINT64 SizeInMegaBytes = 0;
UINT64 OffsetInBlocks = 0;
UINT64 StartBlock;
UINT64 EndBlock;
UINT64 SizeInBytes = 0;
UINT64 Attributes = 0;
UINTN i;
UINTN j;
EFI_GUID *TypeGuid = NULL;
EFI_GUID GuidBody;
EFI_GUID PartitionIdGuid;
CHAR16 *TypeName = NULL;
CHAR16 PartName[PART_NAME_LEN+1]; // 36 allowed by spec plus NUL we need
CHAR16 Buffer[10];
BOOLEAN Verbose = FALSE;
UINT32 BlockSize;
UINT64 DiskSizeBlocks;
UINT8 *p;
BOOLEAN OffsetSpecified = FALSE;
BOOLEAN AllZeros;
INTN AllZeroEntry;
INTN OldFreeEntry;
UINT64 AvailBlocks;
UINT64 BlocksToAllocate;
UINT64 HighSeen;
UINTN Slot;
//
// Setup parameters and error handling
//
if (SelectedDisk == -1) {
Print(MSG_INSPECT01);
return FALSE;
}
if (Token[1] == NULL) {
PrintHelp(CreateHelpText);
return FALSE;
}
if ( (Token[1]) &&
(StrCmp(Token[1], STR_HELP) == 0) )
{
PrintHelp(CreateHelpText);
return FALSE;
}
DiskHandle = DiskHandleList[SelectedDisk];
status = ReadGPT(DiskHandle, &Header, &Table, &LbaBlock, &DiskType);
if (EFI_ERROR(status)) {
return FALSE;
}
BlockSize = GetBlockSize(DiskHandle);
DiskSizeBlocks = GetDiskSize(DiskHandle);
//
// From this point on, must exit this Procedure with a goto Exit
// to free up allocated stuff, otherwise we leak pool...
//
if (DiskType == DISK_RAW) {
Print(MSG_CREATE01, SelectedDisk);
goto Exit;
}
if (DiskType == DISK_MBR) {
CmdCreateMBR(Token);
goto Exit;
}
if (DiskType != DISK_GPT) {
if (DebugLevel >= DEBUG_ERRPRINT) {
Print(L"DiskType = %d\n", DiskType);
}
Print(MSG_CREATE02);
goto Exit;
}
//
// Parse arguments...
//
for (i = 1; Token[i]; i++) {
if (StrCmp(Token[i], STR_NAME) == 0) {
ZeroMem(PartName, (PART_NAME_LEN+1)*sizeof(CHAR16));
StrCpy(PartName, Token[i+1]);
i++;
} else if (StrCmp(Token[i], STR_TYPE) == 0) {
if (Token[i+1] == NULL) {
PrintHelp(CreateHelpText);
goto Exit;
}
for (j = 0; SymbolList[j].SymName != NULL; j++) {
if (StrCmp(SymbolList[j].SymName, Token[i+1]) == 0) {
TypeGuid = SymbolList[j].Value;
TypeName = SymbolList[j].SymName;
break;
}
}
if (TypeGuid == NULL) {
Print(MSG_CREATE03);
goto Exit;
}
i++;
} else if (StrCmp(Token[i], STR_TYPEGUID) == 0) {
if (Token[i+1] == NULL) {
PrintHelp(CreateHelpText);
goto Exit;
}
status = GetGuidFromString(Token[i+1], &GuidBody);
if (EFI_ERROR(status)) {
PrintHelp(CreateHelpText);
goto Exit;
}
TypeGuid = &GuidBody;
i++;
} else if (StrCmp(Token[i], STR_OFFSET) == 0) {
if (Token[i+1] == NULL) {
PrintHelp(CreateHelpText);
goto Exit;
}
OffsetInBlocks = Xtoi64(Token[i+1]);
OffsetSpecified = TRUE;
i++;
} else if (StrCmp(Token[i], STR_SIZE) == 0) {
if (Token[i+1] == NULL) {
PrintHelp(CreateHelpText);
goto Exit;
}
SizeInMegaBytes = Atoi64(Token[i+1]);
i++;
} else if (StrCmp(Token[i], STR_ATTR) == 0) {
if (Token[i+1] == NULL) {
PrintHelp(CreateHelpText);
goto Exit;
}
Attributes = Xtoi64(Token[i+1]);
i++;
} else if (StrCmp(Token[i], STR_VER) == 0) {
Verbose = TRUE;
// do NOT increment i, we only consumed 1 Token
} else {
Print(L"\n??? % ???\n", Token[i]);
PrintHelp(CreateHelpText);
goto Exit;
}
}
if ( (PartName == NULL) ||
(TypeGuid == NULL) )
{
PrintHelp(CreateHelpText);
goto Exit;
}
if ( (DebugLevel >= DEBUG_ARGPRINT) ||
(Verbose) )
{
Print(L"CmdCreate arguments:\n");
Print(L"SelectedDisk = %d\n", SelectedDisk);
Print(L"Name=%s\n", PartName);
Print(L"TypeGuid = ");
PrintGuidString(TypeGuid);
Print(L"\n");
if (TypeName) {
Print(L"TypeName = %s\n", TypeName);
}
Print(L"Requested OffsetInBlocks = %lx\n", OffsetInBlocks);
Print(L"Requested SizeInMegaBytes = %ld\n", SizeInMegaBytes);
Print(L"Attributes = %lx\n", Attributes);
}
if (DebugLevel >= DEBUG_OPPROMPT) {
Input(L"\nCreate = Enter to Continue\n", Buffer, 10);
}
//
// If Requested size is 0, or greater than size remaining,
// we want to fill the disk.
// Otherwise, use enough blocks to provide at *least* the
// required storage. (Not likely to be a problem...)
//
//
// First, scan the Table and decide where the first unallocated
// space is. Note that for this procedure's primitive space allocation,
// holes between the beginning of the first allocated partition and
// the last allocated partition are ignored.
//
AllZeroEntry = -1;
OldFreeEntry = -1;
HighSeen = Header->FirstUsableLBA - 1;
if (OffsetSpecified) {
//
// if offset is specified, compute the start and end blocks
//
StartBlock = OffsetInBlocks;
if (StartBlock < Header->FirstUsableLBA ||
StartBlock > Header->LastUsableLBA) {
//
// Offset specified is too large
//
status = EFI_INVALID_PARAMETER;
Print(MSG_CREATE08);
goto Exit;
}
SizeInBytes = MultU64x32(SizeInMegaBytes, (1024*1024));
if (SizeInBytes < SizeInMegaBytes || SizeInBytes == 0) {
//
// If size is not specified or too large,
// try to make the partition as big as it can be
//
BlocksToAllocate = EndBlock = SizeInBytes = 0xffffffffffffffff;
} else {
BlocksToAllocate = DivU64x32(SizeInBytes, BlockSize, NULL);
EndBlock = StartBlock + BlocksToAllocate - 1;
if (EndBlock > Header->LastUsableLBA) {
EndBlock = Header->LastUsableLBA;
BlocksToAllocate = EndBlock - StartBlock + 1;
}
}
}
for (i = 0; i < Header->EntriesAllocated; i++) {
if (CompareMem(
&(Table->Entry[i].PartitionType),
&GuidNull,
sizeof(EFI_GUID)
) != 0)
{
//
// Type not null, so it's allocated
//
if (Table->Entry[i].EndingLBA > HighSeen) {
HighSeen = Table->Entry[i].EndingLBA;
}
if (OffsetSpecified) {
//
// make sure new partition does not overlap with existing partitions
//
if (Table->Entry[i].StartingLBA <= StartBlock &&
StartBlock <= Table->Entry[i].EndingLBA) {
//
// starting block is inside an existing partition
//
status = EFI_INVALID_PARAMETER;
Print(MSG_CREATE08);
goto Exit;
}
if ((Table->Entry[i].StartingLBA <= EndBlock &&
EndBlock <= Table->Entry[i].EndingLBA) ||
(StartBlock <= Table->Entry[i].StartingLBA &&
Table->Entry[i].StartingLBA <= EndBlock) ||
(StartBlock <= Table->Entry[i].EndingLBA &&
Table->Entry[i].EndingLBA <= EndBlock)) {
//
// new partition overlaps with an existing partition
// readjust new partition size to avoid overlapping
//
EndBlock = Table->Entry[i].StartingLBA-1;
if (EndBlock < StartBlock) {
status = EFI_INVALID_PARAMETER;
Print(MSG_CREATE08);
goto Exit;
} else {
BlocksToAllocate = EndBlock - StartBlock + 1;
}
}
}
} else {
p = (UINT8 *)(&(Table->Entry[i]));
AllZeros = TRUE;
for (j = 0; j < sizeof(GPT_ENTRY); j++) {
if (p[j] != 0) {
AllZeros = FALSE;
}
}
if (AllZeros) {
if (AllZeroEntry == -1) {
AllZeroEntry = i;
}
} else if (OldFreeEntry == -1) {
OldFreeEntry = i;
}
}
}
//
// AllZeroEntry - if not -1, is pointer to a never before used entry (free)
// OldFreeEntry - if not -1, is pointer to some pre-used free entry
//
if ( (AllZeroEntry == -1) && (OldFreeEntry == -1) ) {
//
// TABLE IS FULL!!
//
status = EFI_OUT_OF_RESOURCES;
Print(MSG_CREATE04);
goto Exit;
}
if (OffsetSpecified) {
//
// the user haven't specified the new partition size and we haven't
// run into any partition that will limit the size of this new partition.
// So, use the max it can
//
if (BlocksToAllocate == -1) {
EndBlock = Header->LastUsableLBA;
BlocksToAllocate = EndBlock - StartBlock + 1;
}
} else {
//
// [HighSeen+1 ... LastUsableLBA] is available...
// avail = (LastUsableLBA - (HighSeen+1)) + 1 => LastUsabbleLBA - HighSeen
//
AvailBlocks = Header->LastUsableLBA - HighSeen;
if (AvailBlocks == 0) {
status = EFI_OUT_OF_RESOURCES;
Print(MSG_CREATE07);
goto Exit;
}
SizeInBytes = MultU64x32(SizeInMegaBytes, (1024*1024));
if (SizeInBytes < SizeInMegaBytes) {
//
// overflow, force a very big answer
//
SizeInBytes = 0xffffffffffffffff;
}
if ((SizeInBytes == 0) ||
(SizeInBytes > (MultU64x32(AvailBlocks, BlockSize)) ) )
{
//
// User asked for zero, or for more than we've got,
// so give them all that is left
//
BlocksToAllocate = AvailBlocks;
} else {
//
// We would have to have a BlockSize > 1mb for Remainder to
// not be 0. Since we cannot actually test this case, we
// ingore it...
//
BlocksToAllocate = DivU64x32(SizeInBytes, BlockSize, NULL);
}
}
//
// We have a name
// We have a type guid
// We have a size in blocks
// We have an attribute mask
//
if (BlocksToAllocate < ((1024*1024)/BlockSize)) {
status = EFI_OUT_OF_RESOURCES;
Print(MSG_CREATE09);
goto Exit;
}
if ( (Verbose) ||
(DebugLevel > DEBUG_ARGPRINT) )
{
Print(L"Requested SizeInMegaBytes = %ld\n", SizeInMegaBytes);
Print(L"Resulting size in Blocks = %ld\n", BlocksToAllocate);
Print(L"Results size in Bytes = %ld\n", MultU64x32(BlocksToAllocate, BlockSize));
}
if (AllZeroEntry != -1) {
Slot = AllZeroEntry;
} else {
Slot = OldFreeEntry;
}
PartitionIdGuid = GetGUID();
CopyMem(&(Table->Entry[Slot].PartitionType), TypeGuid, sizeof(EFI_GUID));
CopyMem(&(Table->Entry[Slot].PartitionID), &PartitionIdGuid, sizeof(EFI_GUID));
if (OffsetSpecified) {
Table->Entry[Slot].StartingLBA = StartBlock;
Table->Entry[Slot].EndingLBA = EndBlock;
} else {
Table->Entry[Slot].StartingLBA = HighSeen + 1;
Table->Entry[Slot].EndingLBA = HighSeen + BlocksToAllocate;
}
if (! ( ((Table->Entry[Slot].EndingLBA - Table->Entry[Slot].StartingLBA) + 1) == BlocksToAllocate) ) {
TerribleError(L"Wrong Size for new partiton in CmdCreate\n");
}
if ( (Table->Entry[Slot].StartingLBA < Header->FirstUsableLBA) ||
(Table->Entry[Slot].EndingLBA > Header->LastUsableLBA) )
{
TerribleError(L"New Partition out of bounds in CmdCreate\n");
}
Table->Entry[Slot].Attributes = Attributes;
CopyMem(&(Table->Entry[Slot].PartitionName[0]), PartName, PART_NAME_LEN*sizeof(CHAR16));
status = WriteGPT(DiskHandle, Header, Table, LbaBlock);
if (EFI_ERROR(status)) {
Print(MSG_CREATE05);
}
Exit:
DoFree(Header);
DoFree(Table);
DoFree(LbaBlock);
return FALSE;
}
//
// -----
//
BOOLEAN
CmdDelete(
CHAR16 **Token
)
/*
CmdDelete - deletes a partition from the currently selected disk
*/
{
EFI_HANDLE DiskHandle;
UINTN DiskType = 0;
PGPT_HEADER Header = NULL;
PGPT_TABLE Table = NULL;
PLBA_BLOCK LbaBlock = NULL;
INTN Victim;
CHAR16 Answer[COMMAND_LINE_MAX];
GPT_ENTRY Entry;
if (SelectedDisk == -1) {
Print(MSG_INSPECT01);
return FALSE;
}
if (Token[1] == NULL) {
PrintHelp(DeleteHelpText);
return FALSE;
}
if ( (Token[1]) &&
(StrCmp(Token[1], STR_HELP) == 0) )
{
PrintHelp(DeleteHelpText);
return FALSE;
}
Print(MSG_SELECT02, SelectedDisk);
DiskHandle = DiskHandleList[SelectedDisk];
status = ReadGPT(DiskHandle, &Header, &Table, &LbaBlock, &DiskType);
if (EFI_ERROR(status)) {
return FALSE;
}
if (DiskType == DISK_RAW) {
Print(MSG_DELETE02);
goto Exit;
} else if (DiskType == DISK_MBR) {
CmdInspectMBR(Token);
goto Exit;
} else if (DiskType == DISK_GPT_UPD) {
Print(MSG_DELETE03);
goto Exit;
} else if (DiskType == DISK_GPT_BAD) {
Print(MSG_DELETE04);
goto Exit;
} else if (DiskType != DISK_GPT) {
TerribleError(L"Bad Disk Type returned to Delete!");
goto Exit;
}
//
// OK, it's a Good GPT disk, so do the Delete thing for GPT...
//
if ( (Token[1] == NULL) ||
(Token[2] != NULL) )
{
PrintHelp(InspectHelpText);
goto Exit;
}
Victim = Atoi(Token[1]);
if ( (Victim < 0) ||
((UINT32)Victim > Header->EntriesAllocated) )
{
Print(MSG_DELETE05);
goto Exit;
}
CopyMem(&Entry, &Table->Entry[Victim], sizeof(GPT_ENTRY));
if (CompareMem(&(Entry.PartitionType), &GuidNull, sizeof(EFI_GUID)) == 0) {
Print(MSG_DELETE06);
goto Exit;
}
//
// What you are going to delete, are you sure, are you really sure...
//
Print(MSG_DELETE07, Victim);
PrintGptEntry(&Entry, Victim);
Print(L"\n\n");
Print(MSG_DELETE09);
Print(MSG_DELETE10);
Input(STR_DELETE_PROMPT, Answer, COMMAND_LINE_MAX);
Print(L"\n");
StrUpr(Answer);
if (StrCmp(Answer, L"Y") != 0) {
goto Exit;
}
Print(MSG_DELETE11);
Input(STR_DELETE_PROMPT, Answer, COMMAND_LINE_MAX);
Print(L"\n");
StrUpr(Answer);
if (StrCmp(Answer, STR_DELETE_ANS) != 0) {
goto Exit;
}
//
// If we get here, then...
// Victim is the number of legal GPT slot
// Victim refers to a slot which is allocated
// The user has seen confirmation of which slot that is
// The user says they realy truly want to delete it
//
CopyMem(&(Table->Entry[Victim].PartitionType), &GuidNull, sizeof(EFI_GUID));
status = WriteGPT(DiskHandle, Header, Table, LbaBlock);
if (EFI_ERROR(status)) {
Print(MSG_DELETE08);
}
Exit:
DoFree(Header);
DoFree(Table);
DoFree(LbaBlock);
return FALSE;
}
BOOLEAN
CmdHelp(
CHAR16 **Token
)
{
UINTN i;
for (i = 0; CmdTable[i].Name != NULL; i++) {
Print(L"%s %s\n", CmdTable[i].Name, CmdTable[i].HelpSummary);
}
return FALSE;
}
BOOLEAN
CmdExit(
CHAR16 **Token
)
{
Print(L"%s\n", MSG_EXITING);
return TRUE;
}
BOOLEAN
CmdSymbols(
CHAR16 **Token
)
/*
CmdSymbols - print out the GUID symbols compiled into the program
For predefined symbol (see ...) we print it's friendly name,
it's text definition, and it's actual value.
*/
{
UINTN i;
EFI_GUID *Guid;
BOOLEAN Verbose = FALSE;
if ( (Token[1]) &&
(StrCmp(Token[1], STR_VER) == 0) )
{
Verbose = TRUE;
}
for (i = 0; SymbolList[i].SymName != NULL; i++) {
Guid = SymbolList[i].Value;
Print(L"%s = %s\n", SymbolList[i].SymName, SymbolList[i].Comment);
if (Verbose) {
PrintGuidString(Guid);
Print(L"\n\n");
}
}
return FALSE;
}
BOOLEAN
CmdRemark(
CHAR16 **Token
)
{
//
// The remark command does nothing...
return FALSE;
}
BOOLEAN
CmdMake(
CHAR16 **Token
)
{
UINTN i;
Token++;
if (Token[0] != NULL) {
for (i = 0; ScriptTable[i].Name != NULL; i++) {
if (StrCmp(ScriptTable[i].Name, Token[0]) == 0) {
return ScriptTable[i].Function(Token);
}
}
}
//
// Nothing we know about, so run list
//
return ScriptList(Token);
}
BOOLEAN
CmdDebug(
CHAR16 **Token
)
/*
Debug -
Without args, shows last status value, and AllocCount
If an arg, it sets the debug/checkout support level
0 = do nothing extra
1 = print full computed arguments before starting an operation
2 = print full computed arguments and hold for prompt before
doing a major operation.
*/
{
if (Token[1]) {
DebugLevel = Atoi(Token[1]);
}
Print(L"status = %x %r\n", status, status);
Print(L"AllocCount = %d\n", AllocCount);
Print(L"DebugLevel = %d\n", DebugLevel);
return FALSE;
}
//
// ----- SubUnits to do MBR operations -----
//
VOID
CmdInspectMBR(
CHAR16 **Token
)
/*
CmdInspectMBR - dumps the partition data for an MBR disk
*/
{
Print(MSG_INSPECT05);
return;
}
VOID
CmdCreateMBR(
CHAR16 **Token
)
/*
CmdCreateMBR - creates an MBR parititon
*/
{
Print(MSG_CREATE06);
return;
}
VOID
CmdNewMBR(
CHAR16 **Token
)
/*
CmdCreateMBR - creates an MBR parititon
*/
{
Print(MSG_NEW04);
return;
}
VOID
CmdDeleteMBR(
CHAR16 **Token
)
/*
CmdDeleteMBR - deletes an MBR parititon
*/
{
Print(MSG_DELETE01);
return;
}
//
// ----- Various Support Routines -----
//
VOID
PrintGuidString(
EFI_GUID *Guid
)
{
CHAR16 Buffer[40];
SPrint(Buffer, 40, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
Guid->Data1,
Guid->Data2,
Guid->Data3,
Guid->Data4[0],
Guid->Data4[1],
Guid->Data4[2],
Guid->Data4[3],
Guid->Data4[4],
Guid->Data4[5],
Guid->Data4[6],
Guid->Data4[7]
);
Print(L"%s", Buffer);
return;
}
EFI_STATUS
GetGuidFromString(
CHAR16 *String,
EFI_GUID *Guid
)
/*
GetGuidFromString
This routine scans the string looking for 32 hex digits. Each
such digits is shifted into the Guid. Non hex digits are skipped.
This means the guid MUST begin with the first digit, not with a filler
0 or 0x or the like. However, because non hex digits are skipped,
any set of dashes, dots, etc. may be used as punctuation.
So:
01234567-abcd-ef01-12-34-56-78-9a-bc-de-f0
&
01.23.45.67-ab.cd.ef.01-12.34.56.78-9a.bc.de.f0
Will create the same Guid value.
*/
{
EFI_GUID TempGuid;
INTN x;
UINTN i;
UINTN j;
//
// scan until we have the right number of hex digits for each part
// of the guid structure, skipping over non hex digits
//
ZeroMem((CHAR16 *)&TempGuid, sizeof(EFI_GUID));
//
// 1st uint32
//
for (i = 0; i < 8; String++) {
if (*String == NUL) {
status = EFI_INVALID_PARAMETER;
return status;
}
x = HexChar(*String);
if (x != -1) {
TempGuid.Data1 = (UINT32)((TempGuid.Data1 * 16) + x);
i++;
}
}
//
// 2nd unit - uint16
//
for (i = 0; i < 4; String++) {
if (*String == NUL) {
status = EFI_INVALID_PARAMETER;
return status;
}
x = HexChar(*String);
if (x != -1) {
TempGuid.Data2 = (TempGuid.Data2 * 16) + (UINT16)x;
i++;
}
}
//
// 3nd unit - uint16
//
for (i = 0; i < 4; String++) {
if (*String == NUL) {
status = EFI_INVALID_PARAMETER;
return status;
}
x = HexChar(*String);
if (x != -1) {
TempGuid.Data3 = (TempGuid.Data3 * 16) + (UINT16)x;
i++;
}
}
//
// 4th unit - 8 uint8s
//
for (j = 0; j < 8; j++) {
for (i = 0; i < 2; String++) {
if (*String == NUL) {
status = EFI_INVALID_PARAMETER;
return status;
}
x = HexChar(*String);
if (x != -1) {
TempGuid.Data4[j] = (TempGuid.Data4[j] * 16) + (UINT8)x;
i++;
}
}
}
CopyMem(Guid, &TempGuid, sizeof(EFI_GUID));
return status = EFI_SUCCESS;
}
INTN
HexChar(
CHAR16 Ch
)
/*
HexChar just finds the offset of Ch in the string "0123456789ABCDEF",
which in effect converts a hex digit to a number.
(a one char at a time xtoi)
If Ch isn't a hex digit, -1 is returned.
*/
{
UINTN i;
CHAR16 *String = L"0123456789ABCDEF";
for (i = 0; String[i] != NUL; i++) {
if (Ch == String[i]) {
return i;
}
}
return -1;
}
UINT64
Xtoi64(
CHAR16 *String
)
/*
Xtoi64 is NOT fully xtoi compatible, it requires that the hex
number start at the first character and stops at first non hex char
Always returns a 64bit value
*/
{
UINT64 BigHex;
INT32 x;
BigHex = 0;
x = (INT32)HexChar(*String);
while (x != -1) {
BigHex = MultU64x32(BigHex, 16) + x;
String++;
x = (INT32)HexChar(*String);
}
return BigHex;
}
UINT64
Atoi64(
CHAR16 *String
)
/*
Atoi64 is NOT fully atoi compatible, it requires that the number
start at the first character and stops at first non number char
Always returns a 64bit value
*/
{
UINT64 BigNum;
INT32 x;
BigNum = 0;
x = (INT32)HexChar(*String);
while ( (x >= 0) && (x <= 9) ) {
BigNum = MultU64x32(BigNum, 10);
BigNum = BigNum + x;
String++;
x = (INT32)HexChar(*String);
}
return BigNum;
}
BOOLEAN
IsIn(
CHAR16 What,
CHAR16 *InWhat
)
/*
IsIn - return TRUE if What is found in InWhat, else FALSE;
*/
{
UINTN i;
for (i = 0; InWhat[i] != NUL; i++) {
if (InWhat[i] == What) {
return TRUE;
}
}
return FALSE;
}
VOID
PrintHelp(
CHAR16 *HelpText[]
)
{
UINTN i;
for (i = 0; HelpText[i] != NULL; i++) {
Print(HelpText[i]);
}
return;
}
VOID
TerribleError(
CHAR16 *String
)
{
CHAR16 *Buffer;
Buffer = AllocatePool(512);
SPrint(Buffer, 512, L"Terrible Error = %s status=%x %r\nProgram terminated.\n", String, status, status);
Print(Buffer);
BS->Exit(SavedImageHandle, EFI_VOLUME_CORRUPTED, StrLen(Buffer), Buffer);
}
Copy Permalink