nsdump.c revision 229989 
175592Sru/******************************************************************************
275592Sru *
394427Sru * Module Name: nsdump - table dumping routines for debug
4114412Sru *
594427Sru *****************************************************************************/
694427Sru
775592Sru/*
875592Sru * Copyright (C) 2000 - 2012, Intel Corp.
975592Sru * 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#define __NSDUMP_C__
45
46#include <contrib/dev/acpica/include/acpi.h>
47#include <contrib/dev/acpica/include/accommon.h>
48#include <contrib/dev/acpica/include/acnamesp.h>
49
50
51#define _COMPONENT          ACPI_NAMESPACE
52        ACPI_MODULE_NAME    ("nsdump")
53
54/* Local prototypes */
55
56#ifdef ACPI_OBSOLETE_FUNCTIONS
57void
58AcpiNsDumpRootDevices (
59    void);
60
61static ACPI_STATUS
62AcpiNsDumpOneDevice (
63    ACPI_HANDLE             ObjHandle,
64    UINT32                  Level,
65    void                    *Context,
66    void                    **ReturnValue);
67#endif
68
69
70#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
71/*******************************************************************************
72 *
73 * FUNCTION:    AcpiNsPrintPathname
74 *
75 * PARAMETERS:  NumSegments         - Number of ACPI name segments
76 *              Pathname            - The compressed (internal) path
77 *
78 * RETURN:      None
79 *
80 * DESCRIPTION: Print an object's full namespace pathname
81 *
82 ******************************************************************************/
83
84void
85AcpiNsPrintPathname (
86    UINT32                  NumSegments,
87    char                    *Pathname)
88{
89    UINT32                  i;
90
91
92    ACPI_FUNCTION_NAME (NsPrintPathname);
93
94
95    if (!(AcpiDbgLevel & ACPI_LV_NAMES) || !(AcpiDbgLayer & ACPI_NAMESPACE))
96    {
97        return;
98    }
99
100    /* Print the entire name */
101
102    ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "["));
103
104    while (NumSegments)
105    {
106        for (i = 0; i < 4; i++)
107        {
108            ACPI_IS_PRINT (Pathname[i]) ?
109                AcpiOsPrintf ("%c", Pathname[i]) :
110                AcpiOsPrintf ("?");
111        }
112
113        Pathname += ACPI_NAME_SIZE;
114        NumSegments--;
115        if (NumSegments)
116        {
117            AcpiOsPrintf (".");
118        }
119    }
120
121    AcpiOsPrintf ("]\n");
122}
123
124
125/*******************************************************************************
126 *
127 * FUNCTION:    AcpiNsDumpPathname
128 *
129 * PARAMETERS:  Handle              - Object
130 *              Msg                 - Prefix message
131 *              Level               - Desired debug level
132 *              Component           - Caller's component ID
133 *
134 * RETURN:      None
135 *
136 * DESCRIPTION: Print an object's full namespace pathname
137 *              Manages allocation/freeing of a pathname buffer
138 *
139 ******************************************************************************/
140
141void
142AcpiNsDumpPathname (
143    ACPI_HANDLE             Handle,
144    char                    *Msg,
145    UINT32                  Level,
146    UINT32                  Component)
147{
148
149    ACPI_FUNCTION_TRACE (NsDumpPathname);
150
151
152    /* Do this only if the requested debug level and component are enabled */
153
154    if (!(AcpiDbgLevel & Level) || !(AcpiDbgLayer & Component))
155    {
156        return_VOID;
157    }
158
159    /* Convert handle to a full pathname and print it (with supplied message) */
160
161    AcpiNsPrintNodePathname (Handle, Msg);
162    AcpiOsPrintf ("\n");
163    return_VOID;
164}
165
166
167/*******************************************************************************
168 *
169 * FUNCTION:    AcpiNsDumpOneObject
170 *
171 * PARAMETERS:  ObjHandle           - Node to be dumped
172 *              Level               - Nesting level of the handle
173 *              Context             - Passed into WalkNamespace
174 *              ReturnValue         - Not used
175 *
176 * RETURN:      Status
177 *
178 * DESCRIPTION: Dump a single Node
179 *              This procedure is a UserFunction called by AcpiNsWalkNamespace.
180 *
181 ******************************************************************************/
182
183ACPI_STATUS
184AcpiNsDumpOneObject (
185    ACPI_HANDLE             ObjHandle,
186    UINT32                  Level,
187    void                    *Context,
188    void                    **ReturnValue)
189{
190    ACPI_WALK_INFO          *Info = (ACPI_WALK_INFO *) Context;
191    ACPI_NAMESPACE_NODE     *ThisNode;
192    ACPI_OPERAND_OBJECT     *ObjDesc = NULL;
193    ACPI_OBJECT_TYPE        ObjType;
194    ACPI_OBJECT_TYPE        Type;
195    UINT32                  BytesToDump;
196    UINT32                  DbgLevel;
197    UINT32                  i;
198
199
200    ACPI_FUNCTION_NAME (NsDumpOneObject);
201
202
203    /* Is output enabled? */
204
205    if (!(AcpiDbgLevel & Info->DebugLevel))
206    {
207        return (AE_OK);
208    }
209
210    if (!ObjHandle)
211    {
212        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Null object handle\n"));
213        return (AE_OK);
214    }
215
216    ThisNode = AcpiNsValidateHandle (ObjHandle);
217    if (!ThisNode)
218    {
219        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Invalid object handle %p\n",
220            ObjHandle));
221        return (AE_OK);
222    }
223
224    Type = ThisNode->Type;
225
226    /* Check if the owner matches */
227
228    if ((Info->OwnerId != ACPI_OWNER_ID_MAX) &&
229        (Info->OwnerId != ThisNode->OwnerId))
230    {
231        return (AE_OK);
232    }
233
234    if (!(Info->DisplayType & ACPI_DISPLAY_SHORT))
235    {
236        /* Indent the object according to the level */
237
238        AcpiOsPrintf ("%2d%*s", (UINT32) Level - 1, (int) Level * 2, " ");
239
240        /* Check the node type and name */
241
242        if (Type > ACPI_TYPE_LOCAL_MAX)
243        {
244            ACPI_WARNING ((AE_INFO, "Invalid ACPI Object Type 0x%08X", Type));
245        }
246
247        AcpiOsPrintf ("%4.4s", AcpiUtGetNodeName (ThisNode));
248    }
249
250    /* Now we can print out the pertinent information */
251
252    AcpiOsPrintf (" %-12s %p %2.2X ",
253            AcpiUtGetTypeName (Type), ThisNode, ThisNode->OwnerId);
254
255    DbgLevel = AcpiDbgLevel;
256    AcpiDbgLevel = 0;
257    ObjDesc = AcpiNsGetAttachedObject (ThisNode);
258    AcpiDbgLevel = DbgLevel;
259
260    /* Temp nodes are those nodes created by a control method */
261
262    if (ThisNode->Flags & ANOBJ_TEMPORARY)
263    {
264        AcpiOsPrintf ("(T) ");
265    }
266
267    switch (Info->DisplayType & ACPI_DISPLAY_MASK)
268    {
269    case ACPI_DISPLAY_SUMMARY:
270
271        if (!ObjDesc)
272        {
273            /* No attached object, we are done */
274
275            AcpiOsPrintf ("\n");
276            return (AE_OK);
277        }
278
279        switch (Type)
280        {
281        case ACPI_TYPE_PROCESSOR:
282
283            AcpiOsPrintf ("ID %X Len %.4X Addr %p\n",
284                ObjDesc->Processor.ProcId, ObjDesc->Processor.Length,
285                ACPI_CAST_PTR (void, ObjDesc->Processor.Address));
286            break;
287
288
289        case ACPI_TYPE_DEVICE:
290
291            AcpiOsPrintf ("Notify Object: %p\n", ObjDesc);
292            break;
293
294
295        case ACPI_TYPE_METHOD:
296
297            AcpiOsPrintf ("Args %X Len %.4X Aml %p\n",
298                (UINT32) ObjDesc->Method.ParamCount,
299                ObjDesc->Method.AmlLength, ObjDesc->Method.AmlStart);
300            break;
301
302
303        case ACPI_TYPE_INTEGER:
304
305            AcpiOsPrintf ("= %8.8X%8.8X\n",
306                ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
307            break;
308
309
310        case ACPI_TYPE_PACKAGE:
311
312            if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
313            {
314                AcpiOsPrintf ("Elements %.2X\n",
315                    ObjDesc->Package.Count);
316            }
317            else
318            {
319                AcpiOsPrintf ("[Length not yet evaluated]\n");
320            }
321            break;
322
323
324        case ACPI_TYPE_BUFFER:
325
326            if (ObjDesc->Common.Flags & AOPOBJ_DATA_VALID)
327            {
328                AcpiOsPrintf ("Len %.2X",
329                            ObjDesc->Buffer.Length);
330
331                /* Dump some of the buffer */
332
333                if (ObjDesc->Buffer.Length > 0)
334                {
335                    AcpiOsPrintf (" =");
336                    for (i = 0; (i < ObjDesc->Buffer.Length && i < 12); i++)
337                    {
338                        AcpiOsPrintf (" %.2hX", ObjDesc->Buffer.Pointer[i]);
339                    }
340                }
341                AcpiOsPrintf ("\n");
342            }
343            else
344            {
345                AcpiOsPrintf ("[Length not yet evaluated]\n");
346            }
347            break;
348
349
350        case ACPI_TYPE_STRING:
351
352            AcpiOsPrintf ("Len %.2X ", ObjDesc->String.Length);
353            AcpiUtPrintString (ObjDesc->String.Pointer, 32);
354            AcpiOsPrintf ("\n");
355            break;
356
357
358        case ACPI_TYPE_REGION:
359
360            AcpiOsPrintf ("[%s]",
361                AcpiUtGetRegionName (ObjDesc->Region.SpaceId));
362            if (ObjDesc->Region.Flags & AOPOBJ_DATA_VALID)
363            {
364                AcpiOsPrintf (" Addr %8.8X%8.8X Len %.4X\n",
365                    ACPI_FORMAT_NATIVE_UINT (ObjDesc->Region.Address),
366                    ObjDesc->Region.Length);
367            }
368            else
369            {
370                AcpiOsPrintf (" [Address/Length not yet evaluated]\n");
371            }
372            break;
373
374
375        case ACPI_TYPE_LOCAL_REFERENCE:
376
377            AcpiOsPrintf ("[%s]\n", AcpiUtGetReferenceName (ObjDesc));
378            break;
379
380
381        case ACPI_TYPE_BUFFER_FIELD:
382
383            if (ObjDesc->BufferField.BufferObj &&
384                ObjDesc->BufferField.BufferObj->Buffer.Node)
385            {
386                AcpiOsPrintf ("Buf [%4.4s]",
387                    AcpiUtGetNodeName (
388                        ObjDesc->BufferField.BufferObj->Buffer.Node));
389            }
390            break;
391
392
393        case ACPI_TYPE_LOCAL_REGION_FIELD:
394
395            AcpiOsPrintf ("Rgn [%4.4s]",
396                AcpiUtGetNodeName (
397                    ObjDesc->CommonField.RegionObj->Region.Node));
398            break;
399
400
401        case ACPI_TYPE_LOCAL_BANK_FIELD:
402
403            AcpiOsPrintf ("Rgn [%4.4s] Bnk [%4.4s]",
404                AcpiUtGetNodeName (
405                    ObjDesc->CommonField.RegionObj->Region.Node),
406                AcpiUtGetNodeName (
407                    ObjDesc->BankField.BankObj->CommonField.Node));
408            break;
409
410
411        case ACPI_TYPE_LOCAL_INDEX_FIELD:
412
413            AcpiOsPrintf ("Idx [%4.4s] Dat [%4.4s]",
414                AcpiUtGetNodeName (
415                    ObjDesc->IndexField.IndexObj->CommonField.Node),
416                AcpiUtGetNodeName (
417                    ObjDesc->IndexField.DataObj->CommonField.Node));
418            break;
419
420
421        case ACPI_TYPE_LOCAL_ALIAS:
422        case ACPI_TYPE_LOCAL_METHOD_ALIAS:
423
424            AcpiOsPrintf ("Target %4.4s (%p)\n",
425                AcpiUtGetNodeName (ObjDesc), ObjDesc);
426            break;
427
428        default:
429
430            AcpiOsPrintf ("Object %p\n", ObjDesc);
431            break;
432        }
433
434        /* Common field handling */
435
436        switch (Type)
437        {
438        case ACPI_TYPE_BUFFER_FIELD:
439        case ACPI_TYPE_LOCAL_REGION_FIELD:
440        case ACPI_TYPE_LOCAL_BANK_FIELD:
441        case ACPI_TYPE_LOCAL_INDEX_FIELD:
442
443            AcpiOsPrintf (" Off %.3X Len %.2X Acc %.2hd\n",
444                (ObjDesc->CommonField.BaseByteOffset * 8)
445                    + ObjDesc->CommonField.StartFieldBitOffset,
446                ObjDesc->CommonField.BitLength,
447                ObjDesc->CommonField.AccessByteWidth);
448            break;
449
450        default:
451            break;
452        }
453        break;
454
455
456    case ACPI_DISPLAY_OBJECTS:
457
458        AcpiOsPrintf ("O:%p", ObjDesc);
459        if (!ObjDesc)
460        {
461            /* No attached object, we are done */
462
463            AcpiOsPrintf ("\n");
464            return (AE_OK);
465        }
466
467        AcpiOsPrintf ("(R%u)", ObjDesc->Common.ReferenceCount);
468
469        switch (Type)
470        {
471        case ACPI_TYPE_METHOD:
472
473            /* Name is a Method and its AML offset/length are set */
474
475            AcpiOsPrintf (" M:%p-%X\n", ObjDesc->Method.AmlStart,
476                ObjDesc->Method.AmlLength);
477            break;
478
479        case ACPI_TYPE_INTEGER:
480
481            AcpiOsPrintf (" I:%8.8X8.8%X\n",
482                ACPI_FORMAT_UINT64 (ObjDesc->Integer.Value));
483            break;
484
485        case ACPI_TYPE_STRING:
486
487            AcpiOsPrintf (" S:%p-%X\n", ObjDesc->String.Pointer,
488                ObjDesc->String.Length);
489            break;
490
491        case ACPI_TYPE_BUFFER:
492
493            AcpiOsPrintf (" B:%p-%X\n", ObjDesc->Buffer.Pointer,
494                ObjDesc->Buffer.Length);
495            break;
496
497        default:
498
499            AcpiOsPrintf ("\n");
500            break;
501        }
502        break;
503
504
505    default:
506        AcpiOsPrintf ("\n");
507        break;
508    }
509
510    /* If debug turned off, done */
511
512    if (!(AcpiDbgLevel & ACPI_LV_VALUES))
513    {
514        return (AE_OK);
515    }
516
517    /* If there is an attached object, display it */
518
519    DbgLevel     = AcpiDbgLevel;
520    AcpiDbgLevel = 0;
521    ObjDesc      = AcpiNsGetAttachedObject (ThisNode);
522    AcpiDbgLevel = DbgLevel;
523
524    /* Dump attached objects */
525
526    while (ObjDesc)
527    {
528        ObjType = ACPI_TYPE_INVALID;
529        AcpiOsPrintf ("Attached Object %p: ", ObjDesc);
530
531        /* Decode the type of attached object and dump the contents */
532
533        switch (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc))
534        {
535        case ACPI_DESC_TYPE_NAMED:
536
537            AcpiOsPrintf ("(Ptr to Node)\n");
538            BytesToDump = sizeof (ACPI_NAMESPACE_NODE);
539            ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
540            break;
541
542        case ACPI_DESC_TYPE_OPERAND:
543
544            ObjType = ObjDesc->Common.Type;
545
546            if (ObjType > ACPI_TYPE_LOCAL_MAX)
547            {
548                AcpiOsPrintf ("(Pointer to ACPI Object type %.2X [UNKNOWN])\n",
549                    ObjType);
550                BytesToDump = 32;
551            }
552            else
553            {
554                AcpiOsPrintf ("(Pointer to ACPI Object type %.2X [%s])\n",
555                    ObjType, AcpiUtGetTypeName (ObjType));
556                BytesToDump = sizeof (ACPI_OPERAND_OBJECT);
557            }
558
559            ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
560            break;
561
562        default:
563
564            break;
565        }
566
567        /* If value is NOT an internal object, we are done */
568
569        if (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND)
570        {
571            goto Cleanup;
572        }
573
574        /* Valid object, get the pointer to next level, if any */
575
576        switch (ObjType)
577        {
578        case ACPI_TYPE_BUFFER:
579        case ACPI_TYPE_STRING:
580            /*
581             * NOTE: takes advantage of common fields between string/buffer
582             */
583            BytesToDump = ObjDesc->String.Length;
584            ObjDesc = (void *) ObjDesc->String.Pointer;
585            AcpiOsPrintf ( "(Buffer/String pointer %p length %X)\n",
586                ObjDesc, BytesToDump);
587            ACPI_DUMP_BUFFER (ObjDesc, BytesToDump);
588            goto Cleanup;
589
590        case ACPI_TYPE_BUFFER_FIELD:
591            ObjDesc = (ACPI_OPERAND_OBJECT *) ObjDesc->BufferField.BufferObj;
592            break;
593
594        case ACPI_TYPE_PACKAGE:
595            ObjDesc = (void *) ObjDesc->Package.Elements;
596            break;
597
598        case ACPI_TYPE_METHOD:
599            ObjDesc = (void *) ObjDesc->Method.AmlStart;
600            break;
601
602        case ACPI_TYPE_LOCAL_REGION_FIELD:
603            ObjDesc = (void *) ObjDesc->Field.RegionObj;
604            break;
605
606        case ACPI_TYPE_LOCAL_BANK_FIELD:
607            ObjDesc = (void *) ObjDesc->BankField.RegionObj;
608            break;
609
610        case ACPI_TYPE_LOCAL_INDEX_FIELD:
611            ObjDesc = (void *) ObjDesc->IndexField.IndexObj;
612            break;
613
614        default:
615            goto Cleanup;
616        }
617
618        ObjType = ACPI_TYPE_INVALID;   /* Terminate loop after next pass */
619    }
620
621Cleanup:
622    AcpiOsPrintf ("\n");
623    return (AE_OK);
624}
625
626
627/*******************************************************************************
628 *
629 * FUNCTION:    AcpiNsDumpObjects
630 *
631 * PARAMETERS:  Type                - Object type to be dumped
632 *              DisplayType         - 0 or ACPI_DISPLAY_SUMMARY
633 *              MaxDepth            - Maximum depth of dump. Use ACPI_UINT32_MAX
634 *                                    for an effectively unlimited depth.
635 *              OwnerId             - Dump only objects owned by this ID. Use
636 *                                    ACPI_UINT32_MAX to match all owners.
637 *              StartHandle         - Where in namespace to start/end search
638 *
639 * RETURN:      None
640 *
641 * DESCRIPTION: Dump typed objects within the loaded namespace. Uses
642 *              AcpiNsWalkNamespace in conjunction with AcpiNsDumpOneObject.
643 *
644 ******************************************************************************/
645
646void
647AcpiNsDumpObjects (
648    ACPI_OBJECT_TYPE        Type,
649    UINT8                   DisplayType,
650    UINT32                  MaxDepth,
651    ACPI_OWNER_ID           OwnerId,
652    ACPI_HANDLE             StartHandle)
653{
654    ACPI_WALK_INFO          Info;
655    ACPI_STATUS             Status;
656
657
658    ACPI_FUNCTION_ENTRY ();
659
660
661    /*
662     * Just lock the entire namespace for the duration of the dump.
663     * We don't want any changes to the namespace during this time,
664     * especially the temporary nodes since we are going to display
665     * them also.
666     */
667    Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
668    if (ACPI_FAILURE (Status))
669    {
670        AcpiOsPrintf ("Could not acquire namespace mutex\n");
671        return;
672    }
673
674    Info.DebugLevel = ACPI_LV_TABLES;
675    Info.OwnerId = OwnerId;
676    Info.DisplayType = DisplayType;
677
678    (void) AcpiNsWalkNamespace (Type, StartHandle, MaxDepth,
679                ACPI_NS_WALK_NO_UNLOCK | ACPI_NS_WALK_TEMP_NODES,
680                AcpiNsDumpOneObject, NULL, (void *) &Info, NULL);
681
682    (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
683}
684
685
686/*******************************************************************************
687 *
688 * FUNCTION:    AcpiNsDumpEntry
689 *
690 * PARAMETERS:  Handle              - Node to be dumped
691 *              DebugLevel          - Output level
692 *
693 * RETURN:      None
694 *
695 * DESCRIPTION: Dump a single Node
696 *
697 ******************************************************************************/
698
699void
700AcpiNsDumpEntry (
701    ACPI_HANDLE             Handle,
702    UINT32                  DebugLevel)
703{
704    ACPI_WALK_INFO          Info;
705
706
707    ACPI_FUNCTION_ENTRY ();
708
709
710    Info.DebugLevel = DebugLevel;
711    Info.OwnerId = ACPI_OWNER_ID_MAX;
712    Info.DisplayType = ACPI_DISPLAY_SUMMARY;
713
714    (void) AcpiNsDumpOneObject (Handle, 1, &Info, NULL);
715}
716
717
718#ifdef ACPI_ASL_COMPILER
719/*******************************************************************************
720 *
721 * FUNCTION:    AcpiNsDumpTables
722 *
723 * PARAMETERS:  SearchBase          - Root of subtree to be dumped, or
724 *                                    NS_ALL to dump the entire namespace
725 *              MaxDepth            - Maximum depth of dump.  Use INT_MAX
726 *                                    for an effectively unlimited depth.
727 *
728 * RETURN:      None
729 *
730 * DESCRIPTION: Dump the name space, or a portion of it.
731 *
732 ******************************************************************************/
733
734void
735AcpiNsDumpTables (
736    ACPI_HANDLE             SearchBase,
737    UINT32                  MaxDepth)
738{
739    ACPI_HANDLE             SearchHandle = SearchBase;
740
741
742    ACPI_FUNCTION_TRACE (NsDumpTables);
743
744
745    if (!AcpiGbl_RootNode)
746    {
747        /*
748         * If the name space has not been initialized,
749         * there is nothing to dump.
750         */
751        ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "namespace not initialized!\n"));
752        return_VOID;
753    }
754
755    if (ACPI_NS_ALL == SearchBase)
756    {
757        /* Entire namespace */
758
759        SearchHandle = AcpiGbl_RootNode;
760        ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "\\\n"));
761    }
762
763    AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, MaxDepth,
764            ACPI_OWNER_ID_MAX, SearchHandle);
765    return_VOID;
766}
767#endif
768#endif
769
770