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