1 /******************************************************************************
2  *
3  * Module Name: apdump - Dump routines for ACPI tables (acpidump)
4  *
5  *****************************************************************************/
6 
7 /*
8  * Copyright (C) 2000 - 2014, Intel Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions, and the following disclaimer,
16  *    without modification.
17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18  *    substantially similar to the "NO WARRANTY" disclaimer below
19  *    ("Disclaimer") and any redistribution must be conditioned upon
20  *    including a substantially similar Disclaimer requirement for further
21  *    binary redistribution.
22  * 3. Neither the names of the above-listed copyright holders nor the names
23  *    of any contributors may be used to endorse or promote products derived
24  *    from this software without specific prior written permission.
25  *
26  * Alternatively, this software may be distributed under the terms of the
27  * GNU General Public License ("GPL") version 2 as published by the Free
28  * Software Foundation.
29  *
30  * NO WARRANTY
31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41  * POSSIBILITY OF SUCH DAMAGES.
42  */
43 
44 #include "acpidump.h"
45 
46 
47 /* Local prototypes */
48 
49 static int
50 ApDumpTableBuffer (
51     ACPI_TABLE_HEADER       *Table,
52     UINT32                  Instance,
53     ACPI_PHYSICAL_ADDRESS   Address);
54 
55 
56 /******************************************************************************
57  *
58  * FUNCTION:    ApIsValidHeader
59  *
60  * PARAMETERS:  Table               - Pointer to table to be validated
61  *
62  * RETURN:      TRUE if the header appears to be valid. FALSE otherwise
63  *
64  * DESCRIPTION: Check for a valid ACPI table header
65  *
66  ******************************************************************************/
67 
68 BOOLEAN
69 ApIsValidHeader (
70     ACPI_TABLE_HEADER       *Table)
71 {
72     if (!ACPI_VALIDATE_RSDP_SIG (Table->Signature))
73     {
74         /* Make sure signature is all ASCII and a valid ACPI name */
75 
76         if (!AcpiUtValidAcpiName (Table->Signature))
77         {
78             fprintf (stderr, "Table signature (0x%8.8X) is invalid\n",
79                 *(UINT32 *) Table->Signature);
80             return (FALSE);
81         }
82 
83         /* Check for minimum table length */
84 
85         if (Table->Length < sizeof (ACPI_TABLE_HEADER))
86         {
87             fprintf (stderr, "Table length (0x%8.8X) is invalid\n",
88                 Table->Length);
89             return (FALSE);
90         }
91     }
92 
93     return (TRUE);
94 }
95 
96 
97 /******************************************************************************
98  *
99  * FUNCTION:    ApIsValidChecksum
100  *
101  * PARAMETERS:  Table               - Pointer to table to be validated
102  *
103  * RETURN:      TRUE if the checksum appears to be valid. FALSE otherwise
104  *
105  * DESCRIPTION: Check for a valid ACPI table checksum
106  *
107  ******************************************************************************/
108 
109 BOOLEAN
110 ApIsValidChecksum (
111     ACPI_TABLE_HEADER       *Table)
112 {
113     ACPI_STATUS             Status;
114     ACPI_TABLE_RSDP         *Rsdp;
115 
116 
117     if (ACPI_VALIDATE_RSDP_SIG (Table->Signature))
118     {
119         /*
120          * Checksum for RSDP.
121          * Note: Other checksums are computed during the table dump.
122          */
123 
124         Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
125         Status = AcpiTbValidateRsdp (Rsdp);
126     }
127     else
128     {
129         Status = AcpiTbVerifyChecksum (Table, Table->Length);
130     }
131 
132     if (ACPI_FAILURE (Status))
133     {
134         fprintf (stderr, "%4.4s: Warning: wrong checksum\n",
135             Table->Signature);
136     }
137 
138     return (AE_OK);
139 }
140 
141 
142 /******************************************************************************
143  *
144  * FUNCTION:    ApGetTableLength
145  *
146  * PARAMETERS:  Table               - Pointer to the table
147  *
148  * RETURN:      Table length
149  *
150  * DESCRIPTION: Obtain table length according to table signature
151  *
152  ******************************************************************************/
153 
154 UINT32
155 ApGetTableLength (
156     ACPI_TABLE_HEADER       *Table)
157 {
158     ACPI_TABLE_RSDP         *Rsdp;
159 
160 
161     /* Check if table is valid */
162 
163     if (!ApIsValidHeader (Table))
164     {
165         return (0);
166     }
167 
168     if (ACPI_VALIDATE_RSDP_SIG (Table->Signature))
169     {
170         Rsdp = ACPI_CAST_PTR (ACPI_TABLE_RSDP, Table);
171         return (Rsdp->Length);
172     }
173     else
174     {
175         return (Table->Length);
176     }
177 }
178 
179 
180 /******************************************************************************
181  *
182  * FUNCTION:    ApDumpTableBuffer
183  *
184  * PARAMETERS:  Table               - ACPI table to be dumped
185  *              Instance            - ACPI table instance no. to be dumped
186  *              Address             - Physical address of the table
187  *
188  * RETURN:      None
189  *
190  * DESCRIPTION: Dump an ACPI table in standard ASCII hex format, with a
191  *              header that is compatible with the AcpiXtract utility.
192  *
193  ******************************************************************************/
194 
195 static int
196 ApDumpTableBuffer (
197     ACPI_TABLE_HEADER       *Table,
198     UINT32                  Instance,
199     ACPI_PHYSICAL_ADDRESS   Address)
200 {
201     UINT32                  TableLength;
202 
203 
204     TableLength = ApGetTableLength (Table);
205 
206     /* Print only the header if requested */
207 
208     if (Gbl_SummaryMode)
209     {
210         AcpiTbPrintTableHeader (Address, Table);
211         return (0);
212     }
213 
214     /* Dump to binary file if requested */
215 
216     if (Gbl_BinaryMode)
217     {
218         return (ApWriteToBinaryFile (Table, Instance));
219     }
220 
221     /*
222      * Dump the table with header for use with acpixtract utility
223      * Note: simplest to just always emit a 64-bit address. AcpiXtract
224      * utility can handle this.
225      */
226     printf ("%4.4s @ 0x%8.8X%8.8X\n", Table->Signature,
227         ACPI_FORMAT_UINT64 (Address));
228 
229     AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table), TableLength,
230         DB_BYTE_DISPLAY, 0);
231     printf ("\n");
232     return (0);
233 }
234 
235 
236 /******************************************************************************
237  *
238  * FUNCTION:    ApDumpAllTables
239  *
240  * PARAMETERS:  None
241  *
242  * RETURN:      Status
243  *
244  * DESCRIPTION: Get all tables from the RSDT/XSDT (or at least all of the
245  *              tables that we can possibly get).
246  *
247  ******************************************************************************/
248 
249 int
250 ApDumpAllTables (
251     void)
252 {
253     ACPI_TABLE_HEADER       *Table;
254     UINT32                  Instance = 0;
255     ACPI_PHYSICAL_ADDRESS   Address;
256     ACPI_STATUS             Status;
257     UINT32                  i;
258 
259 
260     /* Get and dump all available ACPI tables */
261 
262     for (i = 0; i < AP_MAX_ACPI_FILES; i++)
263     {
264         Status = AcpiOsGetTableByIndex (i, &Table, &Instance, &Address);
265         if (ACPI_FAILURE (Status))
266         {
267             /* AE_LIMIT means that no more tables are available */
268 
269             if (Status == AE_LIMIT)
270             {
271                 return (0);
272             }
273             else if (i == 0)
274             {
275                 fprintf (stderr, "Could not get ACPI tables, %s\n",
276                     AcpiFormatException (Status));
277                 return (-1);
278             }
279             else
280             {
281                 fprintf (stderr, "Could not get ACPI table at index %u, %s\n",
282                     i, AcpiFormatException (Status));
283                 continue;
284             }
285         }
286 
287         if (ApDumpTableBuffer (Table, Instance, Address))
288         {
289             return (-1);
290         }
291         free (Table);
292     }
293 
294     /* Something seriously bad happened if the loop terminates here */
295 
296     return (-1);
297 }
298 
299 
300 /******************************************************************************
301  *
302  * FUNCTION:    ApDumpTableByAddress
303  *
304  * PARAMETERS:  AsciiAddress        - Address for requested ACPI table
305  *
306  * RETURN:      Status
307  *
308  * DESCRIPTION: Get an ACPI table via a physical address and dump it.
309  *
310  ******************************************************************************/
311 
312 int
313 ApDumpTableByAddress (
314     char                    *AsciiAddress)
315 {
316     ACPI_PHYSICAL_ADDRESS   Address;
317     ACPI_TABLE_HEADER       *Table;
318     ACPI_STATUS             Status;
319     int                     TableStatus;
320     UINT64                  LongAddress;
321 
322 
323     /* Convert argument to an integer physical address */
324 
325     Status = AcpiUtStrtoul64 (AsciiAddress, 0, &LongAddress);
326     if (ACPI_FAILURE (Status))
327     {
328         fprintf (stderr, "%s: Could not convert to a physical address\n",
329             AsciiAddress);
330         return (-1);
331     }
332 
333     Address = (ACPI_PHYSICAL_ADDRESS) LongAddress;
334     Status = AcpiOsGetTableByAddress (Address, &Table);
335     if (ACPI_FAILURE (Status))
336     {
337         fprintf (stderr, "Could not get table at 0x%8.8X%8.8X, %s\n",
338             ACPI_FORMAT_UINT64 (Address),
339             AcpiFormatException (Status));
340         return (-1);
341     }
342 
343     TableStatus = ApDumpTableBuffer (Table, 0, Address);
344     free (Table);
345     return (TableStatus);
346 }
347 
348 
349 /******************************************************************************
350  *
351  * FUNCTION:    ApDumpTableByName
352  *
353  * PARAMETERS:  Signature           - Requested ACPI table signature
354  *
355  * RETURN:      Status
356  *
357  * DESCRIPTION: Get an ACPI table via a signature and dump it. Handles
358  *              multiple tables with the same signature (SSDTs).
359  *
360  ******************************************************************************/
361 
362 int
363 ApDumpTableByName (
364     char                    *Signature)
365 {
366     char                    LocalSignature [ACPI_NAME_SIZE + 1];
367     UINT32                  Instance;
368     ACPI_TABLE_HEADER       *Table;
369     ACPI_PHYSICAL_ADDRESS   Address;
370     ACPI_STATUS             Status;
371 
372 
373     if (strlen (Signature) != ACPI_NAME_SIZE)
374     {
375         fprintf (stderr,
376             "Invalid table signature [%s]: must be exactly 4 characters\n",
377             Signature);
378         return (-1);
379     }
380 
381     /* Table signatures are expected to be uppercase */
382 
383     strcpy (LocalSignature, Signature);
384     AcpiUtStrupr (LocalSignature);
385 
386     /* To be friendly, handle tables whose signatures do not match the name */
387 
388     if (ACPI_COMPARE_NAME (LocalSignature, "FADT"))
389     {
390         strcpy (LocalSignature, ACPI_SIG_FADT);
391     }
392     else if (ACPI_COMPARE_NAME (LocalSignature, "MADT"))
393     {
394         strcpy (LocalSignature, ACPI_SIG_MADT);
395     }
396 
397     /* Dump all instances of this signature (to handle multiple SSDTs) */
398 
399     for (Instance = 0; Instance < AP_MAX_ACPI_FILES; Instance++)
400     {
401         Status = AcpiOsGetTableByName (LocalSignature, Instance,
402             &Table, &Address);
403         if (ACPI_FAILURE (Status))
404         {
405             /* AE_LIMIT means that no more tables are available */
406 
407             if (Status == AE_LIMIT)
408             {
409                 return (0);
410             }
411 
412             fprintf (stderr,
413                 "Could not get ACPI table with signature [%s], %s\n",
414                 LocalSignature, AcpiFormatException (Status));
415             return (-1);
416         }
417 
418         if (ApDumpTableBuffer (Table, Instance, Address))
419         {
420             return (-1);
421         }
422         free (Table);
423     }
424 
425     /* Something seriously bad happened if the loop terminates here */
426 
427     return (-1);
428 }
429 
430 
431 /******************************************************************************
432  *
433  * FUNCTION:    ApDumpTableFromFile
434  *
435  * PARAMETERS:  Pathname            - File containing the binary ACPI table
436  *
437  * RETURN:      Status
438  *
439  * DESCRIPTION: Dump an ACPI table from a binary file
440  *
441  ******************************************************************************/
442 
443 int
444 ApDumpTableFromFile (
445     char                    *Pathname)
446 {
447     ACPI_TABLE_HEADER       *Table;
448     UINT32                  FileSize = 0;
449     int                     TableStatus;
450 
451 
452     /* Get the entire ACPI table from the file */
453 
454     Table = ApGetTableFromFile (Pathname, &FileSize);
455     if (!Table)
456     {
457         return (-1);
458     }
459 
460     /* File must be at least as long as the table length */
461 
462     if (Table->Length > FileSize)
463     {
464         fprintf (stderr,
465             "Table length (0x%X) is too large for input file (0x%X) %s\n",
466             Table->Length, FileSize, Pathname);
467         return (-1);
468     }
469 
470     if (Gbl_VerboseMode)
471     {
472         fprintf (stderr,
473             "Input file:  %s contains table [%4.4s], 0x%X (%u) bytes\n",
474             Pathname, Table->Signature, FileSize, FileSize);
475     }
476 
477     TableStatus = ApDumpTableBuffer (Table, 0, 0);
478     free (Table);
479     return (TableStatus);
480 }
481 
482 
483 /******************************************************************************
484  *
485  * FUNCTION:    AcpiOs* print functions
486  *
487  * DESCRIPTION: Used for linkage with ACPICA modules
488  *
489  ******************************************************************************/
490 
491 void ACPI_INTERNAL_VAR_XFACE
492 AcpiOsPrintf (
493     const char              *Fmt,
494     ...)
495 {
496     va_list                 Args;
497 
498     va_start (Args, Fmt);
499     vfprintf (stdout, Fmt, Args);
500     va_end (Args);
501 }
502 
503 void
504 AcpiOsVprintf (
505     const char              *Fmt,
506     va_list                 Args)
507 {
508     vfprintf (stdout, Fmt, Args);
509 }
510