int
AbDumpAmlFile (
char *File1Path,
char *File2Path)
{
char *FileBuffer;
FILE *FileOutHandle;
UINT32 FileSize = 0;
int Status = -1;
/* Get the entire AML file, validate header */
FileBuffer = AbGetFile (File1Path, &FileSize);
if (!FileBuffer)
{
return (-1);
}
printf ("Input file: %s contains %u (0x%X) bytes\n",
File1Path, FileSize, FileSize);
FileOutHandle = fopen (File2Path, "wb");
if (!FileOutHandle)
{
printf ("Could not open file %s\n", File2Path);
goto Exit1;
}
if (!AbValidateHeader ((ACPI_TABLE_HEADER *) FileBuffer))
{
goto Exit2;
}
/* Convert binary AML to text, using common dump buffer routine */
AcpiGbl_DebugFile = FileOutHandle;
AcpiGbl_DbOutputFlags = ACPI_DB_REDIRECTABLE_OUTPUT;
AcpiOsPrintf ("%4.4s @ 0x%8.8X\n",
((ACPI_TABLE_HEADER *) FileBuffer)->Signature, 0);
AcpiUtDumpBuffer ((UINT8 *) FileBuffer, FileSize, DB_BYTE_DISPLAY, 0);
/* Summary for the output file */
FileSize = CmGetFileSize (FileOutHandle);
printf ("Output file: %s contains %u (0x%X) bytes\n\n",
File2Path, FileSize, FileSize);
Status = 0;
Exit2:
fclose (FileOutHandle);
Exit1:
free (FileBuffer);
return (Status);
}
ACPI_TABLE_HEADER *
ApGetTableFromFile (
char *Pathname,
UINT32 *OutFileSize)
{
ACPI_TABLE_HEADER *Buffer = NULL;
ACPI_FILE File;
UINT32 FileSize;
size_t Actual;
/* Must use binary mode */
File = AcpiOsOpenFile (Pathname, ACPI_FILE_READING | ACPI_FILE_BINARY);
if (!File)
{
AcpiLogError ("Could not open input file: %s\n", Pathname);
return (NULL);
}
/* Need file size to allocate a buffer */
FileSize = CmGetFileSize (File);
if (FileSize == ACPI_UINT32_MAX)
{
AcpiLogError (
"Could not get input file size: %s\n", Pathname);
goto Cleanup;
}
/* Allocate a buffer for the entire file */
Buffer = ACPI_ALLOCATE_ZEROED (FileSize);
if (!Buffer)
{
AcpiLogError (
"Could not allocate file buffer of size: %u\n", FileSize);
goto Cleanup;
}
/* Read the entire file */
Actual = AcpiOsReadFile (File, Buffer, 1, FileSize);
if (Actual != FileSize)
{
AcpiLogError (
"Could not read input file: %s\n", Pathname);
ACPI_FREE (Buffer);
Buffer = NULL;
goto Cleanup;
}
*OutFileSize = FileSize;
Cleanup:
AcpiOsCloseFile (File);
return (Buffer);
}
ACPI_TABLE_HEADER *
ApGetTableFromFile (
char *Pathname,
UINT32 *OutFileSize)
{
ACPI_TABLE_HEADER *Buffer = NULL;
ACPI_FILE File;
UINT32 FileSize;
ACPI_SIZE Actual;
/* Must use binary mode */
File = fopen (Pathname, "rb");
if (!File)
{
fprintf (stderr, "Could not open input file: %s\n", Pathname);
return (NULL);
}
/* Need file size to allocate a buffer */
FileSize = CmGetFileSize (File);
if (FileSize == ACPI_UINT32_MAX)
{
fprintf (stderr,
"Could not get input file size: %s\n", Pathname);
goto Cleanup;
}
/* Allocate a buffer for the entire file */
Buffer = ACPI_ALLOCATE_ZEROED (FileSize);
if (!Buffer)
{
fprintf (stderr,
"Could not allocate file buffer of size: %u\n", FileSize);
goto Cleanup;
}
/* Read the entire file */
Actual = fread (Buffer, 1, FileSize, File);
if (Actual != FileSize)
{
fprintf (stderr, "Could not read input file: %s\n", Pathname);
ACPI_FREE (Buffer);
Buffer = NULL;
goto Cleanup;
}
*OutFileSize = FileSize;
Cleanup:
fclose (File);
return (Buffer);
}
static char *
AbGetFile (
char *Filename,
UINT32 *FileSize)
{
FILE *File;
UINT32 Size;
char *Buffer = NULL;
size_t Actual;
/* Binary mode does not alter CR/LF pairs */
File = fopen (Filename, "rb");
if (!File)
{
printf ("Could not open file %s\n", Filename);
return (NULL);
}
/* Need file size to allocate a buffer */
Size = CmGetFileSize (File);
if (Size == ACPI_UINT32_MAX)
{
printf ("Could not get file size (seek) for %s\n", Filename);
goto ErrorExit;
}
/* Allocate a buffer for the entire file */
Buffer = calloc (Size, 1);
if (!Buffer)
{
printf ("Could not allocate buffer of size %u\n", Size);
goto ErrorExit;
}
/* Read the entire file */
Actual = fread (Buffer, 1, Size, File);
if (Actual != Size)
{
printf ("Could not read the input file %s\n", Filename);
free (Buffer);
Buffer = NULL;
goto ErrorExit;
}
*FileSize = Size;
ErrorExit:
fclose (File);
return (Buffer);
}
UINT32
FlGetFileSize (
UINT32 FileId)
{
UINT32 FileSize;
FileSize = CmGetFileSize (Gbl_Files[FileId].Handle);
if (FileSize == ACPI_UINT32_MAX)
{
AslAbort();
}
return (FileSize);
}
ACPI_STATUS
AcpiUtReadTableFromFile (
char *Filename,
ACPI_TABLE_HEADER **Table)
{
FILE *File;
UINT32 FileSize;
UINT32 TableLength;
ACPI_STATUS Status = AE_ERROR;
/* Open the file, get current size */
File = fopen (Filename, "rb");
if (!File)
{
perror ("Could not open input file");
if (errno == ENOENT)
{
return (AE_NOT_EXIST);
}
return (Status);
}
FileSize = CmGetFileSize (File);
if (FileSize == ACPI_UINT32_MAX)
{
goto Exit;
}
/* Get the entire file */
fprintf (stderr,
"Reading ACPI table from file %12s - Length %.8u (0x%06X)\n",
Filename, FileSize, FileSize);
Status = AcpiUtReadTable (File, Table, &TableLength);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not get table from the file\n");
}
Exit:
fclose(File);
return (Status);
}
DT_FIELD *
DtScanFile (
FILE *Handle)
{
ACPI_STATUS Status;
UINT32 Offset;
ACPI_FUNCTION_NAME (DtScanFile);
/* Get the file size */
Gbl_InputByteCount = CmGetFileSize (Handle);
if (Gbl_InputByteCount == ACPI_UINT32_MAX)
{
AslAbort ();
}
Gbl_CurrentLineNumber = 0;
Gbl_CurrentLineOffset = 0;
Gbl_NextLineOffset = 0;
/* Scan line-by-line */
while ((Offset = DtGetNextLine (Handle, 0)) != ASL_EOF)
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s",
Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer));
Status = DtParseLine (Gbl_CurrentLineBuffer,
Gbl_CurrentLineNumber, Offset);
if (Status == AE_NOT_FOUND)
{
break;
}
}
/* Dump the parse tree if debug enabled */
DtDumpFieldList (Gbl_FieldList);
return (Gbl_FieldList);
}
void
DtOutputBinary (
DT_SUBTABLE *RootTable)
{
if (!RootTable)
{
return;
}
/* Walk the entire parse tree, emitting the binary data */
DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL);
Gbl_TableLength = CmGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
if (Gbl_TableLength == ACPI_UINT32_MAX)
{
AslAbort ();
}
}
ACPI_STATUS
AcValidateTableHeader (
FILE *File,
long TableOffset)
{
ACPI_TABLE_HEADER TableHeader;
ACPI_SIZE Actual;
long OriginalOffset;
UINT32 FileSize;
UINT32 i;
ACPI_FUNCTION_TRACE (AcValidateTableHeader);
/* Read a potential table header */
OriginalOffset = ftell (File);
fseek (File, TableOffset, SEEK_SET);
Actual = fread (&TableHeader, 1, sizeof (ACPI_TABLE_HEADER), File);
fseek (File, OriginalOffset, SEEK_SET);
if (Actual < sizeof (ACPI_TABLE_HEADER))
{
return (AE_ERROR);
}
/* Validate the signature (limited ASCII chars) */
if (!AcpiUtValidNameseg (TableHeader.Signature))
{
fprintf (stderr, "Invalid table signature: 0x%8.8X\n",
*ACPI_CAST_PTR (UINT32, TableHeader.Signature));
return (AE_BAD_SIGNATURE);
}
/* Validate table length against bytes remaining in the file */
FileSize = CmGetFileSize (File);
if (TableHeader.Length > (UINT32) (FileSize - TableOffset))
{
fprintf (stderr, "Table [%4.4s] is too long for file - "
"needs: 0x%.2X, remaining in file: 0x%.2X\n",
TableHeader.Signature, TableHeader.Length,
(UINT32) (FileSize - TableOffset));
return (AE_BAD_HEADER);
}
/*
* These fields must be ASCII: OemId, OemTableId, AslCompilerId.
* We allow a NULL terminator in OemId and OemTableId.
*/
for (i = 0; i < ACPI_NAME_SIZE; i++)
{
if (!ACPI_IS_ASCII ((UINT8) TableHeader.AslCompilerId[i]))
{
goto BadCharacters;
}
}
for (i = 0; (i < ACPI_OEM_ID_SIZE) && (TableHeader.OemId[i]); i++)
{
if (!ACPI_IS_ASCII ((UINT8) TableHeader.OemId[i]))
{
goto BadCharacters;
}
}
for (i = 0; (i < ACPI_OEM_TABLE_ID_SIZE) && (TableHeader.OemTableId[i]); i++)
{
if (!ACPI_IS_ASCII ((UINT8) TableHeader.OemTableId[i]))
{
goto BadCharacters;
}
}
return (AE_OK);
BadCharacters:
ACPI_WARNING ((AE_INFO,
"Table header for [%4.4s] has invalid ASCII character(s)",
TableHeader.Signature));
return (AE_OK);
}
ACPI_STATUS
AcGetAllTablesFromFile (
char *Filename,
UINT8 GetOnlyAmlTables,
ACPI_NEW_TABLE_DESC **ReturnListHead)
{
ACPI_NEW_TABLE_DESC *ListHead = NULL;
ACPI_NEW_TABLE_DESC *ListTail = NULL;
ACPI_NEW_TABLE_DESC *TableDesc;
FILE *File;
ACPI_TABLE_HEADER *Table = NULL;
UINT32 FileSize;
ACPI_STATUS Status = AE_OK;
File = fopen (Filename, "rb");
if (!File)
{
fprintf (stderr, "Could not open input file: %s\n", Filename);
if (errno == ENOENT)
{
return (AE_NOT_EXIST);
}
return (AE_ERROR);
}
/* Get the file size */
FileSize = CmGetFileSize (File);
if (FileSize == ACPI_UINT32_MAX)
{
Status = AE_ERROR;
goto Exit;
}
fprintf (stderr,
"Input file %s, Length 0x%X (%u) bytes\n",
Filename, FileSize, FileSize);
/* We must have at least one ACPI table header */
if (FileSize < sizeof (ACPI_TABLE_HEADER))
{
Status = AE_BAD_HEADER;
goto Exit;
}
/* Check for an non-binary file */
if (!AcIsFileBinary (File))
{
fprintf (stderr,
" %s: File does not appear to contain a valid AML table\n",
Filename);
Status = AE_TYPE;
goto Exit;
}
/* Read all tables within the file */
while (ACPI_SUCCESS (Status))
{
/* Get one entire ACPI table */
Status = AcGetOneTableFromFile (
Filename, File, GetOnlyAmlTables, &Table);
if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
break;
}
else if (Status == AE_TYPE)
{
Status = AE_OK;
goto Exit;
}
else if (ACPI_FAILURE (Status))
{
goto Exit;
}
/* Print table header for iASL/disassembler only */
#ifdef ACPI_ASL_COMPILER
AcpiTbPrintTableHeader (0, Table);
#endif
/* Allocate and link a table descriptor */
TableDesc = AcpiOsAllocate (sizeof (ACPI_NEW_TABLE_DESC));
if (!TableDesc)
{
AcpiOsFree (Table);
Status = AE_NO_MEMORY;
goto Exit;
}
TableDesc->Table = Table;
TableDesc->Next = NULL;
/* Link at the end of the local table list */
if (!ListHead)
{
ListHead = TableDesc;
ListTail = TableDesc;
}
else
{
ListTail->Next = TableDesc;
ListTail = TableDesc;
}
}
/* Add the local table list to the end of the global list */
if (*ReturnListHead)
{
ListTail = *ReturnListHead;
while (ListTail->Next)
{
ListTail = ListTail->Next;
}
ListTail->Next = ListHead;
}
else
{
*ReturnListHead = ListHead;
}
Exit:
fclose(File);
return (Status);
}
ACPI_STATUS
AdAmlDisassemble (
BOOLEAN OutToFile,
char *Filename,
char *Prefix,
char **OutFilename)
{
ACPI_STATUS Status;
ACPI_STATUS GlobalStatus = AE_OK;
char *DisasmFilename = NULL;
char *ExternalFilename;
ACPI_EXTERNAL_FILE *ExternalFileList = AcpiGbl_ExternalFileList;
FILE *File = NULL;
ACPI_TABLE_HEADER *Table = NULL;
ACPI_TABLE_HEADER *ExternalTable;
ACPI_OWNER_ID OwnerId;
/*
* Input: AML code from either a file or via GetTables (memory or
* registry)
*/
if (Filename)
{
Status = AcpiDbGetTableFromFile (Filename, &Table, FALSE);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/*
* External filenames separated by commas
* Example: iasl -e file1,file2,file3 -d xxx.aml
*/
while (ExternalFileList)
{
ExternalFilename = ExternalFileList->Path;
if (!strcmp (ExternalFilename, Filename))
{
/* Next external file */
ExternalFileList = ExternalFileList->Next;
continue;
}
Status = AcpiDbGetTableFromFile (ExternalFilename, &ExternalTable, TRUE);
if (ACPI_FAILURE (Status))
{
if (Status == AE_TYPE)
{
ExternalFileList = ExternalFileList->Next;
GlobalStatus = AE_TYPE;
Status = AE_OK;
continue;
}
return (Status);
}
/* Load external table for symbol resolution */
if (ExternalTable)
{
Status = AdParseTable (ExternalTable, &OwnerId, TRUE, TRUE);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not parse external ACPI tables, %s\n",
AcpiFormatException (Status));
return (Status);
}
/*
* Load namespace from names created within control methods
* Set owner id of nodes in external table
*/
AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
}
/* Next external file */
ExternalFileList = ExternalFileList->Next;
}
if (ACPI_FAILURE (GlobalStatus))
{
return (GlobalStatus);
}
/* Clear external list generated by Scope in external tables */
if (AcpiGbl_ExternalFileList)
{
AcpiDmClearExternalList ();
}
/* Load any externals defined in the optional external ref file */
AcpiDmGetExternalsFromFile ();
}
else
{
Status = AdGetLocalTables ();
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not get ACPI tables, %s\n",
AcpiFormatException (Status));
return (Status);
}
if (!AcpiGbl_DmOpt_Disasm)
{
return (AE_OK);
}
/* Obtained the local tables, just disassemble the DSDT */
Status = AcpiGetTable (ACPI_SIG_DSDT, 0, &Table);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not get DSDT, %s\n",
AcpiFormatException (Status));
return (Status);
}
AcpiOsPrintf ("\nDisassembly of DSDT\n");
Prefix = AdGenerateFilename ("dsdt", Table->OemTableId);
}
/*
* Output: ASL code. Redirect to a file if requested
*/
if (OutToFile)
{
/* Create/Open a disassembly output file */
DisasmFilename = FlGenerateFilename (Prefix, FILE_SUFFIX_DISASSEMBLY);
if (!DisasmFilename)
{
fprintf (stderr, "Could not generate output filename\n");
Status = AE_ERROR;
goto Cleanup;
}
File = fopen (DisasmFilename, "w+");
if (!File)
{
fprintf (stderr, "Could not open output file %s\n", DisasmFilename);
Status = AE_ERROR;
goto Cleanup;
}
AcpiOsRedirectOutput (File);
}
*OutFilename = DisasmFilename;
/* ForceAmlDisassembly means to assume the table contains valid AML */
if (!AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
{
AdDisassemblerHeader (Filename, ACPI_IS_DATA_TABLE);
AcpiOsPrintf (" * ACPI Data Table [%4.4s]\n *\n",
Table->Signature);
AcpiOsPrintf (" * Format: [HexOffset DecimalOffset ByteLength] "
"FieldName : FieldValue\n */\n\n");
AcpiDmDumpDataTable (Table);
fprintf (stderr, "Acpi Data Table [%4.4s] decoded\n",
Table->Signature);
if (File)
{
fprintf (stderr, "Formatted output: %s - %u bytes\n",
DisasmFilename, CmGetFileSize (File));
}
}
else
{
/* Always parse the tables, only option is what to display */
Status = AdParseTable (Table, &OwnerId, TRUE, FALSE);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
AcpiFormatException (Status));
goto Cleanup;
}
if (AslCompilerdebug)
{
AcpiOsPrintf ("/**** Before second load\n");
if (File)
{
NsSetupNamespaceListing (File);
NsDisplayNamespace ();
}
AcpiOsPrintf ("*****/\n");
}
/* Load namespace from names created within control methods */
AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
/*
* Cross reference the namespace here, in order to
* generate External() statements
*/
AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
if (AslCompilerdebug)
{
AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
}
/* Find possible calls to external control methods */
AcpiDmFindOrphanMethods (AcpiGbl_ParseOpRoot);
/*
* If we found any external control methods, we must reparse
* the entire tree with the new information (namely, the
* number of arguments per method)
*/
if (AcpiDmGetExternalMethodCount ())
{
fprintf (stderr,
"\nFound %u external control methods, "
"reparsing with new information\n",
AcpiDmGetExternalMethodCount ());
/* Reparse, rebuild namespace */
AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
AcpiGbl_ParseOpRoot = NULL;
AcpiNsDeleteNamespaceSubtree (AcpiGbl_RootNode);
AcpiGbl_RootNode = NULL;
AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
AcpiGbl_RootNodeStruct.Type = ACPI_TYPE_DEVICE;
AcpiGbl_RootNodeStruct.Parent = NULL;
AcpiGbl_RootNodeStruct.Child = NULL;
AcpiGbl_RootNodeStruct.Peer = NULL;
AcpiGbl_RootNodeStruct.Object = NULL;
AcpiGbl_RootNodeStruct.Flags = 0;
Status = AcpiNsRootInitialize ();
/* New namespace, add the external definitions first */
AcpiDmAddExternalsToNamespace ();
/* Parse the table again. No need to reload it, however */
Status = AdParseTable (Table, NULL, FALSE, FALSE);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
AcpiFormatException (Status));
goto Cleanup;
}
/* Cross reference the namespace again */
AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
if (AslCompilerdebug)
{
AcpiOsPrintf ("/**** After second load and resource conversion\n");
if (File)
{
NsSetupNamespaceListing (File);
NsDisplayNamespace ();
}
AcpiOsPrintf ("*****/\n");
AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
}
}
/*
* Now that the namespace is finalized, we can perform namespace
* transforms.
*
* 1) Convert fixed-offset references to resource descriptors
* to symbolic references (Note: modifies namespace)
*/
AcpiDmConvertResourceIndexes (AcpiGbl_ParseOpRoot, AcpiGbl_RootNode);
/* Optional displays */
if (AcpiGbl_DmOpt_Disasm)
{
/* This is the real disassembly */
AdDisplayTables (Filename, Table);
/* Dump hex table if requested (-vt) */
AcpiDmDumpDataTable (Table);
fprintf (stderr, "Disassembly completed\n");
if (File)
{
fprintf (stderr, "ASL Output: %s - %u bytes\n",
DisasmFilename, CmGetFileSize (File));
}
if (Gbl_MapfileFlag)
{
fprintf (stderr, "%14s %s - %u bytes\n",
Gbl_Files[ASL_FILE_MAP_OUTPUT].ShortDescription,
Gbl_Files[ASL_FILE_MAP_OUTPUT].Filename,
FlGetFileSize (ASL_FILE_MAP_OUTPUT));
}
}
}
Cleanup:
if (Table && !AcpiGbl_ForceAmlDisassembly &&!AcpiUtIsAmlTable (Table))
{
ACPI_FREE (Table);
}
if (File)
{
if (AslCompilerdebug) /* Display final namespace, with transforms */
{
NsSetupNamespaceListing (File);
NsDisplayNamespace ();
}
fclose (File);
AcpiOsRedirectOutput (stdout);
}
AcpiPsDeleteParseTree (AcpiGbl_ParseOpRoot);
AcpiGbl_ParseOpRoot = NULL;
return (Status);
}
ACPI_STATUS
FlCheckForAcpiTable (
FILE *Handle)
{
ACPI_TABLE_HEADER Table;
UINT32 FileSize;
size_t Actual;
UINT32 i;
/* Read a potential table header */
Actual = fread (&Table, 1, sizeof (ACPI_TABLE_HEADER), Handle);
fseek (Handle, 0, SEEK_SET);
if (Actual < sizeof (ACPI_TABLE_HEADER))
{
return (AE_ERROR);
}
/* Header length field must match the file size */
FileSize = CmGetFileSize (Handle);
if (Table.Length != FileSize)
{
return (AE_ERROR);
}
/*
* These fields must be ASCII:
* Signature, OemId, OemTableId, AslCompilerId.
* We allow a NULL terminator in OemId and OemTableId.
*/
for (i = 0; i < ACPI_NAME_SIZE; i++)
{
if (!ACPI_IS_ASCII ((UINT8) Table.Signature[i]))
{
return (AE_ERROR);
}
if (!ACPI_IS_ASCII ((UINT8) Table.AslCompilerId[i]))
{
return (AE_ERROR);
}
}
for (i = 0; (i < ACPI_OEM_ID_SIZE) && (Table.OemId[i]); i++)
{
if (!ACPI_IS_ASCII ((UINT8) Table.OemId[i]))
{
return (AE_ERROR);
}
}
for (i = 0; (i < ACPI_OEM_TABLE_ID_SIZE) && (Table.OemTableId[i]); i++)
{
if (!ACPI_IS_ASCII ((UINT8) Table.OemTableId[i]))
{
return (AE_ERROR);
}
}
printf ("Binary file appears to be a valid ACPI table, disassembling\n");
return (AE_OK);
}
static ACPI_STATUS
AdDisassembleOneTable (
ACPI_TABLE_HEADER *Table,
FILE *File,
char *Filename,
char *DisasmFilename)
{
ACPI_STATUS Status;
ACPI_OWNER_ID OwnerId;
/* ForceAmlDisassembly means to assume the table contains valid AML */
if (!AcpiGbl_ForceAmlDisassembly && !AcpiUtIsAmlTable (Table))
{
AdDisassemblerHeader (Filename, ACPI_IS_DATA_TABLE);
/* This is a "Data Table" (non-AML table) */
AcpiOsPrintf (" * ACPI Data Table [%4.4s]\n *\n",
Table->Signature);
AcpiOsPrintf (" * Format: [HexOffset DecimalOffset ByteLength] "
"FieldName : FieldValue\n */\n\n");
AcpiDmDumpDataTable (Table);
fprintf (stderr, "Acpi Data Table [%4.4s] decoded\n",
Table->Signature);
if (File)
{
fprintf (stderr, "Formatted output: %s - %u bytes\n",
DisasmFilename, CmGetFileSize (File));
}
return (AE_OK);
}
/*
* This is an AML table (DSDT or SSDT).
* Always parse the tables, only option is what to display
*/
Status = AdParseTable (Table, &OwnerId, TRUE, FALSE);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not parse ACPI tables, %s\n",
AcpiFormatException (Status));
return (Status);
}
/* Debug output, namespace and parse tree */
if (AslCompilerdebug && File)
{
AcpiOsPrintf ("/**** Before second load\n");
NsSetupNamespaceListing (File);
NsDisplayNamespace ();
AcpiOsPrintf ("*****/\n");
}
/* Load namespace from names created within control methods */
AcpiDmFinishNamespaceLoad (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
/*
* Cross reference the namespace here, in order to
* generate External() statements
*/
AcpiDmCrossReferenceNamespace (AcpiGbl_ParseOpRoot,
AcpiGbl_RootNode, OwnerId);
if (AslCompilerdebug)
{
AcpiDmDumpTree (AcpiGbl_ParseOpRoot);
}
/* Find possible calls to external control methods */
AcpiDmFindOrphanMethods (AcpiGbl_ParseOpRoot);
/*
* If we found any external control methods, we must reparse
* the entire tree with the new information (namely, the
* number of arguments per method)
*/
if (AcpiDmGetExternalMethodCount ())
{
Status = AdReparseOneTable (Table, File, OwnerId);
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
/*
* Now that the namespace is finalized, we can perform namespace
* transforms.
*
* 1) Convert fixed-offset references to resource descriptors
* to symbolic references (Note: modifies namespace)
*/
AcpiDmConvertResourceIndexes (AcpiGbl_ParseOpRoot, AcpiGbl_RootNode);
/* Optional displays */
if (AcpiGbl_DmOpt_Disasm)
{
/* This is the real disassembly */
AdDisplayTables (Filename, Table);
/* Dump hex table if requested (-vt) */
AcpiDmDumpDataTable (Table);
fprintf (stderr, "Disassembly completed\n");
if (File)
{
fprintf (stderr, "ASL Output: %s - %u bytes\n",
DisasmFilename, CmGetFileSize (File));
}
if (Gbl_MapfileFlag)
{
fprintf (stderr, "%14s %s - %u bytes\n",
Gbl_Files[ASL_FILE_MAP_OUTPUT].ShortDescription,
Gbl_Files[ASL_FILE_MAP_OUTPUT].Filename,
FlGetFileSize (ASL_FILE_MAP_OUTPUT));
}
}
return (AE_OK);
}
int
AsGetFile (
char *Filename,
char **FileBuffer,
UINT32 *FileSize)
{
FILE *File;
UINT32 Size;
char *Buffer;
size_t Actual;
/* Binary mode leaves CR/LF pairs */
File = fopen (Filename, "rb");
if (!File)
{
printf ("Could not open file %s\n", Filename);
return (-1);
}
/* Need file size to allocate a buffer */
Size = CmGetFileSize (File);
if (Size == ACPI_UINT32_MAX)
{
printf ("Could not get file size for %s\n", Filename);
goto ErrorExit;
}
/*
* Create a buffer for the entire file
* Add plenty extra buffer to accommodate string replacements
*/
Gbl_TotalSize += Size;
Buffer = calloc (Size * 2, 1);
if (!Buffer)
{
printf ("Could not allocate buffer of size %u\n", Size * 2);
goto ErrorExit;
}
/* Read the entire file */
Actual = fread (Buffer, 1, Size, File);
if (Actual != Size)
{
printf ("Could not read the input file %s (%u bytes)\n",
Filename, Size);
goto ErrorExit;
}
Buffer [Size] = 0; /* Null terminate the buffer */
fclose (File);
/* Check for unix contamination */
Gbl_HasLoneLineFeeds = AsDetectLoneLineFeeds (Filename, Buffer);
/*
* Convert all CR/LF pairs to LF only. We do this locally so that
* this code is portable across operating systems.
*/
AsConvertToLineFeeds (Buffer);
*FileBuffer = Buffer;
*FileSize = Size;
return (0);
ErrorExit:
fclose (File);
return (-1);
}
static ACPI_STATUS
AcpiUtReadTable (
FILE *fp,
ACPI_TABLE_HEADER **Table,
UINT32 *TableLength)
{
ACPI_TABLE_HEADER TableHeader;
UINT32 Actual;
ACPI_STATUS Status;
UINT32 FileSize;
BOOLEAN StandardHeader = TRUE;
INT32 Count;
/* Get the file size */
FileSize = CmGetFileSize (fp);
if (FileSize == ACPI_UINT32_MAX)
{
return (AE_ERROR);
}
if (FileSize < 4)
{
return (AE_BAD_HEADER);
}
/* Read the signature */
fseek (fp, 0, SEEK_SET);
Count = fread (&TableHeader, 1, sizeof (ACPI_TABLE_HEADER), fp);
if (Count != sizeof (ACPI_TABLE_HEADER))
{
AcpiOsPrintf ("Could not read the table header\n");
return (AE_BAD_HEADER);
}
/* The RSDP table does not have standard ACPI header */
if (ACPI_VALIDATE_RSDP_SIG (TableHeader.Signature))
{
*TableLength = FileSize;
StandardHeader = FALSE;
}
else
{
#if 0
/* Validate the table header/length */
Status = AcpiTbValidateTableHeader (&TableHeader);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Table header is invalid!\n");
return (Status);
}
#endif
/* File size must be at least as long as the Header-specified length */
if (TableHeader.Length > FileSize)
{
AcpiOsPrintf (
"TableHeader length [0x%X] greater than the input file size [0x%X]\n",
TableHeader.Length, FileSize);
#ifdef ACPI_ASL_COMPILER
AcpiOsPrintf ("File is corrupt or is ASCII text -- "
"it must be a binary file\n");
#endif
return (AE_BAD_HEADER);
}
#ifdef ACPI_OBSOLETE_CODE
/* We only support a limited number of table types */
if (!ACPI_COMPARE_NAME ((char *) TableHeader.Signature, ACPI_SIG_DSDT) &&
!ACPI_COMPARE_NAME ((char *) TableHeader.Signature, ACPI_SIG_PSDT) &&
!ACPI_COMPARE_NAME ((char *) TableHeader.Signature, ACPI_SIG_SSDT))
{
AcpiOsPrintf ("Table signature [%4.4s] is invalid or not supported\n",
(char *) TableHeader.Signature);
ACPI_DUMP_BUFFER (&TableHeader, sizeof (ACPI_TABLE_HEADER));
return (AE_ERROR);
}
#endif
*TableLength = TableHeader.Length;
}
/* Allocate a buffer for the table */
*Table = AcpiOsAllocate ((size_t) FileSize);
if (!*Table)
{
AcpiOsPrintf (
"Could not allocate memory for ACPI table %4.4s (size=0x%X)\n",
TableHeader.Signature, *TableLength);
return (AE_NO_MEMORY);
}
/* Get the rest of the table */
fseek (fp, 0, SEEK_SET);
Actual = fread (*Table, 1, (size_t) FileSize, fp);
if (Actual == FileSize)
{
if (StandardHeader)
{
/* Now validate the checksum */
Status = AcpiTbVerifyChecksum ((void *) *Table,
ACPI_CAST_PTR (ACPI_TABLE_HEADER, *Table)->Length);
if (Status == AE_BAD_CHECKSUM)
{
Status = AcpiUtCheckTextModeCorruption ((UINT8 *) *Table,
FileSize, (*Table)->Length);
return (Status);
}
}
return (AE_OK);
}
if (Actual > 0)
{
AcpiOsPrintf ("Warning - reading table, asked for %X got %X\n",
FileSize, Actual);
return (AE_OK);
}
AcpiOsPrintf ("Error - could not read the table file\n");
AcpiOsFree (*Table);
*Table = NULL;
*TableLength = 0;
return (AE_ERROR);
}
int ACPI_SYSTEM_XFACE
main (
int argc,
char *argv[])
{
int Status = 0;
AP_DUMP_ACTION *Action;
UINT32 FileSize;
UINT32 i;
ACPI_DEBUG_INITIALIZE (); /* For debug version only */
/* Process command line options */
if (ApDoOptions (argc, argv))
{
return (-1);
}
/* Get/dump ACPI table(s) as requested */
for (i = 0; i < CurrentAction; i++)
{
Action = &ActionTable[i];
switch (Action->ToBeDone)
{
case AP_DUMP_ALL_TABLES:
Status = ApDumpAllTables ();
break;
case AP_DUMP_TABLE_BY_ADDRESS:
Status = ApDumpTableByAddress (Action->Argument);
break;
case AP_DUMP_TABLE_BY_NAME:
Status = ApDumpTableByName (Action->Argument);
break;
case AP_DUMP_TABLE_BY_FILE:
Status = ApDumpTableFromFile (Action->Argument);
break;
default:
fprintf (stderr, "Internal error, invalid action: 0x%X\n",
Action->ToBeDone);
return (-1);
}
if (Status)
{
return (Status);
}
}
if (Gbl_OutputFile)
{
if (Gbl_VerboseMode)
{
/* Summary for the output file */
FileSize = CmGetFileSize (Gbl_OutputFile);
fprintf (stderr, "Output file %s contains 0x%X (%u) bytes\n\n",
Gbl_OutputFilename, FileSize, FileSize);
}
fclose (Gbl_OutputFile);
}
return (Status);
}