Branch data     Line data    Source code

       1                 :             : // SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
       2                 :             : /*
       3                 :             :  * Console Log routines
       4                 :             :  * Wraps libc and console lower level functions
       5                 :             :  * does fancy-schmancy things like timestamps and priorities
       6                 :             :  * Doesn't make waffles.
       7                 :             :  *
       8                 :             :  * Copyright 2013-2018 IBM Corp.
       9                 :             :  */
      10                 :             : 
      11                 :             : #include "skiboot.h"
      12                 :             : #include "unistd.h"
      13                 :             : #include "stdio.h"
      14                 :             : #include "console.h"
      15                 :             : #include "timebase.h"
      16                 :             : #include <debug_descriptor.h>
      17                 :             : 
      18                 :          13 : int vprlog(int log_level, const char *fmt, va_list ap)
      19                 :             : {
      20                 :             :         int count;
      21                 :             :         char buffer[320];
      22                 :          13 :         bool flush_to_drivers = true;
      23                 :          13 :         unsigned long tb = mftb();
      24                 :             : 
      25                 :             :         /* It's safe to return 0 when we "did" something here
      26                 :             :          * as only printf cares about how much we wrote, and
      27                 :             :          * if you change log_level to below PR_PRINTF then you
      28                 :             :          * get everything you deserve.
      29                 :             :          * By default, only PR_DEBUG and higher are stored in memory.
      30                 :             :          * PR_TRACE and PR_INSANE are for those having a bad day.
      31                 :             :          */
      32                 :          13 :         if (log_level > (debug_descriptor.console_log_levels >> 4))
      33                 :           2 :                 return 0;
      34                 :             : 
      35                 :          11 :         count = snprintf(buffer, sizeof(buffer), "[%5lu.%09lu,%d] ",
      36                 :             :                          tb_to_secs(tb), tb_remaining_nsecs(tb), log_level);
      37                 :          11 :         count+= vsnprintf(buffer+count, sizeof(buffer)-count, fmt, ap);
      38                 :             : 
      39                 :          11 :         if (log_level > (debug_descriptor.console_log_levels & 0x0f))
      40                 :           2 :                 flush_to_drivers = false;
      41                 :             : 
      42                 :          11 :         console_write(flush_to_drivers, buffer, count);
      43                 :             : 
      44                 :          11 :         return count;
      45                 :             : }
      46                 :             : 
      47                 :             : /* we don't return anything as what on earth are we going to do
      48                 :             :  * if we actually fail to print a log message? Print a log message about it?
      49                 :             :  * Callers shouldn't care, prlog and friends should do something generically
      50                 :             :  * sane in such crazy situations.
      51                 :             :  */
      52                 :          10 : void _prlog(int log_level, const char* fmt, ...)
      53                 :             : {
      54                 :             :         va_list ap;
      55                 :             : 
      56                 :          10 :         va_start(ap, fmt);
      57                 :          10 :         vprlog(log_level, fmt, ap);
      58                 :          10 :         va_end(ap);
      59                 :          10 : }
      60                 :             : 
      61                 :           2 : int _printf(const char* fmt, ...)
      62                 :             : {
      63                 :             :         int count;
      64                 :             :         va_list ap;
      65                 :             : 
      66                 :           3 :         va_start(ap, fmt);
      67                 :           3 :         count = vprlog(PR_PRINTF, fmt, ap);
      68                 :           3 :         va_end(ap);
      69                 :             : 
      70                 :           3 :         return count;
      71                 :             : }