xref: /illumos-gate/usr/src/cmd/acpi/acpixtract/acpixtract.c (revision 35786f6866ae52207d0f1a25fe7ca5f652f32ce0)
1 /******************************************************************************
2  *
3  * Module Name: acpixtract - Top level functions to convert ascii/hex
4  *                           ACPI tables to the original binary tables
5  *
6  *****************************************************************************/
7 
8 /******************************************************************************
9  *
10  * 1. Copyright Notice
11  *
12  * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
13  * All rights reserved.
14  *
15  * 2. License
16  *
17  * 2.1. This is your license from Intel Corp. under its intellectual property
18  * rights. You may have additional license terms from the party that provided
19  * you this software, covering your right to use that party's intellectual
20  * property rights.
21  *
22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
23  * copy of the source code appearing in this file ("Covered Code") an
24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
25  * base code distributed originally by Intel ("Original Intel Code") to copy,
26  * make derivatives, distribute, use and display any portion of the Covered
27  * Code in any form, with the right to sublicense such rights; and
28  *
29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
30  * license (with the right to sublicense), under only those claims of Intel
31  * patents that are infringed by the Original Intel Code, to make, use, sell,
32  * offer to sell, and import the Covered Code and derivative works thereof
33  * solely to the minimum extent necessary to exercise the above copyright
34  * license, and in no event shall the patent license extend to any additions
35  * to or modifications of the Original Intel Code. No other license or right
36  * is granted directly or by implication, estoppel or otherwise;
37  *
38  * The above copyright and patent license is granted only if the following
39  * conditions are met:
40  *
41  * 3. Conditions
42  *
43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
44  * Redistribution of source code of any substantial portion of the Covered
45  * Code or modification with rights to further distribute source must include
46  * the above Copyright Notice, the above License, this list of Conditions,
47  * and the following Disclaimer and Export Compliance provision. In addition,
48  * Licensee must cause all Covered Code to which Licensee contributes to
49  * contain a file documenting the changes Licensee made to create that Covered
50  * Code and the date of any change. Licensee must include in that file the
51  * documentation of any changes made by any predecessor Licensee. Licensee
52  * must include a prominent statement that the modification is derived,
53  * directly or indirectly, from Original Intel Code.
54  *
55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
56  * Redistribution of source code of any substantial portion of the Covered
57  * Code or modification without rights to further distribute source must
58  * include the following Disclaimer and Export Compliance provision in the
59  * documentation and/or other materials provided with distribution. In
60  * addition, Licensee may not authorize further sublicense of source of any
61  * portion of the Covered Code, and must include terms to the effect that the
62  * license from Licensee to its licensee is limited to the intellectual
63  * property embodied in the software Licensee provides to its licensee, and
64  * not to intellectual property embodied in modifications its licensee may
65  * make.
66  *
67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
68  * substantial portion of the Covered Code or modification must reproduce the
69  * above Copyright Notice, and the following Disclaimer and Export Compliance
70  * provision in the documentation and/or other materials provided with the
71  * distribution.
72  *
73  * 3.4. Intel retains all right, title, and interest in and to the Original
74  * Intel Code.
75  *
76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
77  * Intel shall be used in advertising or otherwise to promote the sale, use or
78  * other dealings in products derived from or relating to the Covered Code
79  * without prior written authorization from Intel.
80  *
81  * 4. Disclaimer and Export Compliance
82  *
83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
84  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
86  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
87  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
89  * PARTICULAR PURPOSE.
90  *
91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
98  * LIMITED REMEDY.
99  *
100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
101  * software or system incorporating such software without first obtaining any
102  * required license or other approval from the U. S. Department of Commerce or
103  * any other agency or department of the United States Government. In the
104  * event Licensee exports any such software from the United States or
105  * re-exports any such software from a foreign destination, Licensee shall
106  * ensure that the distribution and export/re-export of the software is in
107  * compliance with all laws, regulations, orders, or other restrictions of the
108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
109  * any of its subsidiaries will export/re-export any technical data, process,
110  * software, or service, directly or indirectly, to any country for which the
111  * United States government or any agency thereof requires an export license,
112  * other governmental approval, or letter of assurance, without first obtaining
113  * such license, approval or letter.
114  *
115  *****************************************************************************
116  *
117  * Alternatively, you may choose to be licensed under the terms of the
118  * following license:
119  *
120  * Redistribution and use in source and binary forms, with or without
121  * modification, are permitted provided that the following conditions
122  * are met:
123  * 1. Redistributions of source code must retain the above copyright
124  *    notice, this list of conditions, and the following disclaimer,
125  *    without modification.
126  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
127  *    substantially similar to the "NO WARRANTY" disclaimer below
128  *    ("Disclaimer") and any redistribution must be conditioned upon
129  *    including a substantially similar Disclaimer requirement for further
130  *    binary redistribution.
131  * 3. Neither the names of the above-listed copyright holders nor the names
132  *    of any contributors may be used to endorse or promote products derived
133  *    from this software without specific prior written permission.
134  *
135  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
136  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
137  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
138  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
139  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
140  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
141  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
142  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
143  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
144  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
145  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
146  *
147  * Alternatively, you may choose to be licensed under the terms of the
148  * GNU General Public License ("GPL") version 2 as published by the Free
149  * Software Foundation.
150  *
151  *****************************************************************************/
152 
153 #include "acpixtract.h"
154 
155 
156 /******************************************************************************
157  *
158  * FUNCTION:    AxExtractTables
159  *
160  * PARAMETERS:  InputPathname       - Filename for input acpidump file
161  *              Signature           - Requested ACPI signature to extract.
162  *                                    NULL means extract ALL tables.
163  *              MinimumInstances    - Min instances that are acceptable
164  *
165  * RETURN:      Status
166  *
167  * DESCRIPTION: Convert text ACPI tables to binary
168  *
169  ******************************************************************************/
170 
171 int
AxExtractTables(char * InputPathname,char * Signature,unsigned int MinimumInstances)172 AxExtractTables (
173     char                    *InputPathname,
174     char                    *Signature,
175     unsigned int            MinimumInstances)
176 {
177     FILE                    *InputFile;
178     FILE                    *OutputFile = NULL;
179     unsigned int            BytesConverted;
180     unsigned int            ThisTableBytesWritten = 0;
181     unsigned int            FoundTable = 0;
182     unsigned int            Instances = 0;
183     unsigned int            ThisInstance;
184     char                    ThisSignature[5];
185     char                    UpperSignature[5];
186     int                     Status = 0;
187     unsigned int            State = AX_STATE_FIND_HEADER;
188 
189 
190     /* Open input in text mode, output is in binary mode */
191 
192     InputFile = fopen (InputPathname, "r");
193     if (!InputFile)
194     {
195         printf ("Could not open input file %s\n", InputPathname);
196         return (-1);
197     }
198 
199     if (!AxIsFileAscii (InputFile))
200     {
201         fclose (InputFile);
202         return (-1);
203     }
204 
205     if (Signature)
206     {
207         strncpy (UpperSignature, Signature, ACPI_NAME_SIZE);
208         AcpiUtStrupr (UpperSignature);
209 
210         /* Are there enough instances of the table to continue? */
211 
212         AxNormalizeSignature (UpperSignature);
213         Instances = AxCountTableInstances (InputPathname, UpperSignature);
214 
215         if (Instances < MinimumInstances)
216         {
217             printf ("Table [%s] was not found in %s\n",
218                 UpperSignature, InputPathname);
219             fclose (InputFile);
220             return (0);             /* Don't abort */
221         }
222 
223         if (Instances == 0)
224         {
225             fclose (InputFile);
226             return (-1);
227         }
228     }
229 
230     /* Convert all instances of the table to binary */
231 
232     while (fgets (Gbl_LineBuffer, AX_LINE_BUFFER_SIZE, InputFile))
233     {
234         /*
235          * Check up front if we have a header line of the form:
236          * DSDT @ 0xdfffd0c0 (10999 bytes)
237          */
238         if (AX_IS_TABLE_BLOCK_HEADER &&
239             (State == AX_STATE_EXTRACT_DATA))
240         {
241             /* End of previous table, start of new table */
242 
243             if (ThisTableBytesWritten)
244             {
245                 printf (AX_TABLE_INFO_FORMAT, ThisSignature, ThisTableBytesWritten,
246                     ThisTableBytesWritten, Gbl_OutputFilename);
247             }
248             else
249             {
250                 Gbl_TableCount--;
251             }
252 
253             State = AX_STATE_FIND_HEADER;
254         }
255 
256         switch (State)
257         {
258         case AX_STATE_FIND_HEADER:
259 
260             if (!AxIsDataBlockHeader ())
261             {
262                 continue;
263             }
264 
265             ACPI_MOVE_NAME (ThisSignature, Gbl_LineBuffer);
266             if (Signature)
267             {
268                 /* Ignore signatures that don't match */
269 
270                 if (!ACPI_COMPARE_NAME (ThisSignature, UpperSignature))
271                 {
272                     continue;
273                 }
274             }
275 
276             /*
277              * Get the instance number for this signature. Only the
278              * SSDT and PSDT tables can have multiple instances.
279              */
280             ThisInstance = AxGetNextInstance (InputPathname, ThisSignature);
281 
282             /* Build an output filename and create/open the output file */
283 
284             if (ThisInstance > 0)
285             {
286                 /* Add instance number to the output filename */
287 
288                 sprintf (Gbl_OutputFilename, "%4.4s%u.dat",
289                     ThisSignature, ThisInstance);
290             }
291             else
292             {
293                 sprintf (Gbl_OutputFilename, "%4.4s.dat",
294                     ThisSignature);
295             }
296 
297             AcpiUtStrlwr (Gbl_OutputFilename);
298             OutputFile = fopen (Gbl_OutputFilename, "w+b");
299             if (!OutputFile)
300             {
301                 printf ("Could not open output file %s\n",
302                     Gbl_OutputFilename);
303                 fclose (InputFile);
304                 return (-1);
305             }
306 
307             /*
308              * Toss this block header of the form "<sig> @ <addr>" line
309              * and move on to the actual data block
310              */
311             Gbl_TableCount++;
312             FoundTable = 1;
313             ThisTableBytesWritten = 0;
314             State = AX_STATE_EXTRACT_DATA;
315             continue;
316 
317         case AX_STATE_EXTRACT_DATA:
318 
319             if (!AxIsHexDataLine ())
320             {
321                 continue;   /* Toss any lines that are not raw hex data */
322             }
323 
324             /* Empty line or non-data line terminates the data block */
325 
326             BytesConverted = AxConvertAndWrite (OutputFile, ThisSignature,
327                 ThisTableBytesWritten);
328             switch (BytesConverted)
329             {
330             case 0:
331 
332                 State = AX_STATE_FIND_HEADER; /* No more data block lines */
333                 continue;
334 
335             case -1:
336 
337                 goto CleanupAndExit; /* There was a write error */
338 
339             default: /* Normal case, get next line */
340 
341                 ThisTableBytesWritten += BytesConverted;
342                 continue;
343             }
344 
345         default:
346 
347             Status = -1;
348             goto CleanupAndExit;
349         }
350     }
351 
352     if (!FoundTable)
353     {
354         printf ("No ACPI tables were found in %s\n", InputPathname);
355     }
356 
357 
358 CleanupAndExit:
359 
360     if (State == AX_STATE_EXTRACT_DATA)
361     {
362         /* Received an input file EOF while extracting data */
363 
364         printf (AX_TABLE_INFO_FORMAT, ThisSignature, ThisTableBytesWritten,
365             ThisTableBytesWritten, Gbl_OutputFilename);
366     }
367 
368     if (OutputFile)
369     {
370         fclose (OutputFile);
371     }
372 
373     fclose (InputFile);
374     return (Status);
375 }
376 
377 
378 /******************************************************************************
379  *
380  * FUNCTION:    AxExtractToMultiAmlFile
381  *
382  * PARAMETERS:  InputPathname       - Filename for input acpidump file
383  *
384  * RETURN:      Status
385  *
386  * DESCRIPTION: Convert all DSDT/SSDT tables to binary and append them all
387  *              into a single output file. Used to simplify the loading of
388  *              multiple/many SSDTs into a utility like acpiexec -- instead
389  *              of creating many separate output files.
390  *
391  ******************************************************************************/
392 
393 int
AxExtractToMultiAmlFile(char * InputPathname)394 AxExtractToMultiAmlFile (
395     char                    *InputPathname)
396 {
397     FILE                    *InputFile;
398     FILE                    *OutputFile;
399     int                     Status = 0;
400     unsigned int            TotalBytesWritten = 0;
401     unsigned int            ThisTableBytesWritten = 0;
402     unsigned int            BytesConverted;
403     char                    ThisSignature[4];
404     unsigned int            State = AX_STATE_FIND_HEADER;
405 
406 
407     strcpy (Gbl_OutputFilename, AX_MULTI_TABLE_FILENAME);
408 
409     /* Open the input file in text mode */
410 
411     InputFile = fopen (InputPathname, "r");
412     if (!InputFile)
413     {
414         printf ("Could not open input file %s\n", InputPathname);
415         return (-1);
416     }
417 
418     if (!AxIsFileAscii (InputFile))
419     {
420         fclose (InputFile);
421         return (-1);
422     }
423 
424     /* Open the output file in binary mode */
425 
426     OutputFile = fopen (Gbl_OutputFilename, "w+b");
427     if (!OutputFile)
428     {
429         printf ("Could not open output file %s\n", Gbl_OutputFilename);
430         fclose (InputFile);
431         return (-1);
432     }
433 
434     /* Convert the DSDT and all SSDTs to binary */
435 
436     while (fgets (Gbl_LineBuffer, AX_LINE_BUFFER_SIZE, InputFile))
437     {
438         /*
439          * Check up front if we have a header line of the form:
440          * DSDT @ 0xdfffd0c0 (10999 bytes)
441          */
442         if (AX_IS_TABLE_BLOCK_HEADER &&
443             (State == AX_STATE_EXTRACT_DATA))
444         {
445             /* End of previous table, start of new table */
446 
447             if (ThisTableBytesWritten)
448             {
449                 printf (AX_TABLE_INFO_FORMAT, ThisSignature, ThisTableBytesWritten,
450                     ThisTableBytesWritten, Gbl_OutputFilename);
451             }
452             else
453             {
454                 Gbl_TableCount--;
455             }
456 
457             State = AX_STATE_FIND_HEADER;
458         }
459 
460         switch (State)
461         {
462         case AX_STATE_FIND_HEADER:
463 
464             if (!AxIsDataBlockHeader ())
465             {
466                 continue;
467             }
468 
469             ACPI_MOVE_NAME (ThisSignature, Gbl_LineBuffer);
470 
471             /* Only want DSDT and SSDTs */
472 
473             if (!ACPI_COMPARE_NAME (ThisSignature, ACPI_SIG_DSDT) &&
474                 !ACPI_COMPARE_NAME (ThisSignature, ACPI_SIG_SSDT))
475             {
476                 continue;
477             }
478 
479             /*
480              * Toss this block header of the form "<sig> @ <addr>" line
481              * and move on to the actual data block
482              */
483             Gbl_TableCount++;
484             ThisTableBytesWritten = 0;
485             State = AX_STATE_EXTRACT_DATA;
486             continue;
487 
488         case AX_STATE_EXTRACT_DATA:
489 
490             if (!AxIsHexDataLine ())
491             {
492                 continue;   /* Toss any lines that are not raw hex data */
493             }
494 
495             /* Empty line or non-data line terminates the data block */
496 
497             BytesConverted = AxConvertAndWrite (
498                 OutputFile, ThisSignature, ThisTableBytesWritten);
499             switch (BytesConverted)
500             {
501             case 0:
502 
503                 State = AX_STATE_FIND_HEADER; /* No more data block lines */
504                 continue;
505 
506             case -1:
507 
508                 goto CleanupAndExit; /* There was a write error */
509 
510             default: /* Normal case, get next line */
511 
512                 ThisTableBytesWritten += BytesConverted;
513                 TotalBytesWritten += BytesConverted;
514                 continue;
515             }
516 
517         default:
518 
519             Status = -1;
520             goto CleanupAndExit;
521         }
522     }
523 
524 
525 CleanupAndExit:
526 
527     if (State == AX_STATE_EXTRACT_DATA)
528     {
529         /* Received an input file EOF or error while writing data */
530 
531         printf (AX_TABLE_INFO_FORMAT, ThisSignature, ThisTableBytesWritten,
532             ThisTableBytesWritten, Gbl_OutputFilename);
533     }
534 
535     printf ("\n%u binary ACPI tables extracted and written to %s (%u bytes)\n",
536         Gbl_TableCount, Gbl_OutputFilename, TotalBytesWritten);
537 
538     fclose (InputFile);
539     fclose (OutputFile);
540     return (Status);
541 }
542 
543 
544 /******************************************************************************
545  *
546  * FUNCTION:    AxListAllTables
547  *
548  * PARAMETERS:  InputPathname       - Filename for acpidump file
549  *
550  * RETURN:      Status
551  *
552  * DESCRIPTION: Display info for all ACPI tables found in input. Does not
553  *              perform an actual extraction of the tables.
554  *
555  ******************************************************************************/
556 
557 int
AxListAllTables(char * InputPathname)558 AxListAllTables (
559     char                    *InputPathname)
560 {
561     FILE                    *InputFile;
562     unsigned char           Header[48];
563     UINT32                  ByteCount = 0;
564     unsigned int            State = AX_STATE_FIND_HEADER;
565 
566 
567     /* Open input in text mode, output is in binary mode */
568 
569     InputFile = fopen (InputPathname, "r");
570     if (!InputFile)
571     {
572         printf ("Could not open input file %s\n", InputPathname);
573         return (-1);
574     }
575 
576     if (!AxIsFileAscii (InputFile))
577     {
578         fclose (InputFile);
579         return (-1);
580     }
581 
582     /* Info header */
583 
584     printf ("\n Signature  Length    Version Oem       Oem         "
585         "Oem         Compiler Compiler\n");
586     printf (  "                              Id        TableId     "
587         "RevisionId  Name     Revision\n");
588     printf (  " _________  __________  ____  ________  __________  "
589         "__________  _______  __________\n\n");
590 
591     /* Dump the headers for all tables found in the input file */
592 
593     while (fgets (Gbl_LineBuffer, AX_LINE_BUFFER_SIZE, InputFile))
594     {
595         /* Ignore empty lines */
596 
597         if (AxIsEmptyLine (Gbl_LineBuffer))
598         {
599             continue;
600         }
601 
602         /*
603          * Check up front if we have a header line of the form:
604          * DSDT @ 0xdfffd0c0 (10999 bytes)
605          */
606         if (AX_IS_TABLE_BLOCK_HEADER &&
607             (State == AX_STATE_EXTRACT_DATA))
608         {
609             State = AX_STATE_FIND_HEADER;
610         }
611 
612         switch (State)
613         {
614         case AX_STATE_FIND_HEADER:
615 
616             ByteCount = 0;
617             if (!AxIsDataBlockHeader ())
618             {
619                 continue;
620             }
621 
622             State = AX_STATE_EXTRACT_DATA;
623             continue;
624 
625         case AX_STATE_EXTRACT_DATA:
626 
627             /* Ignore any lines that don't look like a data line */
628 
629             if (!AxIsHexDataLine ())
630             {
631                 continue;   /* Toss any lines that are not raw hex data */
632             }
633 
634             /* Convert header to hex and display it */
635 
636             ByteCount += AxConvertToBinary (Gbl_LineBuffer, &Header[ByteCount]);
637             if (ByteCount >= sizeof (ACPI_TABLE_HEADER))
638             {
639                 AxDumpTableHeader (Header);
640                 State = AX_STATE_FIND_HEADER;
641             }
642             continue;
643 
644         default:
645             break;
646         }
647     }
648 
649     printf ("\nFound %u ACPI tables in %s\n", Gbl_TableCount, InputPathname);
650     fclose (InputFile);
651     return (0);
652 }
653