Print this page
update to acpica-unix2-20140114
acpica-unix2-20130823
PANKOVs restructure
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/acpica/debugger/dbstats.c
+++ new/usr/src/common/acpica/components/debugger/dbstats.c
1 1 /*******************************************************************************
2 2 *
3 3 * Module Name: dbstats - Generation and display of ACPI table statistics
4 4 *
5 5 ******************************************************************************/
6 6
7 7 /*
8 - * Copyright (C) 2000 - 2011, Intel Corp.
8 + * Copyright (C) 2000 - 2014, Intel Corp.
9 9 * All rights reserved.
10 10 *
11 11 * Redistribution and use in source and binary forms, with or without
12 12 * modification, are permitted provided that the following conditions
13 13 * are met:
14 14 * 1. Redistributions of source code must retain the above copyright
15 15 * notice, this list of conditions, and the following disclaimer,
16 16 * without modification.
17 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 20 * including a substantially similar Disclaimer requirement for further
21 21 * binary redistribution.
22 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 23 * of any contributors may be used to endorse or promote products derived
24 24 * from this software without specific prior written permission.
25 25 *
26 26 * Alternatively, this software may be distributed under the terms of the
27 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 28 * Software Foundation.
29 29 *
30 30 * NO WARRANTY
31 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 41 * POSSIBILITY OF SUCH DAMAGES.
42 42 */
43 43
44 44
45 45 #include "acpi.h"
46 46 #include "accommon.h"
47 47 #include "acdebug.h"
48 48 #include "acnamesp.h"
49 49
50 50 #ifdef ACPI_DEBUGGER
51 51
52 52 #define _COMPONENT ACPI_CA_DEBUGGER
53 53 ACPI_MODULE_NAME ("dbstats")
54 54
55 55 /* Local prototypes */
56 56
57 57 static void
58 58 AcpiDbCountNamespaceObjects (
59 59 void);
60 60
61 61 static void
62 62 AcpiDbEnumerateObject (
63 63 ACPI_OPERAND_OBJECT *ObjDesc);
64 64
65 65 static ACPI_STATUS
66 66 AcpiDbClassifyOneObject (
67 67 ACPI_HANDLE ObjHandle,
68 68 UINT32 NestingLevel,
69 69 void *Context,
70 70 void **ReturnValue);
71 71
|
↓ open down ↓ |
53 lines elided |
↑ open up ↑ |
72 72 #if defined ACPI_DBG_TRACK_ALLOCATIONS || defined ACPI_USE_LOCAL_CACHE
73 73 static void
74 74 AcpiDbListInfo (
75 75 ACPI_MEMORY_LIST *List);
76 76 #endif
77 77
78 78
79 79 /*
80 80 * Statistics subcommands
81 81 */
82 -static ARGUMENT_INFO AcpiDbStatTypes [] =
82 +static ACPI_DB_ARGUMENT_INFO AcpiDbStatTypes [] =
83 83 {
84 84 {"ALLOCATIONS"},
85 85 {"OBJECTS"},
86 86 {"MEMORY"},
87 87 {"MISC"},
88 88 {"TABLES"},
89 89 {"SIZES"},
90 90 {"STACK"},
91 91 {NULL} /* Must be null terminated */
92 92 };
93 93
94 94 #define CMD_STAT_ALLOCATIONS 0
95 95 #define CMD_STAT_OBJECTS 1
96 96 #define CMD_STAT_MEMORY 2
97 97 #define CMD_STAT_MISC 3
98 98 #define CMD_STAT_TABLES 4
99 99 #define CMD_STAT_SIZES 5
100 100 #define CMD_STAT_STACK 6
101 101
102 102
103 103 #if defined ACPI_DBG_TRACK_ALLOCATIONS || defined ACPI_USE_LOCAL_CACHE
104 104 /*******************************************************************************
105 105 *
106 106 * FUNCTION: AcpiDbListInfo
107 107 *
108 108 * PARAMETERS: List - Memory list/cache to be displayed
109 109 *
110 110 * RETURN: None
111 111 *
112 112 * DESCRIPTION: Display information about the input memory list or cache.
113 113 *
114 114 ******************************************************************************/
115 115
116 116 static void
117 117 AcpiDbListInfo (
118 118 ACPI_MEMORY_LIST *List)
119 119 {
120 120 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
121 121 UINT32 Outstanding;
122 122 #endif
123 123
124 124 AcpiOsPrintf ("\n%s\n", List->ListName);
125 125
126 126 /* MaxDepth > 0 indicates a cache object */
127 127
128 128 if (List->MaxDepth > 0)
129 129 {
130 130 AcpiOsPrintf (
131 131 " Cache: [Depth MaxD Avail Size] %8.2X %8.2X %8.2X %8.2X\n",
132 132 List->CurrentDepth,
133 133 List->MaxDepth,
134 134 List->MaxDepth - List->CurrentDepth,
135 135 (List->CurrentDepth * List->ObjectSize));
136 136 }
137 137
138 138 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
139 139 if (List->MaxDepth > 0)
140 140 {
141 141 AcpiOsPrintf (
142 142 " Cache: [Requests Hits Misses ObjSize] %8.2X %8.2X %8.2X %8.2X\n",
143 143 List->Requests,
144 144 List->Hits,
145 145 List->Requests - List->Hits,
146 146 List->ObjectSize);
147 147 }
148 148
149 149 Outstanding = AcpiDbGetCacheInfo (List);
150 150
151 151 if (List->ObjectSize)
152 152 {
153 153 AcpiOsPrintf (
154 154 " Mem: [Alloc Free Max CurSize Outstanding] %8.2X %8.2X %8.2X %8.2X %8.2X\n",
155 155 List->TotalAllocated,
156 156 List->TotalFreed,
157 157 List->MaxOccupied,
158 158 Outstanding * List->ObjectSize,
159 159 Outstanding);
160 160 }
161 161 else
162 162 {
163 163 AcpiOsPrintf (
164 164 " Mem: [Alloc Free Max CurSize Outstanding Total] %8.2X %8.2X %8.2X %8.2X %8.2X %8.2X\n",
165 165 List->TotalAllocated,
166 166 List->TotalFreed,
167 167 List->MaxOccupied,
168 168 List->CurrentTotalSize,
169 169 Outstanding,
170 170 List->TotalSize);
171 171 }
172 172 #endif
173 173 }
174 174 #endif
175 175
176 176
177 177 /*******************************************************************************
178 178 *
179 179 * FUNCTION: AcpiDbEnumerateObject
180 180 *
181 181 * PARAMETERS: ObjDesc - Object to be counted
182 182 *
183 183 * RETURN: None
184 184 *
185 185 * DESCRIPTION: Add this object to the global counts, by object type.
186 186 * Limited recursion handles subobjects and packages, and this
187 187 * is probably acceptable within the AML debugger only.
188 188 *
189 189 ******************************************************************************/
190 190
191 191 static void
192 192 AcpiDbEnumerateObject (
193 193 ACPI_OPERAND_OBJECT *ObjDesc)
194 194 {
195 195 UINT32 i;
196 196
197 197
198 198 if (!ObjDesc)
199 199 {
200 200 return;
201 201 }
202 202
203 203 /* Enumerate this object first */
204 204
205 205 AcpiGbl_NumObjects++;
206 206
207 207 if (ObjDesc->Common.Type > ACPI_TYPE_NS_NODE_MAX)
208 208 {
209 209 AcpiGbl_ObjTypeCountMisc++;
210 210 }
211 211 else
212 212 {
213 213 AcpiGbl_ObjTypeCount [ObjDesc->Common.Type]++;
214 214 }
215 215
216 216 /* Count the sub-objects */
217 217
218 218 switch (ObjDesc->Common.Type)
219 219 {
|
↓ open down ↓ |
127 lines elided |
↑ open up ↑ |
220 220 case ACPI_TYPE_PACKAGE:
221 221
222 222 for (i = 0; i < ObjDesc->Package.Count; i++)
223 223 {
224 224 AcpiDbEnumerateObject (ObjDesc->Package.Elements[i]);
225 225 }
226 226 break;
227 227
228 228 case ACPI_TYPE_DEVICE:
229 229
230 - AcpiDbEnumerateObject (ObjDesc->Device.SystemNotify);
231 - AcpiDbEnumerateObject (ObjDesc->Device.DeviceNotify);
230 + AcpiDbEnumerateObject (ObjDesc->Device.NotifyList[0]);
231 + AcpiDbEnumerateObject (ObjDesc->Device.NotifyList[1]);
232 232 AcpiDbEnumerateObject (ObjDesc->Device.Handler);
233 233 break;
234 234
235 235 case ACPI_TYPE_BUFFER_FIELD:
236 236
237 237 if (AcpiNsGetSecondaryObject (ObjDesc))
238 238 {
239 239 AcpiGbl_ObjTypeCount [ACPI_TYPE_BUFFER_FIELD]++;
240 240 }
241 241 break;
242 242
243 243 case ACPI_TYPE_REGION:
244 244
245 245 AcpiGbl_ObjTypeCount [ACPI_TYPE_LOCAL_REGION_FIELD ]++;
246 246 AcpiDbEnumerateObject (ObjDesc->Region.Handler);
247 247 break;
248 248
249 249 case ACPI_TYPE_POWER:
250 250
251 - AcpiDbEnumerateObject (ObjDesc->PowerResource.SystemNotify);
252 - AcpiDbEnumerateObject (ObjDesc->PowerResource.DeviceNotify);
251 + AcpiDbEnumerateObject (ObjDesc->PowerResource.NotifyList[0]);
252 + AcpiDbEnumerateObject (ObjDesc->PowerResource.NotifyList[1]);
253 253 break;
254 254
255 255 case ACPI_TYPE_PROCESSOR:
256 256
257 - AcpiDbEnumerateObject (ObjDesc->Processor.SystemNotify);
258 - AcpiDbEnumerateObject (ObjDesc->Processor.DeviceNotify);
257 + AcpiDbEnumerateObject (ObjDesc->Processor.NotifyList[0]);
258 + AcpiDbEnumerateObject (ObjDesc->Processor.NotifyList[1]);
259 259 AcpiDbEnumerateObject (ObjDesc->Processor.Handler);
260 260 break;
261 261
262 262 case ACPI_TYPE_THERMAL:
263 263
264 - AcpiDbEnumerateObject (ObjDesc->ThermalZone.SystemNotify);
265 - AcpiDbEnumerateObject (ObjDesc->ThermalZone.DeviceNotify);
264 + AcpiDbEnumerateObject (ObjDesc->ThermalZone.NotifyList[0]);
265 + AcpiDbEnumerateObject (ObjDesc->ThermalZone.NotifyList[1]);
266 266 AcpiDbEnumerateObject (ObjDesc->ThermalZone.Handler);
267 267 break;
268 268
269 269 default:
270 +
270 271 break;
271 272 }
272 273 }
273 274
274 275
275 276 /*******************************************************************************
276 277 *
277 278 * FUNCTION: AcpiDbClassifyOneObject
278 279 *
279 280 * PARAMETERS: Callback for WalkNamespace
280 281 *
281 282 * RETURN: Status
282 283 *
283 284 * DESCRIPTION: Enumerate both the object descriptor (including subobjects) and
284 285 * the parent namespace node.
285 286 *
286 287 ******************************************************************************/
287 288
288 289 static ACPI_STATUS
289 290 AcpiDbClassifyOneObject (
290 291 ACPI_HANDLE ObjHandle,
291 292 UINT32 NestingLevel,
292 293 void *Context,
293 294 void **ReturnValue)
294 295 {
295 296 ACPI_NAMESPACE_NODE *Node;
296 297 ACPI_OPERAND_OBJECT *ObjDesc;
297 298 UINT32 Type;
298 299
299 300
300 301 AcpiGbl_NumNodes++;
301 302
302 303 Node = (ACPI_NAMESPACE_NODE *) ObjHandle;
303 304 ObjDesc = AcpiNsGetAttachedObject (Node);
304 305
305 306 AcpiDbEnumerateObject (ObjDesc);
306 307
|
↓ open down ↓ |
27 lines elided |
↑ open up ↑ |
307 308 Type = Node->Type;
308 309 if (Type > ACPI_TYPE_NS_NODE_MAX)
309 310 {
310 311 AcpiGbl_NodeTypeCountMisc++;
311 312 }
312 313 else
313 314 {
314 315 AcpiGbl_NodeTypeCount [Type]++;
315 316 }
316 317
317 - return AE_OK;
318 + return (AE_OK);
318 319
319 320
320 321 #ifdef ACPI_FUTURE_IMPLEMENTATION
321 322
322 323 /* TBD: These need to be counted during the initial parsing phase */
323 324
324 325 if (AcpiPsIsNamedOp (Op->Opcode))
325 326 {
326 327 NumNodes++;
327 328 }
328 329
329 330 if (IsMethod)
330 331 {
331 332 NumMethodElements++;
332 333 }
333 334
334 335 NumGrammarElements++;
335 336 Op = AcpiPsGetDepthNext (Root, Op);
336 337
337 338 SizeOfParseTree = (NumGrammarElements - NumMethodElements) *
338 339 (UINT32) sizeof (ACPI_PARSE_OBJECT);
339 340 SizeOfMethodTrees = NumMethodElements * (UINT32) sizeof (ACPI_PARSE_OBJECT);
340 341 SizeOfNodeEntries = NumNodes * (UINT32) sizeof (ACPI_NAMESPACE_NODE);
341 342 SizeOfAcpiObjects = NumNodes * (UINT32) sizeof (ACPI_OPERAND_OBJECT);
342 343 #endif
343 344 }
344 345
345 346
346 347 /*******************************************************************************
347 348 *
348 349 * FUNCTION: AcpiDbCountNamespaceObjects
349 350 *
350 351 * PARAMETERS: None
351 352 *
352 353 * RETURN: None
353 354 *
354 355 * DESCRIPTION: Count and classify the entire namespace, including all
355 356 * namespace nodes and attached objects.
356 357 *
357 358 ******************************************************************************/
358 359
359 360 static void
360 361 AcpiDbCountNamespaceObjects (
361 362 void)
362 363 {
363 364 UINT32 i;
364 365
365 366
366 367 AcpiGbl_NumNodes = 0;
367 368 AcpiGbl_NumObjects = 0;
368 369
369 370 AcpiGbl_ObjTypeCountMisc = 0;
370 371 for (i = 0; i < (ACPI_TYPE_NS_NODE_MAX -1); i++)
371 372 {
372 373 AcpiGbl_ObjTypeCount [i] = 0;
373 374 AcpiGbl_NodeTypeCount [i] = 0;
374 375 }
375 376
376 377 (void) AcpiNsWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
377 378 ACPI_UINT32_MAX, FALSE, AcpiDbClassifyOneObject, NULL, NULL, NULL);
378 379 }
379 380
380 381
381 382 /*******************************************************************************
382 383 *
383 384 * FUNCTION: AcpiDbDisplayStatistics
384 385 *
385 386 * PARAMETERS: TypeArg - Subcommand
386 387 *
387 388 * RETURN: Status
388 389 *
389 390 * DESCRIPTION: Display various statistics
390 391 *
|
↓ open down ↓ |
63 lines elided |
↑ open up ↑ |
391 392 ******************************************************************************/
392 393
393 394 ACPI_STATUS
394 395 AcpiDbDisplayStatistics (
395 396 char *TypeArg)
396 397 {
397 398 UINT32 i;
398 399 UINT32 Temp;
399 400
400 401
401 - if (!TypeArg)
402 - {
403 - AcpiOsPrintf ("The following subcommands are available:\n ALLOCATIONS, OBJECTS, MEMORY, MISC, SIZES, TABLES\n");
404 - return (AE_OK);
405 - }
406 -
407 402 AcpiUtStrupr (TypeArg);
408 403 Temp = AcpiDbMatchArgument (TypeArg, AcpiDbStatTypes);
409 - if (Temp == (UINT32) -1)
404 + if (Temp == ACPI_TYPE_NOT_FOUND)
410 405 {
411 406 AcpiOsPrintf ("Invalid or unsupported argument\n");
412 407 return (AE_OK);
413 408 }
414 409
415 410
416 411 switch (Temp)
417 412 {
418 413 case CMD_STAT_ALLOCATIONS:
419 414
420 415 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
421 416 AcpiUtDumpAllocationInfo ();
422 417 #endif
423 418 break;
424 419
425 420 case CMD_STAT_TABLES:
426 421
427 422 AcpiOsPrintf ("ACPI Table Information (not implemented):\n\n");
428 423 break;
429 424
430 425 case CMD_STAT_OBJECTS:
431 426
432 427 AcpiDbCountNamespaceObjects ();
433 428
434 429 AcpiOsPrintf ("\nObjects defined in the current namespace:\n\n");
435 430
436 431 AcpiOsPrintf ("%16.16s %10.10s %10.10s\n",
437 432 "ACPI_TYPE", "NODES", "OBJECTS");
438 433
439 434 for (i = 0; i < ACPI_TYPE_NS_NODE_MAX; i++)
440 435 {
441 436 AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", AcpiUtGetTypeName (i),
442 437 AcpiGbl_NodeTypeCount [i], AcpiGbl_ObjTypeCount [i]);
443 438 }
444 439 AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "Misc/Unknown",
445 440 AcpiGbl_NodeTypeCountMisc, AcpiGbl_ObjTypeCountMisc);
446 441
447 442 AcpiOsPrintf ("%16.16s % 10ld% 10ld\n", "TOTALS:",
448 443 AcpiGbl_NumNodes, AcpiGbl_NumObjects);
449 444 break;
450 445
451 446 case CMD_STAT_MEMORY:
452 447
453 448 #ifdef ACPI_DBG_TRACK_ALLOCATIONS
454 449 AcpiOsPrintf ("\n----Object Statistics (all in hex)---------\n");
455 450
456 451 AcpiDbListInfo (AcpiGbl_GlobalList);
457 452 AcpiDbListInfo (AcpiGbl_NsNodeList);
458 453 #endif
459 454
460 455 #ifdef ACPI_USE_LOCAL_CACHE
461 456 AcpiOsPrintf ("\n----Cache Statistics (all in hex)---------\n");
462 457 AcpiDbListInfo (AcpiGbl_OperandCache);
463 458 AcpiDbListInfo (AcpiGbl_PsNodeCache);
464 459 AcpiDbListInfo (AcpiGbl_PsNodeExtCache);
465 460 AcpiDbListInfo (AcpiGbl_StateCache);
466 461 #endif
467 462
468 463 break;
469 464
470 465 case CMD_STAT_MISC:
471 466
472 467 AcpiOsPrintf ("\nMiscellaneous Statistics:\n\n");
473 468 AcpiOsPrintf ("Calls to AcpiPsFind:.. ........% 7ld\n",
474 469 AcpiGbl_PsFindCount);
475 470 AcpiOsPrintf ("Calls to AcpiNsLookup:..........% 7ld\n",
476 471 AcpiGbl_NsLookupCount);
477 472
|
↓ open down ↓ |
58 lines elided |
↑ open up ↑ |
478 473 AcpiOsPrintf ("\n");
479 474
480 475 AcpiOsPrintf ("Mutex usage:\n\n");
481 476 for (i = 0; i < ACPI_NUM_MUTEX; i++)
482 477 {
483 478 AcpiOsPrintf ("%-28s: % 7ld\n",
484 479 AcpiUtGetMutexName (i), AcpiGbl_MutexInfo[i].UseCount);
485 480 }
486 481 break;
487 482
488 -
489 483 case CMD_STAT_SIZES:
490 484
491 485 AcpiOsPrintf ("\nInternal object sizes:\n\n");
492 486
493 487 AcpiOsPrintf ("Common %3d\n", sizeof (ACPI_OBJECT_COMMON));
494 488 AcpiOsPrintf ("Number %3d\n", sizeof (ACPI_OBJECT_INTEGER));
495 489 AcpiOsPrintf ("String %3d\n", sizeof (ACPI_OBJECT_STRING));
496 490 AcpiOsPrintf ("Buffer %3d\n", sizeof (ACPI_OBJECT_BUFFER));
497 491 AcpiOsPrintf ("Package %3d\n", sizeof (ACPI_OBJECT_PACKAGE));
498 492 AcpiOsPrintf ("BufferField %3d\n", sizeof (ACPI_OBJECT_BUFFER_FIELD));
499 493 AcpiOsPrintf ("Device %3d\n", sizeof (ACPI_OBJECT_DEVICE));
500 494 AcpiOsPrintf ("Event %3d\n", sizeof (ACPI_OBJECT_EVENT));
501 495 AcpiOsPrintf ("Method %3d\n", sizeof (ACPI_OBJECT_METHOD));
502 496 AcpiOsPrintf ("Mutex %3d\n", sizeof (ACPI_OBJECT_MUTEX));
503 497 AcpiOsPrintf ("Region %3d\n", sizeof (ACPI_OBJECT_REGION));
504 498 AcpiOsPrintf ("PowerResource %3d\n", sizeof (ACPI_OBJECT_POWER_RESOURCE));
505 499 AcpiOsPrintf ("Processor %3d\n", sizeof (ACPI_OBJECT_PROCESSOR));
506 500 AcpiOsPrintf ("ThermalZone %3d\n", sizeof (ACPI_OBJECT_THERMAL_ZONE));
507 501 AcpiOsPrintf ("RegionField %3d\n", sizeof (ACPI_OBJECT_REGION_FIELD));
508 502 AcpiOsPrintf ("BankField %3d\n", sizeof (ACPI_OBJECT_BANK_FIELD));
509 503 AcpiOsPrintf ("IndexField %3d\n", sizeof (ACPI_OBJECT_INDEX_FIELD));
510 504 AcpiOsPrintf ("Reference %3d\n", sizeof (ACPI_OBJECT_REFERENCE));
511 505 AcpiOsPrintf ("Notify %3d\n", sizeof (ACPI_OBJECT_NOTIFY_HANDLER));
512 506 AcpiOsPrintf ("AddressSpace %3d\n", sizeof (ACPI_OBJECT_ADDR_HANDLER));
513 507 AcpiOsPrintf ("Extra %3d\n", sizeof (ACPI_OBJECT_EXTRA));
514 508 AcpiOsPrintf ("Data %3d\n", sizeof (ACPI_OBJECT_DATA));
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
515 509
516 510 AcpiOsPrintf ("\n");
517 511
518 512 AcpiOsPrintf ("ParseObject %3d\n", sizeof (ACPI_PARSE_OBJ_COMMON));
519 513 AcpiOsPrintf ("ParseObjectNamed %3d\n", sizeof (ACPI_PARSE_OBJ_NAMED));
520 514 AcpiOsPrintf ("ParseObjectAsl %3d\n", sizeof (ACPI_PARSE_OBJ_ASL));
521 515 AcpiOsPrintf ("OperandObject %3d\n", sizeof (ACPI_OPERAND_OBJECT));
522 516 AcpiOsPrintf ("NamespaceNode %3d\n", sizeof (ACPI_NAMESPACE_NODE));
523 517 AcpiOsPrintf ("AcpiObject %3d\n", sizeof (ACPI_OBJECT));
524 518
519 + AcpiOsPrintf ("\n");
520 +
521 + AcpiOsPrintf ("Generic State %3d\n", sizeof (ACPI_GENERIC_STATE));
522 + AcpiOsPrintf ("Common State %3d\n", sizeof (ACPI_COMMON_STATE));
523 + AcpiOsPrintf ("Control State %3d\n", sizeof (ACPI_CONTROL_STATE));
524 + AcpiOsPrintf ("Update State %3d\n", sizeof (ACPI_UPDATE_STATE));
525 + AcpiOsPrintf ("Scope State %3d\n", sizeof (ACPI_SCOPE_STATE));
526 + AcpiOsPrintf ("Parse Scope %3d\n", sizeof (ACPI_PSCOPE_STATE));
527 + AcpiOsPrintf ("Package State %3d\n", sizeof (ACPI_PKG_STATE));
528 + AcpiOsPrintf ("Thread State %3d\n", sizeof (ACPI_THREAD_STATE));
529 + AcpiOsPrintf ("Result Values %3d\n", sizeof (ACPI_RESULT_VALUES));
530 + AcpiOsPrintf ("Notify Info %3d\n", sizeof (ACPI_NOTIFY_INFO));
525 531 break;
526 532
527 -
528 533 case CMD_STAT_STACK:
529 534 #if defined(ACPI_DEBUG_OUTPUT)
530 535
531 536 Temp = (UINT32) ACPI_PTR_DIFF (AcpiGbl_EntryStackPointer, AcpiGbl_LowestStackPointer);
532 537
533 538 AcpiOsPrintf ("\nSubsystem Stack Usage:\n\n");
534 539 AcpiOsPrintf ("Entry Stack Pointer %p\n", AcpiGbl_EntryStackPointer);
535 540 AcpiOsPrintf ("Lowest Stack Pointer %p\n", AcpiGbl_LowestStackPointer);
536 541 AcpiOsPrintf ("Stack Use %X (%u)\n", Temp, Temp);
537 542 AcpiOsPrintf ("Deepest Procedure Nesting %u\n", AcpiGbl_DeepestNesting);
538 543 #endif
539 544 break;
540 545
541 546 default:
547 +
542 548 break;
543 549 }
544 550
545 551 AcpiOsPrintf ("\n");
546 552 return (AE_OK);
547 553 }
548 554
549 555 #endif /* ACPI_DEBUGGER */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX