xnu-4570.20.62.tar.gz

[apple/xnu.git] / osfmk / kern / printf.c

diff --git a/osfmk/kern/printf.c b/osfmk/kern/printf.c
index bf870083e0cc6b3cdbf52d694d20fcee598b69a9..54a3220d3608282e9ad2d28c3f2c57385b44ab20 100644 (file)
--- a/osfmk/kern/printf.c
+++ b/osfmk/kern/printf.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -78,6 +84,8 @@
  *     %u      unsigned conversion
  *     %x      hexadecimal conversion
  *     %X      hexadecimal conversion with capital letters
  *     %u      unsigned conversion
  *     %x      hexadecimal conversion
  *     %X      hexadecimal conversion with capital letters

+ *      %D      hexdump, ptr & separator string ("%6D", ptr, ":") -> XX:XX:XX:XX:XX:XX
+ *              if you use, "%*D" then there's a length, the data ptr and then the separator

  *     %o      octal conversion
  *     %c      character
  *     %s      string
  *     %o      octal conversion
  *     %c      character
  *     %s      string


@@ -86,11 +94,7 @@
  *     %0m.n   zero-padding
  *     %*.*    width and precision taken from arguments
  *
  *     %0m.n   zero-padding
  *     %*.*    width and precision taken from arguments
  *

- *  This version does not implement %f, %e, or %g.  It accepts, but
- *  ignores, an `l' as in %ld, %lo, %lx, and %lu, and therefore will not
- *  work correctly on machines for which sizeof(long) != sizeof(int).
- *  It does not even parse %D, %O, or %U; you should be using %ld, %o and
- *  %lu if you mean long conversion.
+ *  This version does not implement %f, %e, or %g.

  *
  *  As mentioned, this version does not return any reasonable value.
  *
  *
  *  As mentioned, this version does not return any reasonable value.
  *


@@ -98,6 +102,9 @@
  *  long as this notice is incorporated.
  *
  *  Steve Summit 3/25/87
  *  long as this notice is incorporated.
  *
  *  Steve Summit 3/25/87

+ *
+ *  Tweaked for long long support and extended to support the hexdump %D
+ *  specifier by dbg 05/02/02.

  */
 
 /*
  */
 
 /*


@@ -134,20 +141,25 @@
  *     +       print '+' if positive
  *     blank   print ' ' if positive
  *
  *     +       print '+' if positive
  *     blank   print ' ' if positive
  *

- *     z       signed hexadecimal
+ *     z       set length equal to size_t

  *     r       signed, 'radix'
  *     n       unsigned, 'radix'
  *
  *     D,U,O,Z same as corresponding lower-case versions
  *             (compatibility)
  */
  *     r       signed, 'radix'
  *     n       unsigned, 'radix'
  *
  *     D,U,O,Z same as corresponding lower-case versions
  *             (compatibility)
  */

+/*
+ * Added support for print long long (64-bit) integers.
+ * Use %lld, %Ld or %qd to print a 64-bit int.  Other
+ * output bases such as x, X, u, U, o, and O also work.
+ */

 
 

-#include <platforms.h>
+#include <debug.h>
+#include <mach_kdp.h>

 #include <mach/boolean.h>
 #include <mach/boolean.h>

-#include <cpus.h>

 #include <kern/cpu_number.h>
 #include <kern/cpu_number.h>

-#include <kern/lock.h>

 #include <kern/thread.h>
 #include <kern/thread.h>

+#include <kern/debug.h>

 #include <kern/sched_prim.h>
 #include <kern/misc_protos.h>
 #include <stdarg.h>
 #include <kern/sched_prim.h>
 #include <kern/misc_protos.h>
 #include <stdarg.h>


@@ -156,77 +168,104 @@
 #ifdef  MACH_BSD
 #include <sys/msgbuf.h>
 #endif
 #ifdef  MACH_BSD
 #include <sys/msgbuf.h>
 #endif

+#include <console/serial_protos.h>
+#include <os/log_private.h>

 
 

-#ifdef __ppc__
-#include <ppc/Firmware.h>
-#endif
-
-/*
- * Forward declarations
- */
-void printnum(
-       register unsigned int   u,
-       register int            base,
-       void                    (*putc)(char));
+#ifdef __x86_64__
+#include <i386/cpu_data.h>
+#endif /* __x86_64__ */

 
 

+#if __arm__ || __arm64__
+#include <arm/cpu_data_internal.h>
+#endif

 
 #define isdigit(d) ((d) >= '0' && (d) <= '9')
 #define Ctod(c) ((c) - '0')
 
 
 #define isdigit(d) ((d) >= '0' && (d) <= '9')
 #define Ctod(c) ((c) - '0')
 

-#define MAXBUF (sizeof(long int) * 8)           /* enough for binary */
+#define MAXBUF (sizeof(long long int) * 8)     /* enough for binary */
+static char digs[] = "0123456789abcdef";

 
 

-void
+#if CONFIG_NO_PRINTF_STRINGS
+/* Prevent CPP from breaking the definition below */
+#undef printf
+#endif
+
+int _consume_printf_args(int a __unused, ...)
+{
+    return 0;
+}
+void _consume_kprintf_args(int a __unused, ...)
+{
+}
+
+static int

 printnum(
 printnum(

-       register unsigned int   u,              /* number to print */
-       register int            base,
-       void                    (*putc)(char))
+       unsigned long long int  u,      /* number to print */
+       int             base,
+       void                    (*putc)(int, void *),
+       void                    *arg)

 {
        char    buf[MAXBUF];    /* build number here */
 {
        char    buf[MAXBUF];    /* build number here */

-       register char * p = &buf[MAXBUF-1];
-       static char digs[] = "0123456789abcdef";
+       char *  p = &buf[MAXBUF-1];
+       int nprinted = 0;

 
        do {
            *p-- = digs[u % base];
            u /= base;
        } while (u != 0);
 
 
        do {
            *p-- = digs[u % base];
            u /= base;
        } while (u != 0);
 

-       while (++p != &buf[MAXBUF])
-           (*putc)(*p);
+       while (++p != &buf[MAXBUF]) {
+           (*putc)(*p, arg);
+           nprinted++;
+       }

 
 

+       return nprinted;

 }
 
 boolean_t      _doprnt_truncates = FALSE;
 
 }
 
 boolean_t      _doprnt_truncates = FALSE;
 

-void 
-_doprnt(
-       register const char     *fmt,
-       va_list                 *argp,
+#if (DEVELOPMENT || DEBUG) 
+boolean_t      doprnt_hide_pointers = FALSE;
+#else
+boolean_t      doprnt_hide_pointers = TRUE;
+#endif
+
+int
+__doprnt(
+       const char      *fmt,
+       va_list                 argp,

                                                /* character output routine */
                                                /* character output routine */

-       void                    (*putc)(char),
-       int                     radix)          /* default radix - for '%r' */
+       void                    (*putc)(int, void *arg),
+       void                    *arg,
+       int                     radix,          /* default radix - for '%r' */
+       int                     is_log)

 {
        int             length;
        int             prec;
        boolean_t       ladjust;
        char            padc;
 {
        int             length;
        int             prec;
        boolean_t       ladjust;
        char            padc;

-       long            n;
-       unsigned long   u;
+       long long               n;
+       unsigned long long      u;

        int             plus_sign;
        int             sign_char;
        boolean_t       altfmt, truncate;
        int             base;
        int             plus_sign;
        int             sign_char;
        boolean_t       altfmt, truncate;
        int             base;

-       register char   c;
+       char    c;

        int             capitals;
        int             capitals;

+       int             long_long;
+       int             nprinted = 0;

 
        while ((c = *fmt) != '\0') {
            if (c != '%') {
 
        while ((c = *fmt) != '\0') {
            if (c != '%') {

-               (*putc)(c);
+               (*putc)(c, arg);
+               nprinted++;

                fmt++;
                continue;
            }
 
            fmt++;
 
                fmt++;
                continue;
            }
 
            fmt++;
 

+           long_long = 0;

            length = 0;
            prec = -1;
            ladjust = FALSE;
            length = 0;
            prec = -1;
            ladjust = FALSE;


@@ -267,7 +306,7 @@ _doprnt(
                }
            }
            else if (c == '*') {
                }
            }
            else if (c == '*') {

-               length = va_arg(*argp, int);
+               length = va_arg(argp, int);

                c = *++fmt;
                if (length < 0) {
                    ladjust = !ladjust;
                c = *++fmt;
                if (length < 0) {
                    ladjust = !ladjust;


@@ -285,13 +324,30 @@ _doprnt(
                    }
                }
                else if (c == '*') {
                    }
                }
                else if (c == '*') {

-                   prec = va_arg(*argp, int);
+                   prec = va_arg(argp, int);

                    c = *++fmt;
                }
            }
 
                    c = *++fmt;
                }
            }
 

-           if (c == 'l')
+           if (c == 'l') {

                c = *++fmt;     /* need it if sizeof(int) < sizeof(long) */
                c = *++fmt;     /* need it if sizeof(int) < sizeof(long) */

+               if (sizeof(int)<sizeof(long))
+                   long_long = 1;
+               if (c == 'l') {
+                   long_long = 1;
+                   c = *++fmt;
+               }       
+           } else if (c == 'q' || c == 'L') {
+               long_long = 1;
+               c = *++fmt;
+           }
+
+           if (c == 'z' || c == 'Z') {
+                   c = *++fmt;
+                   if (sizeof(size_t) == sizeof(unsigned long)){
+                           long_long = 1;
+                   }
+           }

 
            truncate = FALSE;
            capitals=0;         /* Assume lower case printing */
 
            truncate = FALSE;
            capitals=0;         /* Assume lower case printing */


@@ -300,14 +356,18 @@ _doprnt(
                case 'b':
                case 'B':
                {
                case 'b':
                case 'B':
                {

-                   register char *p;
+                   char *p;

                    boolean_t     any;
                    boolean_t     any;

-                   register int  i;
+                   int  i;

 
 

-                   u = va_arg(*argp, unsigned long);
-                   p = va_arg(*argp, char *);
+                   if (long_long) {
+                       u = va_arg(argp, unsigned long long);
+                   } else {
+                       u = va_arg(argp, unsigned int);
+                   }
+                   p = va_arg(argp, char *);

                    base = *p++;
                    base = *p++;

-                   printnum(u, base, putc);
+                   nprinted += printnum(u, base, putc, arg);

 
                    if (u == 0)
                        break;
 
                    if (u == 0)
                        break;


@@ -320,57 +380,66 @@ _doprnt(
                            /*
                             * Bit field
                             */
                            /*
                             * Bit field
                             */

-                           register int j;
+                           int j;

                            if (any)
                            if (any)

-                               (*putc)(',');
+                               (*putc)(',', arg);

                            else {
                            else {

-                               (*putc)('<');
+                               (*putc)('<', arg);

                                any = TRUE;
                            }
                                any = TRUE;
                            }

+                           nprinted++;

                            j = *p++;
                            if (*fmt == 'B')
                                j = 32 - j;
                            j = *p++;
                            if (*fmt == 'B')
                                j = 32 - j;

-                           for (; (c = *p) > 32; p++)
-                               (*putc)(c);
-                           printnum((unsigned)( (u>>(j-1)) & ((2<<(i-j))-1)),
-                                       base, putc);
+                           for (; (c = *p) > 32; p++) {
+                               (*putc)(c, arg);
+                               nprinted++;
+                           }
+                           nprinted += printnum((unsigned)( (u>>(j-1)) & ((2<<(i-j))-1)),
+                                                base, putc, arg);

                        }
                        else if (u & (1<<(i-1))) {
                            if (any)
                        }
                        else if (u & (1<<(i-1))) {
                            if (any)

-                               (*putc)(',');
+                               (*putc)(',', arg);

                            else {
                            else {

-                               (*putc)('<');
+                               (*putc)('<', arg);

                                any = TRUE;
                            }
                                any = TRUE;
                            }

-                           for (; (c = *p) > 32; p++)
-                               (*putc)(c);
+                           nprinted++;
+                           for (; (c = *p) > 32; p++) {
+                               (*putc)(c, arg);
+                               nprinted++;
+                           }

                        }
                        else {
                            for (; *p > 32; p++)
                                continue;
                        }
                    }
                        }
                        else {
                            for (; *p > 32; p++)
                                continue;
                        }
                    }

-                   if (any)
-                       (*putc)('>');
+                   if (any) {
+                       (*putc)('>', arg);
+                       nprinted++;
+                   }

                    break;
                }
 
                case 'c':
                    break;
                }
 
                case 'c':

-                   c = va_arg(*argp, int);
-                   (*putc)(c);
+                   c = va_arg(argp, int);
+                   (*putc)(c, arg);
+                   nprinted++;

                    break;
 
                case 's':
                {
                    break;
 
                case 's':
                {

-                   register char *p;
-                   register char *p2;
+                   const char *p;
+                   const char *p2;

 
                    if (prec == -1)
                        prec = 0x7fffffff;      /* MAXINT */
 
 
                    if (prec == -1)
                        prec = 0x7fffffff;      /* MAXINT */
 

-                   p = va_arg(*argp, char *);
+                   p = va_arg(argp, char *);

 
 

-                   if (p == (char *)0)
+                   if (p == NULL)

                        p = "";
 
                    if (length > 0 && !ladjust) {
                        p = "";
 
                    if (length > 0 && !ladjust) {


@@ -383,24 +452,28 @@ _doprnt(
                        p = p2;
 
                        while (n < length) {
                        p = p2;
 
                        while (n < length) {

-                           (*putc)(' ');
+                           (*putc)(' ', arg);

                            n++;
                            n++;

+                           nprinted++;

                        }
                    }
 
                    n = 0;
 
                        }
                    }
 
                    n = 0;
 

-                   while (*p != '\0') {
-                       if (++n > prec || (length > 0 && n > length))
-                           break;
-
-                       (*putc)(*p++);
+                   while ((n < prec) && (!(length > 0 && n >= length))) {
+                           if (*p == '\0') {
+                                   break;
+                           }
+                           (*putc)(*p++, arg);
+                           nprinted++;
+                           n++;

                    }
 
                    if (n < length && ladjust) {
                        while (n < length) {
                    }
 
                    if (n < length && ladjust) {
                        while (n < length) {

-                           (*putc)(' ');
+                           (*putc)(' ', arg);

                            n++;
                            n++;

+                           nprinted++;

                        }
                    }
 
                        }
                    }
 


@@ -413,9 +486,31 @@ _doprnt(
                    base = 8;
                    goto print_unsigned;
 
                    base = 8;
                    goto print_unsigned;
 

+               case 'D': {
+                   unsigned char *up;
+                   char *q, *p;
+                   
+                       up = (unsigned char *)va_arg(argp, unsigned char *);
+                       p = (char *)va_arg(argp, char *);
+                       if (length == -1)
+                               length = 16;
+                       while(length--) {
+                               (*putc)(digs[(*up >> 4)], arg);
+                               (*putc)(digs[(*up & 0x0f)], arg);
+                               nprinted += 2;
+                               up++;
+                               if (length) {
+                                   for (q=p;*q;q++) {
+                                               (*putc)(*q, arg);
+                                               nprinted++;
+                                   }
+                               }
+                       }
+                       break;
+               }
+

                case 'd':
                    truncate = _doprnt_truncates;
                case 'd':
                    truncate = _doprnt_truncates;

-               case 'D':

                    base = 10;
                    goto print_signed;
 
                    base = 10;
                    goto print_signed;
 


@@ -427,6 +522,9 @@ _doprnt(
 
                case 'p':
                    altfmt = TRUE;
 
                case 'p':
                    altfmt = TRUE;

+                   if (sizeof(int)<sizeof(void *)) {
+                       long_long = 1;
+                   }

                case 'x':
                    truncate = _doprnt_truncates;
                    base = 16;
                case 'x':
                    truncate = _doprnt_truncates;
                    base = 16;


@@ -436,17 +534,7 @@ _doprnt(
                    base = 16;
                    capitals=16;        /* Print in upper case */
                    goto print_unsigned;
                    base = 16;
                    capitals=16;        /* Print in upper case */
                    goto print_unsigned;

-
-               case 'z':
-                   truncate = _doprnt_truncates;
-                   base = 16;
-                   goto print_signed;

                        
                        

-               case 'Z':
-                   base = 16;
-                   capitals=16;        /* Print in upper case */
-                   goto print_signed;
-

                case 'r':
                    truncate = _doprnt_truncates;
                case 'R':
                case 'r':
                    truncate = _doprnt_truncates;
                case 'R':


@@ -460,7 +548,11 @@ _doprnt(
                    goto print_unsigned;
 
                print_signed:
                    goto print_unsigned;
 
                print_signed:

-                   n = va_arg(*argp, long);
+                   if (long_long) {
+                       n = va_arg(argp, long long);
+                   } else {
+                       n = va_arg(argp, int);
+                   }

                    if (n >= 0) {
                        u = n;
                        sign_char = plus_sign;
                    if (n >= 0) {
                        u = n;
                        sign_char = plus_sign;


@@ -472,17 +564,36 @@ _doprnt(
                    goto print_num;
 
                print_unsigned:
                    goto print_num;
 
                print_unsigned:

-                   u = va_arg(*argp, unsigned long);
+                   if (long_long) {
+                       u = va_arg(argp, unsigned long long);
+                   } else { 
+                       u = va_arg(argp, unsigned int);
+                   }

                    goto print_num;
 
                print_num:
                {
                    char        buf[MAXBUF];    /* build number here */
                    goto print_num;
 
                print_num:
                {
                    char        buf[MAXBUF];    /* build number here */

-                   register char *     p = &buf[MAXBUF-1];
+                   char *      p = &buf[MAXBUF-1];

                    static char digits[] = "0123456789abcdef0123456789ABCDEF";
                    static char digits[] = "0123456789abcdef0123456789ABCDEF";

-                   char *prefix = 0;
+                   const char *prefix = NULL;
+
+                   if (truncate) u = (long long)((int)(u));

 
 

-                   if (truncate) u = (long)((int)(u));
+                   if (doprnt_hide_pointers && is_log) {
+                       const char str[] = "<ptr>";
+                       const char* strp = str;
+                       int strl = sizeof(str) - 1;
+
+                       if (u >= VM_MIN_KERNEL_AND_KEXT_ADDRESS && u <= VM_MAX_KERNEL_ADDRESS) {
+                           while(*strp != '\0') {
+                               (*putc)(*strp, arg);
+                               strp++;
+                           }
+                           nprinted += strl;
+                           break;
+                       }
+                   }

 
                    if (u != 0 && altfmt) {
                        if (base == 8)
 
                    if (u != 0 && altfmt) {
                        if (base == 8)


@@ -497,33 +608,46 @@ _doprnt(
                        u /= base;
                    } while (u != 0);
 
                        u /= base;
                    } while (u != 0);
 

-                   length -= (&buf[MAXBUF-1] - p);
+                   length -= (int)(&buf[MAXBUF-1] - p);

                    if (sign_char)
                        length--;
                    if (prefix)
                    if (sign_char)
                        length--;
                    if (prefix)

-                       length -= strlen((const char *) prefix);
+                       length -= (int)strlen(prefix);

 
                    if (padc == ' ' && !ladjust) {
                        /* blank padding goes before prefix */
 
                    if (padc == ' ' && !ladjust) {
                        /* blank padding goes before prefix */

-                       while (--length >= 0)
-                           (*putc)(' ');
+                       while (--length >= 0) {
+                           (*putc)(' ', arg);
+                           nprinted++;
+                       }                           
+                   }
+                   if (sign_char) {
+                       (*putc)(sign_char, arg);
+                       nprinted++;
+                   }
+                   if (prefix) {
+                       while (*prefix) {
+                           (*putc)(*prefix++, arg);
+                           nprinted++;
+                       }

                    }
                    }

-                   if (sign_char)
-                       (*putc)(sign_char);
-                   if (prefix)
-                       while (*prefix)
-                           (*putc)(*prefix++);

                    if (padc == '0') {
                        /* zero padding goes after sign and prefix */
                    if (padc == '0') {
                        /* zero padding goes after sign and prefix */

-                       while (--length >= 0)
-                           (*putc)('0');
+                       while (--length >= 0) {
+                           (*putc)('0', arg);
+                           nprinted++;
+                       }                           

                    }
                    }

-                   while (++p != &buf[MAXBUF])
-                       (*putc)(*p);
-
+                   while (++p != &buf[MAXBUF]) {
+                       (*putc)(*p, arg);
+                       nprinted++;
+                   }
+                   

                    if (ladjust) {
                    if (ladjust) {

-                       while (--length >= 0)
-                           (*putc)(' ');
+                       while (--length >= 0) {
+                           (*putc)(' ', arg);
+                           nprinted++;
+                       }

                    }
                    break;
                }
                    }
                    break;
                }


@@ -533,28 +657,92 @@ _doprnt(
                    break;
 
                default:
                    break;
 
                default:

-                   (*putc)(c);
+                   (*putc)(c, arg);
+                   nprinted++;

            }
        fmt++;
        }
            }
        fmt++;
        }

+
+       return nprinted;
+}
+
+static void
+dummy_putc(int ch, void *arg)
+{
+    void (*real_putc)(char) = arg;
+    
+    real_putc(ch);
+}
+
+void 
+_doprnt(
+       const char      *fmt,
+       va_list                 *argp,
+                                               /* character output routine */
+       void                    (*putc)(char),
+       int                     radix)          /* default radix - for '%r' */
+{
+    __doprnt(fmt, *argp, dummy_putc, putc, radix, FALSE);
+}
+
+void 
+_doprnt_log(
+       const char      *fmt,
+       va_list                 *argp,
+                                               /* character output routine */
+       void                    (*putc)(char),
+       int                     radix)          /* default radix - for '%r' */
+{
+    __doprnt(fmt, *argp, dummy_putc, putc, radix, TRUE);

 }
 
 #if    MP_PRINTF 
 boolean_t      new_printf_cpu_number = FALSE;
 #endif /* MP_PRINTF */
 
 }
 
 #if    MP_PRINTF 
 boolean_t      new_printf_cpu_number = FALSE;
 #endif /* MP_PRINTF */
 

-

 decl_simple_lock_data(,printf_lock)
 decl_simple_lock_data(,printf_lock)

-decl_mutex_data(,sprintf_lock)
+decl_simple_lock_data(,bsd_log_spinlock)
+
+/*
+ * Defined here to allow lock group to be statically allocated.
+ */
+static lck_grp_t oslog_stream_lock_grp;
+decl_lck_spin_data(,oslog_stream_lock)
+void oslog_lock_init(void);
+
+extern void bsd_log_init(void);
+void bsd_log_lock(void);
+void bsd_log_unlock(void);

 
 void
 
 void

+

 printf_init(void)
 {
        /*
         * Lock is only really needed after the first thread is created.
         */
 printf_init(void)
 {
        /*
         * Lock is only really needed after the first thread is created.
         */

-       simple_lock_init(&printf_lock, ETAP_MISC_PRINTF);
-       mutex_init(&sprintf_lock, ETAP_MISC_PRINTF);
+       simple_lock_init(&printf_lock, 0);
+       simple_lock_init(&bsd_log_spinlock, 0);
+       bsd_log_init();
+}
+
+void
+bsd_log_lock(void)
+{
+       simple_lock(&bsd_log_spinlock);
+}
+
+void
+bsd_log_unlock(void)
+{
+       simple_unlock(&bsd_log_spinlock);
+}
+
+void
+oslog_lock_init(void)
+{
+       lck_grp_init(&oslog_stream_lock_grp, "oslog stream", LCK_GRP_ATTR_NULL);
+       lck_spin_init(&oslog_stream_lock, &oslog_stream_lock_grp, LCK_ATTR_NULL);

 }
 
 /* derived from boot_gets */
 }
 
 /* derived from boot_gets */


@@ -563,8 +751,8 @@ safe_gets(
        char    *str,
        int     maxlen)
 {
        char    *str,
        int     maxlen)
 {

-       register char *lp;
-       register int c;
+       char *lp;
+       int c;

        char *strmax = str + maxlen - 1; /* allow space for trailing 0 */
 
        lp = str;
        char *strmax = str + maxlen - 1; /* allow space for trailing 0 */
 
        lp = str;


@@ -606,52 +794,208 @@ safe_gets(
        }
 }
 
        }
 }
 

+extern int disableConsoleOutput;
+

 void
 conslog_putc(
        char c)
 {
 void
 conslog_putc(
        char c)
 {

-       extern unsigned int debug_mode, disableDebugOuput, disableConsoleOutput;
-
-       if ((debug_mode && !disableDebugOuput) || !disableConsoleOutput)
+       if (!disableConsoleOutput)

                cnputc(c);
 
 #ifdef MACH_BSD
                cnputc(c);
 
 #ifdef MACH_BSD

-       log_putc(c);
+       if (!kernel_debugger_entry_count)
+               log_putc(c);

 #endif
 }
 
 void
 #endif
 }
 
 void

+cons_putc_locked(
+       char c)
+{
+       if (!disableConsoleOutput)
+               cnputc(c);
+}
+
+static int
+vprintf_internal(const char *fmt, va_list ap_in, void *caller)
+{
+       cpu_data_t * cpu_data_p;
+       if (fmt) {
+               struct console_printbuf_state info_data;
+               cpu_data_p = current_cpu_datap();
+
+               va_list ap;
+               va_copy(ap, ap_in);
+               /*
+                * for early boot printf()s console may not be setup,
+                * fallback to good old cnputc
+                */
+               if (cpu_data_p->cpu_console_buf != NULL) {
+                       console_printbuf_state_init(&info_data, TRUE, TRUE);
+                       __doprnt(fmt, ap, console_printbuf_putc, &info_data, 16, TRUE);
+                       console_printbuf_clear(&info_data);
+               } else {
+                       disable_preemption();
+                       _doprnt_log(fmt, &ap, cons_putc_locked, 16);
+                       enable_preemption();
+               }
+
+               va_end(ap);
+
+               os_log_with_args(OS_LOG_DEFAULT, OS_LOG_TYPE_DEFAULT, fmt, ap_in, caller);
+       }
+       return 0;
+}
+
+__attribute__((noinline,not_tail_called))
+int

 printf(const char *fmt, ...)
 printf(const char *fmt, ...)

+{
+       int ret;
+
+       va_list ap;
+       va_start(ap, fmt);
+       ret = vprintf_internal(fmt, ap, __builtin_return_address(0));
+       va_end(ap);
+
+       return ret;
+}
+
+__attribute__((noinline,not_tail_called))
+int
+vprintf(const char *fmt, va_list ap)
+{
+       return vprintf_internal(fmt, ap, __builtin_return_address(0));
+}
+
+void
+consdebug_putc(char c)
+{
+       if (!disableConsoleOutput)
+               cnputc(c);
+
+       debug_putc(c);
+
+       if (!console_is_serial() && !disable_serial_output)
+               PE_kputc(c);
+}
+
+void
+consdebug_putc_unbuffered(char c)
+{
+       if (!disableConsoleOutput)
+               cnputc_unbuffered(c);
+
+       debug_putc(c);
+
+       if (!console_is_serial() && !disable_serial_output)
+                       PE_kputc(c);
+}
+
+void
+consdebug_log(char c)
+{
+       debug_putc(c);
+}
+
+/*
+ * Append contents to the paniclog buffer but don't flush
+ * it. This is mainly used for writing the actual paniclog
+ * contents since flushing once for every line written
+ * would be prohibitively expensive for the paniclog
+ */
+int
+paniclog_append_noflush(const char *fmt, ...)
+{
+       va_list listp;
+
+       va_start(listp, fmt);
+       _doprnt_log(fmt, &listp, consdebug_putc, 16);
+       va_end(listp);
+
+       return 0;
+}
+
+int
+kdb_printf(const char *fmt, ...)
+{
+       va_list listp;
+
+       va_start(listp, fmt);
+       _doprnt_log(fmt, &listp, consdebug_putc, 16);
+       va_end(listp);
+
+#if CONFIG_EMBEDDED
+       paniclog_flush();
+#endif
+
+       return 0;
+}
+
+int
+kdb_log(const char *fmt, ...)
+{
+       va_list listp;
+
+       va_start(listp, fmt);
+       _doprnt(fmt, &listp, consdebug_log, 16);
+       va_end(listp);
+
+#if CONFIG_EMBEDDED
+       paniclog_flush();
+#endif
+
+       return 0;
+}
+
+int
+kdb_printf_unbuffered(const char *fmt, ...)

 {
        va_list listp;
 
 {
        va_list listp;
 

-       disable_preemption();

        va_start(listp, fmt);
        va_start(listp, fmt);

-       _doprnt(fmt, &listp, conslog_putc, 16);
+       _doprnt(fmt, &listp, consdebug_putc_unbuffered, 16);

        va_end(listp);
        va_end(listp);

-       enable_preemption();
+
+#if CONFIG_EMBEDDED
+       paniclog_flush();
+#endif
+
+       return 0;

 }
 
 }
 

-static char *copybyte_str;
+#if !CONFIG_EMBEDDED

 
 static void
 
 static void

-copybyte(
-        char byte)
+copybyte(int c, void *arg)

 {
 {

-  *copybyte_str++ = byte;
-  *copybyte_str = '\0';
+       /*
+        * arg is a pointer (outside pointer) to the pointer
+        * (inside pointer) which points to the character.
+        * We pass a double pointer, so that we can increment
+        * the inside pointer.
+        */
+       char** p = arg; /* cast outside pointer */
+       **p = c;        /* store character */
+       (*p)++;         /* increment inside pointer */

 }
 
 }
 

+/*
+ * Deprecation Warning:
+ *     sprintf() is being deprecated. Please use snprintf() instead.
+ */

 int
 sprintf(char *buf, const char *fmt, ...)
 {
         va_list listp;
 int
 sprintf(char *buf, const char *fmt, ...)
 {
         va_list listp;

+       char *copybyte_str;

 
         va_start(listp, fmt);
 
         va_start(listp, fmt);

-       mutex_lock(&sprintf_lock);

         copybyte_str = buf;
         copybyte_str = buf;

-        _doprnt(fmt, &listp, copybyte, 16);
-       mutex_unlock(&sprintf_lock);
+        __doprnt(fmt, listp, copybyte, &copybyte_str, 16, FALSE);

         va_end(listp);
         va_end(listp);

-        return strlen(buf);
+       *copybyte_str = '\0';
+        return (int)strlen(buf);

 }
 }

+#endif /* !CONFIG_EMBEDDED */