Added a new SafeSPrintf() function that implements snprintf() in an async-safe-fashion

base/debug/stack_trace_posix.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/stack_trace.h"
 
 #include <errno.h>
 #include <execinfo.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <ostream>
 
 #if defined(__GLIBCXX__)
 #include <cxxabi.h>
 #endif
 
 #if defined(OS_MACOSX)
 #include <AvailabilityMacros.h>
 #endif
 
 #include "base/basictypes.h"
 #include "base/debug/debugger.h"
+#include "base/debug/format.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/strings/string_number_conversions.h"
 
 #if defined(USE_SYMBOLIZE)
 #include "base/third_party/symbolize/symbolize.h"
 #endif
 
 namespace base {
@@ skipping 65 matching lines @@
 
 class BacktraceOutputHandler {
  public:
   virtual void HandleOutput(const char* output) = 0;
 
  protected:
   virtual ~BacktraceOutputHandler() {}
 };
 
 void OutputPointer(void* pointer, BacktraceOutputHandler* handler) {
-  char buf[1024] = { '\0' };
-  handler->HandleOutput(" [0x");
-  internal::itoa_r(reinterpret_cast<intptr_t>(pointer),
-                   buf, sizeof(buf), 16, 12);
+  char buf[30];
+  Format(buf, " [0x%12x]", reinterpret_cast<intptr_t>(pointer));
   handler->HandleOutput(buf);
-  handler->HandleOutput("]");
 }
 
 void ProcessBacktrace(void *const *trace,
                       int size,
                       BacktraceOutputHandler* handler) {
   // NOTE: This code MUST be async-signal safe (it's used by in-process
   // stack dumping signal handler). NO malloc or stdio is allowed here.
 
 #if defined(USE_SYMBOLIZE)
   for (int i = 0; i < size; ++i) {
@@ skipping 50 matching lines @@
   // NOTE: This code MUST be async-signal safe.
   // NO malloc or stdio is allowed here.
 
   // Record the fact that we are in the signal handler now, so that the rest
   // of StackTrace can behave in an async-signal-safe manner.
   in_signal_handler = 1;
 
   if (BeingDebugged())
     BreakDebugger();
 
-  PrintToStderr("Received signal ");
-  char buf[1024] = { 0 };
-  internal::itoa_r(signal, buf, sizeof(buf), 10, 0);
+  char buf[80];
+  Format(buf, "Received signal %d ", signal);
   PrintToStderr(buf);
   if (signal == SIGBUS) {
     if (info->si_code == BUS_ADRALN)
-      PrintToStderr(" BUS_ADRALN ");
+      PrintToStderr("BUS_ADRALN ");
     else if (info->si_code == BUS_ADRERR)
-      PrintToStderr(" BUS_ADRERR ");
+      PrintToStderr("BUS_ADRERR ");
     else if (info->si_code == BUS_OBJERR)
-      PrintToStderr(" BUS_OBJERR ");
+      PrintToStderr("BUS_OBJERR ");
     else
-      PrintToStderr(" <unknown> ");
+      PrintToStderr("<unknown> ");
   } else if (signal == SIGFPE) {
     if (info->si_code == FPE_FLTDIV)
-      PrintToStderr(" FPE_FLTDIV ");
+      PrintToStderr("FPE_FLTDIV ");
     else if (info->si_code == FPE_FLTINV)
-      PrintToStderr(" FPE_FLTINV ");
+      PrintToStderr("FPE_FLTINV ");
     else if (info->si_code == FPE_FLTOVF)
-      PrintToStderr(" FPE_FLTOVF ");
+      PrintToStderr("FPE_FLTOVF ");
     else if (info->si_code == FPE_FLTRES)
-      PrintToStderr(" FPE_FLTRES ");
+      PrintToStderr("FPE_FLTRES ");
     else if (info->si_code == FPE_FLTSUB)
-      PrintToStderr(" FPE_FLTSUB ");
+      PrintToStderr("FPE_FLTSUB ");
     else if (info->si_code == FPE_FLTUND)
-      PrintToStderr(" FPE_FLTUND ");
+      PrintToStderr("FPE_FLTUND ");
     else if (info->si_code == FPE_INTDIV)
-      PrintToStderr(" FPE_INTDIV ");
+      PrintToStderr("FPE_INTDIV ");
     else if (info->si_code == FPE_INTOVF)
-      PrintToStderr(" FPE_INTOVF ");
+      PrintToStderr("FPE_INTOVF ");
     else
-      PrintToStderr(" <unknown> ");
+      PrintToStderr("<unknown> ");
   } else if (signal == SIGILL) {
     if (info->si_code == ILL_BADSTK)
-      PrintToStderr(" ILL_BADSTK ");
+      PrintToStderr("ILL_BADSTK ");
     else if (info->si_code == ILL_COPROC)
-      PrintToStderr(" ILL_COPROC ");
+      PrintToStderr("ILL_COPROC ");
     else if (info->si_code == ILL_ILLOPN)
-      PrintToStderr(" ILL_ILLOPN ");
+      PrintToStderr("ILL_ILLOPN ");
     else if (info->si_code == ILL_ILLADR)
-      PrintToStderr(" ILL_ILLADR ");
+      PrintToStderr("ILL_ILLADR ");
     else if (info->si_code == ILL_ILLTRP)
-      PrintToStderr(" ILL_ILLTRP ");
+      PrintToStderr("ILL_ILLTRP ");
     else if (info->si_code == ILL_PRVOPC)
-      PrintToStderr(" ILL_PRVOPC ");
+      PrintToStderr("ILL_PRVOPC ");
     else if (info->si_code == ILL_PRVREG)
-      PrintToStderr(" ILL_PRVREG ");
+      PrintToStderr("ILL_PRVREG ");
     else
-      PrintToStderr(" <unknown> ");
+      PrintToStderr("<unknown> ");
   } else if (signal == SIGSEGV) {
     if (info->si_code == SEGV_MAPERR)
-      PrintToStderr(" SEGV_MAPERR ");
+      PrintToStderr("SEGV_MAPERR ");
     else if (info->si_code == SEGV_ACCERR)
-      PrintToStderr(" SEGV_ACCERR ");
+      PrintToStderr("SEGV_ACCERR ");
     else
-      PrintToStderr(" <unknown> ");
+      PrintToStderr("<unknown> ");
   }
   if (signal == SIGBUS || signal == SIGFPE ||
       signal == SIGILL || signal == SIGSEGV) {
-    internal::itoa_r(reinterpret_cast<intptr_t>(info->si_addr),
-                     buf, sizeof(buf), 16, 12);
+    Format(buf, "%12x", reinterpret_cast<intptr_t>(info->si_addr));
     PrintToStderr(buf);
   }
   PrintToStderr("\n");
 
   debug::StackTrace().PrintBacktrace();
 
 #if defined(OS_LINUX)
 #if ARCH_CPU_X86_FAMILY
   ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
   const struct {
     const char* label;
     greg_t value;
   } registers[] = {
 #if ARCH_CPU_32_BITS
-    { "  gs: ", context->uc_mcontext.gregs[REG_GS] },
-    { "  fs: ", context->uc_mcontext.gregs[REG_FS] },
-    { "  es: ", context->uc_mcontext.gregs[REG_ES] },
-    { "  ds: ", context->uc_mcontext.gregs[REG_DS] },
-    { " edi: ", context->uc_mcontext.gregs[REG_EDI] },
-    { " esi: ", context->uc_mcontext.gregs[REG_ESI] },
-    { " ebp: ", context->uc_mcontext.gregs[REG_EBP] },
-    { " esp: ", context->uc_mcontext.gregs[REG_ESP] },
-    { " ebx: ", context->uc_mcontext.gregs[REG_EBX] },
-    { " edx: ", context->uc_mcontext.gregs[REG_EDX] },
-    { " ecx: ", context->uc_mcontext.gregs[REG_ECX] },
-    { " eax: ", context->uc_mcontext.gregs[REG_EAX] },
-    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
-    { " err: ", context->uc_mcontext.gregs[REG_ERR] },
-    { "  ip: ", context->uc_mcontext.gregs[REG_EIP] },
-    { "  cs: ", context->uc_mcontext.gregs[REG_CS] },
-    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
-    { " usp: ", context->uc_mcontext.gregs[REG_UESP] },
-    { "  ss: ", context->uc_mcontext.gregs[REG_SS] },
+    {  "gs", context->uc_mcontext.gregs[REG_GS] },
+    {  "fs", context->uc_mcontext.gregs[REG_FS] },
+    {  "es", context->uc_mcontext.gregs[REG_ES] },
+    {  "ds", context->uc_mcontext.gregs[REG_DS] },
+    { "edi", context->uc_mcontext.gregs[REG_EDI] },
+    { "esi", context->uc_mcontext.gregs[REG_ESI] },
+    { "ebp", context->uc_mcontext.gregs[REG_EBP] },
+    { "esp", context->uc_mcontext.gregs[REG_ESP] },
+    { "ebx", context->uc_mcontext.gregs[REG_EBX] },
+    { "edx", context->uc_mcontext.gregs[REG_EDX] },
+    { "ecx", context->uc_mcontext.gregs[REG_ECX] },
+    { "eax", context->uc_mcontext.gregs[REG_EAX] },
+    { "trp", context->uc_mcontext.gregs[REG_TRAPNO] },
+    { "err", context->uc_mcontext.gregs[REG_ERR] },
+    {  "ip", context->uc_mcontext.gregs[REG_EIP] },
+    {  "cs", context->uc_mcontext.gregs[REG_CS] },
+    { "efl", context->uc_mcontext.gregs[REG_EFL] },
+    { "usp", context->uc_mcontext.gregs[REG_UESP] },
+    {  "ss", context->uc_mcontext.gregs[REG_SS] },
 #elif ARCH_CPU_64_BITS
-    { "  r8: ", context->uc_mcontext.gregs[REG_R8] },
-    { "  r9: ", context->uc_mcontext.gregs[REG_R9] },
-    { " r10: ", context->uc_mcontext.gregs[REG_R10] },
-    { " r11: ", context->uc_mcontext.gregs[REG_R11] },
-    { " r12: ", context->uc_mcontext.gregs[REG_R12] },
-    { " r13: ", context->uc_mcontext.gregs[REG_R13] },
-    { " r14: ", context->uc_mcontext.gregs[REG_R14] },
-    { " r15: ", context->uc_mcontext.gregs[REG_R15] },
-    { "  di: ", context->uc_mcontext.gregs[REG_RDI] },
-    { "  si: ", context->uc_mcontext.gregs[REG_RSI] },
-    { "  bp: ", context->uc_mcontext.gregs[REG_RBP] },
-    { "  bx: ", context->uc_mcontext.gregs[REG_RBX] },
-    { "  dx: ", context->uc_mcontext.gregs[REG_RDX] },
-    { "  ax: ", context->uc_mcontext.gregs[REG_RAX] },
-    { "  cx: ", context->uc_mcontext.gregs[REG_RCX] },
-    { "  sp: ", context->uc_mcontext.gregs[REG_RSP] },
-    { "  ip: ", context->uc_mcontext.gregs[REG_RIP] },
-    { " efl: ", context->uc_mcontext.gregs[REG_EFL] },
-    { " cgf: ", context->uc_mcontext.gregs[REG_CSGSFS] },
-    { " erf: ", context->uc_mcontext.gregs[REG_ERR] },
-    { " trp: ", context->uc_mcontext.gregs[REG_TRAPNO] },
-    { " msk: ", context->uc_mcontext.gregs[REG_OLDMASK] },
-    { " cr2: ", context->uc_mcontext.gregs[REG_CR2] },
+    {  "r8", context->uc_mcontext.gregs[REG_R8] },
+    {  "r9", context->uc_mcontext.gregs[REG_R9] },
+    { "r10", context->uc_mcontext.gregs[REG_R10] },
+    { "r11", context->uc_mcontext.gregs[REG_R11] },
+    { "r12", context->uc_mcontext.gregs[REG_R12] },
+    { "r13", context->uc_mcontext.gregs[REG_R13] },
+    { "r14", context->uc_mcontext.gregs[REG_R14] },
+    { "r15", context->uc_mcontext.gregs[REG_R15] },
+    {  "di", context->uc_mcontext.gregs[REG_RDI] },
+    {  "si", context->uc_mcontext.gregs[REG_RSI] },
+    {  "bp", context->uc_mcontext.gregs[REG_RBP] },
+    {  "bx", context->uc_mcontext.gregs[REG_RBX] },
+    {  "dx", context->uc_mcontext.gregs[REG_RDX] },
+    {  "ax", context->uc_mcontext.gregs[REG_RAX] },
+    {  "cx", context->uc_mcontext.gregs[REG_RCX] },
+    {  "sp", context->uc_mcontext.gregs[REG_RSP] },
+    {  "ip", context->uc_mcontext.gregs[REG_RIP] },
+    { "efl", context->uc_mcontext.gregs[REG_EFL] },
+    { "cgf", context->uc_mcontext.gregs[REG_CSGSFS] },
+    { "erf", context->uc_mcontext.gregs[REG_ERR] },
+    { "trp", context->uc_mcontext.gregs[REG_TRAPNO] },
+    { "msk", context->uc_mcontext.gregs[REG_OLDMASK] },
+    { "cr2", context->uc_mcontext.gregs[REG_CR2] },
 #endif
   };
 
 #if ARCH_CPU_32_BITS
-  const int kRegisterPadding = 8;
+  #define K_REGISTER_PADDING "8"
 #elif ARCH_CPU_64_BITS
-  const int kRegisterPadding = 16;
+  #define K_REGISTER_PADDING "16"
 #endif
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(registers); i++) {
-    PrintToStderr(registers[i].label);
-    internal::itoa_r(registers[i].value, buf, sizeof(buf),
-                     16, kRegisterPadding);
+    Format(buf, "%4s: %"K_REGISTER_PADDING"x%s",
+           registers[i].label,
+           registers[i].value,
+           (i + 1) % 4 == 0 ? "\n" : "");
     PrintToStderr(buf);
-
-    if ((i + 1) % 4 == 0)
-      PrintToStderr("\n");
   }
   PrintToStderr("\n");
 #endif
 #elif defined(OS_MACOSX)
   // TODO(shess): Port to 64-bit.
 #if ARCH_CPU_X86_FAMILY && ARCH_CPU_32_BITS
   ucontext_t* context = reinterpret_cast<ucontext_t*>(void_context);
   size_t len;
 
   // NOTE: Even |snprintf()| is not on the approved list for signal
@@ skipping 144 matching lines @@
 
   PrintBacktraceOutputHandler handler;
   ProcessBacktrace(trace_, count_, &handler);
 }
 
 void StackTrace::OutputToStream(std::ostream* os) const {
   StreamBacktraceOutputHandler handler(os);
   ProcessBacktrace(trace_, count_, &handler);
 }
 
-namespace internal {
-
-// NOTE: code from sandbox/linux/seccomp-bpf/demo.cc.
-char *itoa_r(intptr_t i, char *buf, size_t sz, int base, size_t padding) {
-  // Make sure we can write at least one NUL byte.
-  size_t n = 1;
-  if (n > sz)
-    return NULL;
-
-  if (base < 2 || base > 16) {
-    buf[0] = '\000';
-    return NULL;
-  }
-
-  char *start = buf;
-
-  uintptr_t j = i;
-
-  // Handle negative numbers (only for base 10).
-  if (i < 0 && base == 10) {
-    j = -i;
-
-    // Make sure we can write the '-' character.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return NULL;
-    }
-    *start++ = '-';
-  }
-
-  // Loop until we have converted the entire number. Output at least one
-  // character (i.e. '0').
-  char *ptr = start;
-  do {
-    // Make sure there is still enough space left in our output buffer.
-    if (++n > sz) {
-      buf[0] = '\000';
-      return NULL;
-    }
-
-    // Output the next digit.
-    *ptr++ = "0123456789abcdef"[j % base];
-    j /= base;
-
-    if (padding > 0)
-      padding--;
-  } while (j > 0 || padding > 0);
-
-  // Terminate the output with a NUL character.
-  *ptr = '\000';
-
-  // Conversion to ASCII actually resulted in the digits being in reverse
-  // order. We can't easily generate them in forward order, as we can't tell
-  // the number of characters needed until we are done converting.
-  // So, now, we reverse the string (except for the possible "-" sign).
-  while (--ptr > start) {
-    char ch = *ptr;
-    *ptr = *start;
-    *start++ = ch;
-  }
-  return buf;
-}
-
-}  // namespace internal
-
 }  // namespace debug
 }  // namespace base