usr/src/cmd/acpi/common/utdebug.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utdebug - Debug print/trace routines
   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 #define EXPORT_ACPI_INTERFACES
  45
  46 #include "acpi.h"
  47 #include "accommon.h"
  48 #include "acinterp.h"
  49
  50 #define _COMPONENT          ACPI_UTILITIES
  51         ACPI_MODULE_NAME    ("utdebug")
  52
  53
  54 #ifdef ACPI_DEBUG_OUTPUT
  55
  56 static ACPI_THREAD_ID       AcpiGbl_PreviousThreadId = (ACPI_THREAD_ID) 0xFFFFFFFF;
  57 static const char           *AcpiGbl_FunctionEntryPrefix = "----Entry";
  58 static const char           *AcpiGbl_FunctionExitPrefix  = "----Exit-";
  59
  60
  61 /*******************************************************************************
  62  *
  63  * FUNCTION:    AcpiUtInitStackPtrTrace
  64  *
  65  * PARAMETERS:  None
  66  *
  67  * RETURN:      None
  68  *
  69  * DESCRIPTION: Save the current CPU stack pointer at subsystem startup
  70  *
  71  ******************************************************************************/
  72
  73 void
  74 AcpiUtInitStackPtrTrace (
  75     void)
  76 {
  77     ACPI_SIZE               CurrentSp;
  78
  79
  80     AcpiGbl_EntryStackPointer = &CurrentSp;
  81 }
  82
  83
  84 /*******************************************************************************
  85  *
  86  * FUNCTION:    AcpiUtTrackStackPtr
  87  *
  88  * PARAMETERS:  None
  89  *
  90  * RETURN:      None
  91  *
  92  * DESCRIPTION: Save the current CPU stack pointer
  93  *
  94  ******************************************************************************/
  95
  96 void
  97 AcpiUtTrackStackPtr (
  98     void)
  99 {
 100     ACPI_SIZE               CurrentSp;
 101
 102
 103     if (&CurrentSp < AcpiGbl_LowestStackPointer)
 104     {
 105         AcpiGbl_LowestStackPointer = &CurrentSp;
 106     }
 107
 108     if (AcpiGbl_NestingLevel > AcpiGbl_DeepestNesting)
 109     {
 110         AcpiGbl_DeepestNesting = AcpiGbl_NestingLevel;
 111     }
 112 }
 113
 114
 115 /*******************************************************************************
 116  *
 117  * FUNCTION:    AcpiUtTrimFunctionName
 118  *
 119  * PARAMETERS:  FunctionName        - Ascii string containing a procedure name
 120  *
 121  * RETURN:      Updated pointer to the function name
 122  *
 123  * DESCRIPTION: Remove the "Acpi" prefix from the function name, if present.
 124  *              This allows compiler macros such as __FUNCTION__ to be used
 125  *              with no change to the debug output.
 126  *
 127  ******************************************************************************/
 128
 129 static const char *
 130 AcpiUtTrimFunctionName (
 131     const char              *FunctionName)
 132 {
 133
 134     /* All Function names are longer than 4 chars, check is safe */
 135
 136     if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_MIXED)
 137     {
 138         /* This is the case where the original source has not been modified */
 139
 140         return (FunctionName + 4);
 141     }
 142
 143     if (*(ACPI_CAST_PTR (UINT32, FunctionName)) == ACPI_PREFIX_LOWER)
 144     {
 145         /* This is the case where the source has been 'linuxized' */
 146
 147         return (FunctionName + 5);
 148     }
 149
 150     return (FunctionName);
 151 }
 152
 153
 154 /*******************************************************************************
 155  *
 156  * FUNCTION:    AcpiDebugPrint
 157  *
 158  * PARAMETERS:  RequestedDebugLevel - Requested debug print level
 159  *              LineNumber          - Caller's line number (for error output)
 160  *              FunctionName        - Caller's procedure name
 161  *              ModuleName          - Caller's module name
 162  *              ComponentId         - Caller's component ID
 163  *              Format              - Printf format field
 164  *              ...                 - Optional printf arguments
 165  *
 166  * RETURN:      None
 167  *
 168  * DESCRIPTION: Print error message with prefix consisting of the module name,
 169  *              line number, and component ID.
 170  *
 171  ******************************************************************************/
 172
 173 void  ACPI_INTERNAL_VAR_XFACE
 174 AcpiDebugPrint (
 175     UINT32                  RequestedDebugLevel,
 176     UINT32                  LineNumber,
 177     const char              *FunctionName,
 178     const char              *ModuleName,
 179     UINT32                  ComponentId,
 180     const char              *Format,
 181     ...)
 182 {
 183     ACPI_THREAD_ID          ThreadId;
 184     va_list                 args;
 185
 186
 187     /* Check if debug output enabled */
 188
 189     if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
 190     {
 191         return;
 192     }
 193
 194     /*
 195      * Thread tracking and context switch notification
 196      */
 197     ThreadId = AcpiOsGetThreadId ();
 198     if (ThreadId != AcpiGbl_PreviousThreadId)
 199     {
 200         if (ACPI_LV_THREADS & AcpiDbgLevel)
 201         {
 202             AcpiOsPrintf (
 203                 "\n**** Context Switch from TID %u to TID %u ****\n\n",
 204                 (UINT32) AcpiGbl_PreviousThreadId, (UINT32) ThreadId);
 205         }
 206
 207         AcpiGbl_PreviousThreadId = ThreadId;
 208         AcpiGbl_NestingLevel = 0;
 209     }
 210
 211     /*
 212      * Display the module name, current line number, thread ID (if requested),
 213      * current procedure nesting level, and the current procedure name
 214      */
 215     AcpiOsPrintf ("%9s-%04ld ", ModuleName, LineNumber);
 216
 217 #ifdef ACPI_APPLICATION
 218     /*
 219      * For AcpiExec/iASL only, emit the thread ID and nesting level.
 220      * Note: nesting level is really only useful during a single-thread
 221      * execution. Otherwise, multiple threads will keep resetting the
 222      * level.
 223      */
 224     if (ACPI_LV_THREADS & AcpiDbgLevel)
 225     {
 226         AcpiOsPrintf ("[%u] ", (UINT32) ThreadId);
 227     }
 228
 229     AcpiOsPrintf ("[%02ld] ", AcpiGbl_NestingLevel);
 230 #endif
 231
 232     AcpiOsPrintf ("%-22.22s: ", AcpiUtTrimFunctionName (FunctionName));
 233
 234     va_start (args, Format);
 235     AcpiOsVprintf (Format, args);
 236     va_end (args);
 237 }
 238
 239 ACPI_EXPORT_SYMBOL (AcpiDebugPrint)
 240
 241
 242 /*******************************************************************************
 243  *
 244  * FUNCTION:    AcpiDebugPrintRaw
 245  *
 246  * PARAMETERS:  RequestedDebugLevel - Requested debug print level
 247  *              LineNumber          - Caller's line number
 248  *              FunctionName        - Caller's procedure name
 249  *              ModuleName          - Caller's module name
 250  *              ComponentId         - Caller's component ID
 251  *              Format              - Printf format field
 252  *              ...                 - Optional printf arguments
 253  *
 254  * RETURN:      None
 255  *
 256  * DESCRIPTION: Print message with no headers. Has same interface as
 257  *              DebugPrint so that the same macros can be used.
 258  *
 259  ******************************************************************************/
 260
 261 void  ACPI_INTERNAL_VAR_XFACE
 262 AcpiDebugPrintRaw (
 263     UINT32                  RequestedDebugLevel,
 264     UINT32                  LineNumber,
 265     const char              *FunctionName,
 266     const char              *ModuleName,
 267     UINT32                  ComponentId,
 268     const char              *Format,
 269     ...)
 270 {
 271     va_list                 args;
 272
 273
 274     /* Check if debug output enabled */
 275
 276     if (!ACPI_IS_DEBUG_ENABLED (RequestedDebugLevel, ComponentId))
 277     {
 278         return;
 279     }
 280
 281     va_start (args, Format);
 282     AcpiOsVprintf (Format, args);
 283     va_end (args);
 284 }
 285
 286 ACPI_EXPORT_SYMBOL (AcpiDebugPrintRaw)
 287
 288
 289 /*******************************************************************************
 290  *
 291  * FUNCTION:    AcpiUtTrace
 292  *
 293  * PARAMETERS:  LineNumber          - Caller's line number
 294  *              FunctionName        - Caller's procedure name
 295  *              ModuleName          - Caller's module name
 296  *              ComponentId         - Caller's component ID
 297  *
 298  * RETURN:      None
 299  *
 300  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 301  *              set in DebugLevel
 302  *
 303  ******************************************************************************/
 304
 305 void
 306 AcpiUtTrace (
 307     UINT32                  LineNumber,
 308     const char              *FunctionName,
 309     const char              *ModuleName,
 310     UINT32                  ComponentId)
 311 {
 312
 313     AcpiGbl_NestingLevel++;
 314     AcpiUtTrackStackPtr ();
 315
 316     /* Check if enabled up-front for performance */
 317
 318     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 319     {
 320         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 321             LineNumber, FunctionName, ModuleName, ComponentId,
 322             "%s\n", AcpiGbl_FunctionEntryPrefix);
 323     }
 324 }
 325
 326 ACPI_EXPORT_SYMBOL (AcpiUtTrace)
 327
 328
 329 /*******************************************************************************
 330  *
 331  * FUNCTION:    AcpiUtTracePtr
 332  *
 333  * PARAMETERS:  LineNumber          - Caller's line number
 334  *              FunctionName        - Caller's procedure name
 335  *              ModuleName          - Caller's module name
 336  *              ComponentId         - Caller's component ID
 337  *              Pointer             - Pointer to display
 338  *
 339  * RETURN:      None
 340  *
 341  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 342  *              set in DebugLevel
 343  *
 344  ******************************************************************************/
 345
 346 void
 347 AcpiUtTracePtr (
 348     UINT32                  LineNumber,
 349     const char              *FunctionName,
 350     const char              *ModuleName,
 351     UINT32                  ComponentId,
 352     const void              *Pointer)
 353 {
 354
 355     AcpiGbl_NestingLevel++;
 356     AcpiUtTrackStackPtr ();
 357
 358     /* Check if enabled up-front for performance */
 359
 360     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 361     {
 362         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 363             LineNumber, FunctionName, ModuleName, ComponentId,
 364             "%s %p\n", AcpiGbl_FunctionEntryPrefix, Pointer);
 365     }
 366 }
 367
 368
 369 /*******************************************************************************
 370  *
 371  * FUNCTION:    AcpiUtTraceStr
 372  *
 373  * PARAMETERS:  LineNumber          - Caller's line number
 374  *              FunctionName        - Caller's procedure name
 375  *              ModuleName          - Caller's module name
 376  *              ComponentId         - Caller's component ID
 377  *              String              - Additional string to display
 378  *
 379  * RETURN:      None
 380  *
 381  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 382  *              set in DebugLevel
 383  *
 384  ******************************************************************************/
 385
 386 void
 387 AcpiUtTraceStr (
 388     UINT32                  LineNumber,
 389     const char              *FunctionName,
 390     const char              *ModuleName,
 391     UINT32                  ComponentId,
 392     const char              *String)
 393 {
 394
 395     AcpiGbl_NestingLevel++;
 396     AcpiUtTrackStackPtr ();
 397
 398     /* Check if enabled up-front for performance */
 399
 400     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 401     {
 402         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 403             LineNumber, FunctionName, ModuleName, ComponentId,
 404             "%s %s\n", AcpiGbl_FunctionEntryPrefix, String);
 405     }
 406 }
 407
 408
 409 /*******************************************************************************
 410  *
 411  * FUNCTION:    AcpiUtTraceU32
 412  *
 413  * PARAMETERS:  LineNumber          - Caller's line number
 414  *              FunctionName        - Caller's procedure name
 415  *              ModuleName          - Caller's module name
 416  *              ComponentId         - Caller's component ID
 417  *              Integer             - Integer to display
 418  *
 419  * RETURN:      None
 420  *
 421  * DESCRIPTION: Function entry trace. Prints only if TRACE_FUNCTIONS bit is
 422  *              set in DebugLevel
 423  *
 424  ******************************************************************************/
 425
 426 void
 427 AcpiUtTraceU32 (
 428     UINT32                  LineNumber,
 429     const char              *FunctionName,
 430     const char              *ModuleName,
 431     UINT32                  ComponentId,
 432     UINT32                  Integer)
 433 {
 434
 435     AcpiGbl_NestingLevel++;
 436     AcpiUtTrackStackPtr ();
 437
 438     /* Check if enabled up-front for performance */
 439
 440     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 441     {
 442         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 443             LineNumber, FunctionName, ModuleName, ComponentId,
 444             "%s %08X\n", AcpiGbl_FunctionEntryPrefix, Integer);
 445     }
 446 }
 447
 448
 449 /*******************************************************************************
 450  *
 451  * FUNCTION:    AcpiUtExit
 452  *
 453  * PARAMETERS:  LineNumber          - Caller's line number
 454  *              FunctionName        - Caller's procedure name
 455  *              ModuleName          - Caller's module name
 456  *              ComponentId         - Caller's component ID
 457  *
 458  * RETURN:      None
 459  *
 460  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 461  *              set in DebugLevel
 462  *
 463  ******************************************************************************/
 464
 465 void
 466 AcpiUtExit (
 467     UINT32                  LineNumber,
 468     const char              *FunctionName,
 469     const char              *ModuleName,
 470     UINT32                  ComponentId)
 471 {
 472
 473     /* Check if enabled up-front for performance */
 474
 475     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 476     {
 477         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 478             LineNumber, FunctionName, ModuleName, ComponentId,
 479             "%s\n", AcpiGbl_FunctionExitPrefix);
 480     }
 481
 482     if (AcpiGbl_NestingLevel)
 483     {
 484         AcpiGbl_NestingLevel--;
 485     }
 486 }
 487
 488 ACPI_EXPORT_SYMBOL (AcpiUtExit)
 489
 490
 491 /*******************************************************************************
 492  *
 493  * FUNCTION:    AcpiUtStatusExit
 494  *
 495  * PARAMETERS:  LineNumber          - Caller's line number
 496  *              FunctionName        - Caller's procedure name
 497  *              ModuleName          - Caller's module name
 498  *              ComponentId         - Caller's component ID
 499  *              Status              - Exit status code
 500  *
 501  * RETURN:      None
 502  *
 503  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 504  *              set in DebugLevel. Prints exit status also.
 505  *
 506  ******************************************************************************/
 507
 508 void
 509 AcpiUtStatusExit (
 510     UINT32                  LineNumber,
 511     const char              *FunctionName,
 512     const char              *ModuleName,
 513     UINT32                  ComponentId,
 514     ACPI_STATUS             Status)
 515 {
 516
 517     /* Check if enabled up-front for performance */
 518
 519     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 520     {
 521         if (ACPI_SUCCESS (Status))
 522         {
 523             AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 524                 LineNumber, FunctionName, ModuleName, ComponentId,
 525                 "%s %s\n", AcpiGbl_FunctionExitPrefix,
 526                 AcpiFormatException (Status));
 527         }
 528         else
 529         {
 530             AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 531                 LineNumber, FunctionName, ModuleName, ComponentId,
 532                 "%s ****Exception****: %s\n", AcpiGbl_FunctionExitPrefix,
 533                 AcpiFormatException (Status));
 534         }
 535     }
 536
 537     if (AcpiGbl_NestingLevel)
 538     {
 539         AcpiGbl_NestingLevel--;
 540     }
 541 }
 542
 543 ACPI_EXPORT_SYMBOL (AcpiUtStatusExit)
 544
 545
 546 /*******************************************************************************
 547  *
 548  * FUNCTION:    AcpiUtValueExit
 549  *
 550  * PARAMETERS:  LineNumber          - Caller's line number
 551  *              FunctionName        - Caller's procedure name
 552  *              ModuleName          - Caller's module name
 553  *              ComponentId         - Caller's component ID
 554  *              Value               - Value to be printed with exit msg
 555  *
 556  * RETURN:      None
 557  *
 558  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 559  *              set in DebugLevel. Prints exit value also.
 560  *
 561  ******************************************************************************/
 562
 563 void
 564 AcpiUtValueExit (
 565     UINT32                  LineNumber,
 566     const char              *FunctionName,
 567     const char              *ModuleName,
 568     UINT32                  ComponentId,
 569     UINT64                  Value)
 570 {
 571
 572     /* Check if enabled up-front for performance */
 573
 574     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 575     {
 576         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 577             LineNumber, FunctionName, ModuleName, ComponentId,
 578             "%s %8.8X%8.8X\n", AcpiGbl_FunctionExitPrefix,
 579             ACPI_FORMAT_UINT64 (Value));
 580     }
 581
 582     if (AcpiGbl_NestingLevel)
 583     {
 584         AcpiGbl_NestingLevel--;
 585     }
 586 }
 587
 588 ACPI_EXPORT_SYMBOL (AcpiUtValueExit)
 589
 590
 591 /*******************************************************************************
 592  *
 593  * FUNCTION:    AcpiUtPtrExit
 594  *
 595  * PARAMETERS:  LineNumber          - Caller's line number
 596  *              FunctionName        - Caller's procedure name
 597  *              ModuleName          - Caller's module name
 598  *              ComponentId         - Caller's component ID
 599  *              Ptr                 - Pointer to display
 600  *
 601  * RETURN:      None
 602  *
 603  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 604  *              set in DebugLevel. Prints exit value also.
 605  *
 606  ******************************************************************************/
 607
 608 void
 609 AcpiUtPtrExit (
 610     UINT32                  LineNumber,
 611     const char              *FunctionName,
 612     const char              *ModuleName,
 613     UINT32                  ComponentId,
 614     UINT8                   *Ptr)
 615 {
 616
 617     /* Check if enabled up-front for performance */
 618
 619     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 620     {
 621         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 622             LineNumber, FunctionName, ModuleName, ComponentId,
 623             "%s %p\n", AcpiGbl_FunctionExitPrefix, Ptr);
 624     }
 625
 626     if (AcpiGbl_NestingLevel)
 627     {
 628         AcpiGbl_NestingLevel--;
 629     }
 630 }
 631
 632
 633 /*******************************************************************************
 634  *
 635  * FUNCTION:    AcpiUtStrExit
 636  *
 637  * PARAMETERS:  LineNumber          - Caller's line number
 638  *              FunctionName        - Caller's procedure name
 639  *              ModuleName          - Caller's module name
 640  *              ComponentId         - Caller's component ID
 641  *              String              - String to display
 642  *
 643  * RETURN:      None
 644  *
 645  * DESCRIPTION: Function exit trace. Prints only if TRACE_FUNCTIONS bit is
 646  *              set in DebugLevel. Prints exit value also.
 647  *
 648  ******************************************************************************/
 649
 650 void
 651 AcpiUtStrExit (
 652     UINT32                  LineNumber,
 653     const char              *FunctionName,
 654     const char              *ModuleName,
 655     UINT32                  ComponentId,
 656     const char              *String)
 657 {
 658
 659     /* Check if enabled up-front for performance */
 660
 661     if (ACPI_IS_DEBUG_ENABLED (ACPI_LV_FUNCTIONS, ComponentId))
 662     {
 663         AcpiDebugPrint (ACPI_LV_FUNCTIONS,
 664             LineNumber, FunctionName, ModuleName, ComponentId,
 665             "%s %s\n", AcpiGbl_FunctionExitPrefix, String);
 666     }
 667
 668     if (AcpiGbl_NestingLevel)
 669     {
 670         AcpiGbl_NestingLevel--;
 671     }
 672 }
 673
 674
 675 /*******************************************************************************
 676  *
 677  * FUNCTION:    AcpiTracePoint
 678  *
 679  * PARAMETERS:  Type                - Trace event type
 680  *              Begin               - TRUE if before execution
 681  *              Aml                 - Executed AML address
 682  *              Pathname            - Object path
 683  *              Pointer             - Pointer to the related object
 684  *
 685  * RETURN:      None
 686  *
 687  * DESCRIPTION: Interpreter execution trace.
 688  *
 689  ******************************************************************************/
 690
 691 void
 692 AcpiTracePoint (
 693     ACPI_TRACE_EVENT_TYPE   Type,
 694     BOOLEAN                 Begin,
 695     UINT8                   *Aml,
 696     char                    *Pathname)
 697 {
 698
 699     ACPI_FUNCTION_ENTRY ();
 700
 701     AcpiExTracePoint (Type, Begin, Aml, Pathname);
 702
 703 #ifdef ACPI_USE_SYSTEM_TRACER
 704     AcpiOsTracePoint (Type, Begin, Aml, Pathname);
 705 #endif
 706 }
 707
 708 ACPI_EXPORT_SYMBOL (AcpiTracePoint)
 709
 710 #endif
 711
 712
 713 #ifdef ACPI_APPLICATION
 714 /*******************************************************************************
 715  *
 716  * FUNCTION:    AcpiLogError
 717  *
 718  * PARAMETERS:  Format              - Printf format field
 719  *              ...                 - Optional printf arguments
 720  *
 721  * RETURN:      None
 722  *
 723  * DESCRIPTION: Print error message to the console, used by applications.
 724  *
 725  ******************************************************************************/
 726
 727 void  ACPI_INTERNAL_VAR_XFACE
 728 AcpiLogError (
 729     const char              *Format,
 730     ...)
 731 {
 732     va_list                 Args;
 733
 734     va_start (Args, Format);
 735     (void) AcpiUtFileVprintf (ACPI_FILE_ERR, Format, Args);
 736     va_end (Args);
 737 }
 738
 739 ACPI_EXPORT_SYMBOL (AcpiLogError)
 740 #endif