Subversion Repositories Kolibri OS

Rev

Rev 1498 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1498 serge 1
/******************************************************************************
2
 *
3
 * Module Name: uttrack - Memory allocation tracking routines (debug only)
4
 *
5
 *****************************************************************************/
6
 
7
/******************************************************************************
8
 *
9
 * 1. Copyright Notice
10
 *
2216 Serge 11
 * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
1498 serge 12
 * All rights reserved.
13
 *
14
 * 2. License
15
 *
16
 * 2.1. This is your license from Intel Corp. under its intellectual property
17
 * rights.  You may have additional license terms from the party that provided
18
 * you this software, covering your right to use that party's intellectual
19
 * property rights.
20
 *
21
 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22
 * copy of the source code appearing in this file ("Covered Code") an
23
 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24
 * base code distributed originally by Intel ("Original Intel Code") to copy,
25
 * make derivatives, distribute, use and display any portion of the Covered
26
 * Code in any form, with the right to sublicense such rights; and
27
 *
28
 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29
 * license (with the right to sublicense), under only those claims of Intel
30
 * patents that are infringed by the Original Intel Code, to make, use, sell,
31
 * offer to sell, and import the Covered Code and derivative works thereof
32
 * solely to the minimum extent necessary to exercise the above copyright
33
 * license, and in no event shall the patent license extend to any additions
34
 * to or modifications of the Original Intel Code.  No other license or right
35
 * is granted directly or by implication, estoppel or otherwise;
36
 *
37
 * The above copyright and patent license is granted only if the following
38
 * conditions are met:
39
 *
40
 * 3. Conditions
41
 *
42
 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43
 * Redistribution of source code of any substantial portion of the Covered
44
 * Code or modification with rights to further distribute source must include
45
 * the above Copyright Notice, the above License, this list of Conditions,
46
 * and the following Disclaimer and Export Compliance provision.  In addition,
47
 * Licensee must cause all Covered Code to which Licensee contributes to
48
 * contain a file documenting the changes Licensee made to create that Covered
49
 * Code and the date of any change.  Licensee must include in that file the
50
 * documentation of any changes made by any predecessor Licensee.  Licensee
51
 * must include a prominent statement that the modification is derived,
52
 * directly or indirectly, from Original Intel Code.
53
 *
54
 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55
 * Redistribution of source code of any substantial portion of the Covered
56
 * Code or modification without rights to further distribute source must
57
 * include the following Disclaimer and Export Compliance provision in the
58
 * documentation and/or other materials provided with distribution.  In
59
 * addition, Licensee may not authorize further sublicense of source of any
60
 * portion of the Covered Code, and must include terms to the effect that the
61
 * license from Licensee to its licensee is limited to the intellectual
62
 * property embodied in the software Licensee provides to its licensee, and
63
 * not to intellectual property embodied in modifications its licensee may
64
 * make.
65
 *
66
 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67
 * substantial portion of the Covered Code or modification must reproduce the
68
 * above Copyright Notice, and the following Disclaimer and Export Compliance
69
 * provision in the documentation and/or other materials provided with the
70
 * distribution.
71
 *
72
 * 3.4. Intel retains all right, title, and interest in and to the Original
73
 * Intel Code.
74
 *
75
 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76
 * Intel shall be used in advertising or otherwise to promote the sale, use or
77
 * other dealings in products derived from or relating to the Covered Code
78
 * without prior written authorization from Intel.
79
 *
80
 * 4. Disclaimer and Export Compliance
81
 *
82
 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83
 * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84
 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
85
 * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
86
 * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
87
 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88
 * PARTICULAR PURPOSE.
89
 *
90
 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91
 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92
 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93
 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94
 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95
 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
96
 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97
 * LIMITED REMEDY.
98
 *
99
 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100
 * software or system incorporating such software without first obtaining any
101
 * required license or other approval from the U. S. Department of Commerce or
102
 * any other agency or department of the United States Government.  In the
103
 * event Licensee exports any such software from the United States or
104
 * re-exports any such software from a foreign destination, Licensee shall
105
 * ensure that the distribution and export/re-export of the software is in
106
 * compliance with all laws, regulations, orders, or other restrictions of the
107
 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108
 * any of its subsidiaries will export/re-export any technical data, process,
109
 * software, or service, directly or indirectly, to any country for which the
110
 * United States government or any agency thereof requires an export license,
111
 * other governmental approval, or letter of assurance, without first obtaining
112
 * such license, approval or letter.
113
 *
114
 *****************************************************************************/
115
 
116
/*
117
 * These procedures are used for tracking memory leaks in the subsystem, and
118
 * they get compiled out when the ACPI_DBG_TRACK_ALLOCATIONS is not set.
119
 *
120
 * Each memory allocation is tracked via a doubly linked list.  Each
121
 * element contains the caller's component, module name, function name, and
122
 * line number.  AcpiUtAllocate and AcpiUtAllocateZeroed call
123
 * AcpiUtTrackAllocation to add an element to the list; deletion
124
 * occurs in the body of AcpiUtFree.
125
 */
126
 
127
#define __UTTRACK_C__
128
 
129
#include "acpi.h"
130
#include "accommon.h"
131
 
132
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
133
 
134
#define _COMPONENT          ACPI_UTILITIES
135
        ACPI_MODULE_NAME    ("uttrack")
136
 
137
/* Local prototypes */
138
 
139
static ACPI_DEBUG_MEM_BLOCK *
140
AcpiUtFindAllocation (
141
    void                    *Allocation);
142
 
143
static ACPI_STATUS
144
AcpiUtTrackAllocation (
145
    ACPI_DEBUG_MEM_BLOCK    *Address,
146
    ACPI_SIZE               Size,
147
    UINT8                   AllocType,
148
    UINT32                  Component,
149
    const char              *Module,
150
    UINT32                  Line);
151
 
152
static ACPI_STATUS
153
AcpiUtRemoveAllocation (
154
    ACPI_DEBUG_MEM_BLOCK    *Address,
155
    UINT32                  Component,
156
    const char              *Module,
157
    UINT32                  Line);
158
 
159
 
160
/*******************************************************************************
161
 *
162
 * FUNCTION:    AcpiUtCreateList
163
 *
164
 * PARAMETERS:  CacheName       - Ascii name for the cache
165
 *              ObjectSize      - Size of each cached object
166
 *              ReturnCache     - Where the new cache object is returned
167
 *
168
 * RETURN:      Status
169
 *
170
 * DESCRIPTION: Create a local memory list for tracking purposed
171
 *
172
 ******************************************************************************/
173
 
174
ACPI_STATUS
175
AcpiUtCreateList (
176
    char                    *ListName,
177
    UINT16                  ObjectSize,
178
    ACPI_MEMORY_LIST        **ReturnCache)
179
{
180
    ACPI_MEMORY_LIST        *Cache;
181
 
182
 
183
    Cache = AcpiOsAllocate (sizeof (ACPI_MEMORY_LIST));
184
    if (!Cache)
185
    {
186
        return (AE_NO_MEMORY);
187
    }
188
 
189
    ACPI_MEMSET (Cache, 0, sizeof (ACPI_MEMORY_LIST));
190
 
191
    Cache->ListName   = ListName;
192
    Cache->ObjectSize = ObjectSize;
193
 
194
    *ReturnCache = Cache;
195
    return (AE_OK);
196
}
197
 
198
 
199
/*******************************************************************************
200
 *
201
 * FUNCTION:    AcpiUtAllocateAndTrack
202
 *
203
 * PARAMETERS:  Size                - Size of the allocation
204
 *              Component           - Component type of caller
205
 *              Module              - Source file name of caller
206
 *              Line                - Line number of caller
207
 *
208
 * RETURN:      Address of the allocated memory on success, NULL on failure.
209
 *
210
 * DESCRIPTION: The subsystem's equivalent of malloc.
211
 *
212
 ******************************************************************************/
213
 
214
void *
215
AcpiUtAllocateAndTrack (
216
    ACPI_SIZE               Size,
217
    UINT32                  Component,
218
    const char              *Module,
219
    UINT32                  Line)
220
{
221
    ACPI_DEBUG_MEM_BLOCK    *Allocation;
222
    ACPI_STATUS             Status;
223
 
224
 
225
    Allocation = AcpiUtAllocate (Size + sizeof (ACPI_DEBUG_MEM_HEADER),
226
                    Component, Module, Line);
227
    if (!Allocation)
228
    {
229
        return (NULL);
230
    }
231
 
232
    Status = AcpiUtTrackAllocation (Allocation, Size,
233
                    ACPI_MEM_MALLOC, Component, Module, Line);
234
    if (ACPI_FAILURE (Status))
235
    {
236
        AcpiOsFree (Allocation);
237
        return (NULL);
238
    }
239
 
240
    AcpiGbl_GlobalList->TotalAllocated++;
241
    AcpiGbl_GlobalList->TotalSize += (UINT32) Size;
242
    AcpiGbl_GlobalList->CurrentTotalSize += (UINT32) Size;
243
    if (AcpiGbl_GlobalList->CurrentTotalSize > AcpiGbl_GlobalList->MaxOccupied)
244
    {
245
        AcpiGbl_GlobalList->MaxOccupied = AcpiGbl_GlobalList->CurrentTotalSize;
246
    }
247
 
248
    return ((void *) &Allocation->UserSpace);
249
}
250
 
251
 
252
/*******************************************************************************
253
 *
254
 * FUNCTION:    AcpiUtAllocateZeroedAndTrack
255
 *
256
 * PARAMETERS:  Size                - Size of the allocation
257
 *              Component           - Component type of caller
258
 *              Module              - Source file name of caller
259
 *              Line                - Line number of caller
260
 *
261
 * RETURN:      Address of the allocated memory on success, NULL on failure.
262
 *
263
 * DESCRIPTION: Subsystem equivalent of calloc.
264
 *
265
 ******************************************************************************/
266
 
267
void *
268
AcpiUtAllocateZeroedAndTrack (
269
    ACPI_SIZE               Size,
270
    UINT32                  Component,
271
    const char              *Module,
272
    UINT32                  Line)
273
{
274
    ACPI_DEBUG_MEM_BLOCK    *Allocation;
275
    ACPI_STATUS             Status;
276
 
277
 
278
    Allocation = AcpiUtAllocateZeroed (Size + sizeof (ACPI_DEBUG_MEM_HEADER),
279
                    Component, Module, Line);
280
    if (!Allocation)
281
    {
282
        /* Report allocation error */
283
 
284
        ACPI_ERROR ((Module, Line,
285
            "Could not allocate size %u", (UINT32) Size));
286
        return (NULL);
287
    }
288
 
289
    Status = AcpiUtTrackAllocation (Allocation, Size,
290
                ACPI_MEM_CALLOC, Component, Module, Line);
291
    if (ACPI_FAILURE (Status))
292
    {
293
        AcpiOsFree (Allocation);
294
        return (NULL);
295
    }
296
 
297
    AcpiGbl_GlobalList->TotalAllocated++;
298
    AcpiGbl_GlobalList->TotalSize += (UINT32) Size;
299
    AcpiGbl_GlobalList->CurrentTotalSize += (UINT32) Size;
300
    if (AcpiGbl_GlobalList->CurrentTotalSize > AcpiGbl_GlobalList->MaxOccupied)
301
    {
302
        AcpiGbl_GlobalList->MaxOccupied = AcpiGbl_GlobalList->CurrentTotalSize;
303
    }
304
 
305
    return ((void *) &Allocation->UserSpace);
306
}
307
 
308
 
309
/*******************************************************************************
310
 *
311
 * FUNCTION:    AcpiUtFreeAndTrack
312
 *
313
 * PARAMETERS:  Allocation          - Address of the memory to deallocate
314
 *              Component           - Component type of caller
315
 *              Module              - Source file name of caller
316
 *              Line                - Line number of caller
317
 *
318
 * RETURN:      None
319
 *
320
 * DESCRIPTION: Frees the memory at Allocation
321
 *
322
 ******************************************************************************/
323
 
324
void
325
AcpiUtFreeAndTrack (
326
    void                    *Allocation,
327
    UINT32                  Component,
328
    const char              *Module,
329
    UINT32                  Line)
330
{
331
    ACPI_DEBUG_MEM_BLOCK    *DebugBlock;
332
    ACPI_STATUS             Status;
333
 
334
 
335
    ACPI_FUNCTION_TRACE_PTR (UtFree, Allocation);
336
 
337
 
338
    if (NULL == Allocation)
339
    {
340
        ACPI_ERROR ((Module, Line,
341
            "Attempt to delete a NULL address"));
342
 
343
        return_VOID;
344
    }
345
 
346
    DebugBlock = ACPI_CAST_PTR (ACPI_DEBUG_MEM_BLOCK,
347
                    (((char *) Allocation) - sizeof (ACPI_DEBUG_MEM_HEADER)));
348
 
349
    AcpiGbl_GlobalList->TotalFreed++;
350
    AcpiGbl_GlobalList->CurrentTotalSize -= DebugBlock->Size;
351
 
352
    Status = AcpiUtRemoveAllocation (DebugBlock,
353
                    Component, Module, Line);
354
    if (ACPI_FAILURE (Status))
355
    {
356
        ACPI_EXCEPTION ((AE_INFO, Status, "Could not free memory"));
357
    }
358
 
359
    AcpiOsFree (DebugBlock);
360
    ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", Allocation));
361
    return_VOID;
362
}
363
 
364
 
365
/*******************************************************************************
366
 *
367
 * FUNCTION:    AcpiUtFindAllocation
368
 *
369
 * PARAMETERS:  Allocation              - Address of allocated memory
370
 *
371
 * RETURN:      A list element if found; NULL otherwise.
372
 *
373
 * DESCRIPTION: Searches for an element in the global allocation tracking list.
374
 *
375
 ******************************************************************************/
376
 
377
static ACPI_DEBUG_MEM_BLOCK *
378
AcpiUtFindAllocation (
379
    void                    *Allocation)
380
{
381
    ACPI_DEBUG_MEM_BLOCK    *Element;
382
 
383
 
384
    ACPI_FUNCTION_ENTRY ();
385
 
386
 
387
    Element = AcpiGbl_GlobalList->ListHead;
388
 
389
    /* Search for the address. */
390
 
391
    while (Element)
392
    {
393
        if (Element == Allocation)
394
        {
395
            return (Element);
396
        }
397
 
398
        Element = Element->Next;
399
    }
400
 
401
    return (NULL);
402
}
403
 
404
 
405
/*******************************************************************************
406
 *
407
 * FUNCTION:    AcpiUtTrackAllocation
408
 *
409
 * PARAMETERS:  Allocation          - Address of allocated memory
410
 *              Size                - Size of the allocation
411
 *              AllocType           - MEM_MALLOC or MEM_CALLOC
412
 *              Component           - Component type of caller
413
 *              Module              - Source file name of caller
414
 *              Line                - Line number of caller
415
 *
416
 * RETURN:      None.
417
 *
418
 * DESCRIPTION: Inserts an element into the global allocation tracking list.
419
 *
420
 ******************************************************************************/
421
 
422
static ACPI_STATUS
423
AcpiUtTrackAllocation (
424
    ACPI_DEBUG_MEM_BLOCK    *Allocation,
425
    ACPI_SIZE               Size,
426
    UINT8                   AllocType,
427
    UINT32                  Component,
428
    const char              *Module,
429
    UINT32                  Line)
430
{
431
    ACPI_MEMORY_LIST        *MemList;
432
    ACPI_DEBUG_MEM_BLOCK    *Element;
433
    ACPI_STATUS             Status = AE_OK;
434
 
435
 
436
    ACPI_FUNCTION_TRACE_PTR (UtTrackAllocation, Allocation);
437
 
438
 
439
    if (AcpiGbl_DisableMemTracking)
440
    {
441
        return_ACPI_STATUS (AE_OK);
442
    }
443
 
444
    MemList = AcpiGbl_GlobalList;
445
    Status = AcpiUtAcquireMutex (ACPI_MTX_MEMORY);
446
    if (ACPI_FAILURE (Status))
447
    {
448
        return_ACPI_STATUS (Status);
449
    }
450
 
451
    /*
452
     * Search list for this address to make sure it is not already on the list.
453
     * This will catch several kinds of problems.
454
     */
455
    Element = AcpiUtFindAllocation (Allocation);
456
    if (Element)
457
    {
458
        ACPI_ERROR ((AE_INFO,
459
            "UtTrackAllocation: Allocation already present in list! (%p)",
460
            Allocation));
461
 
462
        ACPI_ERROR ((AE_INFO, "Element %p Address %p",
463
            Element, Allocation));
464
 
465
        goto UnlockAndExit;
466
    }
467
 
468
    /* Fill in the instance data. */
469
 
470
    Allocation->Size      = (UINT32) Size;
471
    Allocation->AllocType = AllocType;
472
    Allocation->Component = Component;
473
    Allocation->Line      = Line;
474
 
475
    ACPI_STRNCPY (Allocation->Module, Module, ACPI_MAX_MODULE_NAME);
476
    Allocation->Module[ACPI_MAX_MODULE_NAME-1] = 0;
477
 
478
    /* Insert at list head */
479
 
480
    if (MemList->ListHead)
481
    {
482
        ((ACPI_DEBUG_MEM_BLOCK *)(MemList->ListHead))->Previous = Allocation;
483
    }
484
 
485
    Allocation->Next = MemList->ListHead;
486
    Allocation->Previous = NULL;
487
 
488
    MemList->ListHead = Allocation;
489
 
490
 
491
UnlockAndExit:
492
    Status = AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
493
    return_ACPI_STATUS (Status);
494
}
495
 
496
 
497
/*******************************************************************************
498
 *
499
 * FUNCTION:    AcpiUtRemoveAllocation
500
 *
501
 * PARAMETERS:  Allocation          - Address of allocated memory
502
 *              Component           - Component type of caller
503
 *              Module              - Source file name of caller
504
 *              Line                - Line number of caller
505
 *
506
 * RETURN:
507
 *
508
 * DESCRIPTION: Deletes an element from the global allocation tracking list.
509
 *
510
 ******************************************************************************/
511
 
512
static ACPI_STATUS
513
AcpiUtRemoveAllocation (
514
    ACPI_DEBUG_MEM_BLOCK    *Allocation,
515
    UINT32                  Component,
516
    const char              *Module,
517
    UINT32                  Line)
518
{
519
    ACPI_MEMORY_LIST        *MemList;
520
    ACPI_STATUS             Status;
521
 
522
 
523
    ACPI_FUNCTION_TRACE (UtRemoveAllocation);
524
 
525
 
526
    if (AcpiGbl_DisableMemTracking)
527
    {
528
        return_ACPI_STATUS (AE_OK);
529
    }
530
 
531
    MemList = AcpiGbl_GlobalList;
532
    if (NULL == MemList->ListHead)
533
    {
534
        /* No allocations! */
535
 
536
        ACPI_ERROR ((Module, Line,
537
            "Empty allocation list, nothing to free!"));
538
 
539
        return_ACPI_STATUS (AE_OK);
540
    }
541
 
542
    Status = AcpiUtAcquireMutex (ACPI_MTX_MEMORY);
543
    if (ACPI_FAILURE (Status))
544
    {
545
        return_ACPI_STATUS (Status);
546
    }
547
 
548
    /* Unlink */
549
 
550
    if (Allocation->Previous)
551
    {
552
        (Allocation->Previous)->Next = Allocation->Next;
553
    }
554
    else
555
    {
556
        MemList->ListHead = Allocation->Next;
557
    }
558
 
559
    if (Allocation->Next)
560
    {
561
        (Allocation->Next)->Previous = Allocation->Previous;
562
    }
563
 
564
    /* Mark the segment as deleted */
565
 
566
    ACPI_MEMSET (&Allocation->UserSpace, 0xEA, Allocation->Size);
567
 
568
    ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size 0%X\n",
569
        Allocation->Size));
570
 
571
    Status = AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
572
    return_ACPI_STATUS (Status);
573
}
574
 
575
 
576
/*******************************************************************************
577
 *
578
 * FUNCTION:    AcpiUtDumpAllocationInfo
579
 *
580
 * PARAMETERS:
581
 *
582
 * RETURN:      None
583
 *
584
 * DESCRIPTION: Print some info about the outstanding allocations.
585
 *
586
 ******************************************************************************/
587
 
588
void
589
AcpiUtDumpAllocationInfo (
590
    void)
591
{
592
/*
593
    ACPI_MEMORY_LIST        *MemList;
594
*/
595
 
596
    ACPI_FUNCTION_TRACE (UtDumpAllocationInfo);
597
 
598
/*
599
    ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
600
                    ("%30s: %4d (%3d Kb)\n", "Current allocations",
601
                    MemList->CurrentCount,
602
                    ROUND_UP_TO_1K (MemList->CurrentSize)));
603
 
604
    ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
605
                    ("%30s: %4d (%3d Kb)\n", "Max concurrent allocations",
606
                    MemList->MaxConcurrentCount,
607
                    ROUND_UP_TO_1K (MemList->MaxConcurrentSize)));
608
 
609
 
610
    ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
611
                    ("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
612
                    RunningObjectCount,
613
                    ROUND_UP_TO_1K (RunningObjectSize)));
614
 
615
    ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
616
                    ("%30s: %4d (%3d Kb)\n", "Total (all) allocations",
617
                    RunningAllocCount,
618
                    ROUND_UP_TO_1K (RunningAllocSize)));
619
 
620
 
621
    ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
622
                    ("%30s: %4d (%3d Kb)\n", "Current Nodes",
623
                    AcpiGbl_CurrentNodeCount,
624
                    ROUND_UP_TO_1K (AcpiGbl_CurrentNodeSize)));
625
 
626
    ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
627
                    ("%30s: %4d (%3d Kb)\n", "Max Nodes",
628
                    AcpiGbl_MaxConcurrentNodeCount,
629
                    ROUND_UP_TO_1K ((AcpiGbl_MaxConcurrentNodeCount *
630
                        sizeof (ACPI_NAMESPACE_NODE)))));
631
*/
632
    return_VOID;
633
}
634
 
635
 
636
/*******************************************************************************
637
 *
638
 * FUNCTION:    AcpiUtDumpAllocations
639
 *
640
 * PARAMETERS:  Component           - Component(s) to dump info for.
641
 *              Module              - Module to dump info for.  NULL means all.
642
 *
643
 * RETURN:      None
644
 *
645
 * DESCRIPTION: Print a list of all outstanding allocations.
646
 *
647
 ******************************************************************************/
648
 
649
void
650
AcpiUtDumpAllocations (
651
    UINT32                  Component,
652
    const char              *Module)
653
{
654
    ACPI_DEBUG_MEM_BLOCK    *Element;
655
    ACPI_DESCRIPTOR         *Descriptor;
656
    UINT32                  NumOutstanding = 0;
657
    UINT8                   DescriptorType;
658
 
659
 
660
    ACPI_FUNCTION_TRACE (UtDumpAllocations);
661
 
662
 
663
    if (AcpiGbl_DisableMemTracking)
664
    {
665
        return;
666
    }
667
 
668
    /*
669
     * Walk the allocation list.
670
     */
671
    if (ACPI_FAILURE (AcpiUtAcquireMutex (ACPI_MTX_MEMORY)))
672
    {
673
        return;
674
    }
675
 
676
    Element = AcpiGbl_GlobalList->ListHead;
677
    while (Element)
678
    {
679
        if ((Element->Component & Component) &&
680
            ((Module == NULL) || (0 == ACPI_STRCMP (Module, Element->Module))))
681
        {
682
            Descriptor = ACPI_CAST_PTR (ACPI_DESCRIPTOR, &Element->UserSpace);
683
 
684
            if (Element->Size < sizeof (ACPI_COMMON_DESCRIPTOR))
685
            {
686
                AcpiOsPrintf ("%p Length 0x%04X %9.9s-%u "
687
                    "[Not a Descriptor - too small]\n",
688
                    Descriptor, Element->Size, Element->Module,
689
                    Element->Line);
690
            }
691
            else
692
            {
693
                /* Ignore allocated objects that are in a cache */
694
 
695
                if (ACPI_GET_DESCRIPTOR_TYPE (Descriptor) != ACPI_DESC_TYPE_CACHED)
696
                {
697
                    AcpiOsPrintf ("%p Length 0x%04X %9.9s-%u [%s] ",
698
                        Descriptor, Element->Size, Element->Module,
699
                        Element->Line, AcpiUtGetDescriptorName (Descriptor));
700
 
701
                    /* Validate the descriptor type using Type field and length */
702
 
703
                    DescriptorType = 0; /* Not a valid descriptor type */
704
 
705
                    switch (ACPI_GET_DESCRIPTOR_TYPE (Descriptor))
706
                    {
707
                    case ACPI_DESC_TYPE_OPERAND:
708
                        if (Element->Size == sizeof (ACPI_DESC_TYPE_OPERAND))
709
                        {
710
                            DescriptorType = ACPI_DESC_TYPE_OPERAND;
711
                        }
712
                        break;
713
 
714
                    case ACPI_DESC_TYPE_PARSER:
715
                        if (Element->Size == sizeof (ACPI_DESC_TYPE_PARSER))
716
                        {
717
                            DescriptorType = ACPI_DESC_TYPE_PARSER;
718
                        }
719
                        break;
720
 
721
                    case ACPI_DESC_TYPE_NAMED:
722
                        if (Element->Size == sizeof (ACPI_DESC_TYPE_NAMED))
723
                        {
724
                            DescriptorType = ACPI_DESC_TYPE_NAMED;
725
                        }
726
                        break;
727
 
728
                    default:
729
                        break;
730
                    }
731
 
732
                    /* Display additional info for the major descriptor types */
733
 
734
                    switch (DescriptorType)
735
                    {
736
                    case ACPI_DESC_TYPE_OPERAND:
737
                        AcpiOsPrintf ("%12.12s  RefCount 0x%04X\n",
738
                            AcpiUtGetTypeName (Descriptor->Object.Common.Type),
739
                            Descriptor->Object.Common.ReferenceCount);
740
                        break;
741
 
742
                    case ACPI_DESC_TYPE_PARSER:
743
                        AcpiOsPrintf ("AmlOpcode 0x%04hX\n",
744
                            Descriptor->Op.Asl.AmlOpcode);
745
                        break;
746
 
747
                    case ACPI_DESC_TYPE_NAMED:
748
                        AcpiOsPrintf ("%4.4s\n",
749
                            AcpiUtGetNodeName (&Descriptor->Node));
750
                        break;
751
 
752
                    default:
753
                        AcpiOsPrintf ( "\n");
754
                        break;
755
                    }
756
                }
757
            }
758
 
759
            NumOutstanding++;
760
        }
761
 
762
        Element = Element->Next;
763
    }
764
 
765
    (void) AcpiUtReleaseMutex (ACPI_MTX_MEMORY);
766
 
767
    /* Print summary */
768
 
769
    if (!NumOutstanding)
770
    {
771
        ACPI_INFO ((AE_INFO, "No outstanding allocations"));
772
    }
773
    else
774
    {
775
        ACPI_ERROR ((AE_INFO, "%u(0x%X) Outstanding allocations",
776
            NumOutstanding, NumOutstanding));
777
    }
778
 
779
    return_VOID;
780
}
781
 
782
#endif  /* ACPI_DBG_TRACK_ALLOCATIONS */
783