1//===-- sanitizer_printf.cc -----------------------------------------------===//
2//
3// This file is distributed under the University of Illinois Open Source
4// License. See LICENSE.TXT for details.
5//
6//===----------------------------------------------------------------------===//
7//
8// This file is shared between AddressSanitizer and ThreadSanitizer.
9//
10// Internal printf function, used inside run-time libraries.
11// We can't use libc printf because we intercept some of the functions used
12// inside it.
13//===----------------------------------------------------------------------===//
14
15
16#include "sanitizer_common.h"
17#include "sanitizer_flags.h"
18#include "sanitizer_libc.h"
19
20#include <stdio.h>
21#include <stdarg.h>
22
23#if SANITIZER_WINDOWS && defined(_MSC_VER) && _MSC_VER < 1800 &&               \
24      !defined(va_copy)
25# define va_copy(dst, src) ((dst) = (src))
26#endif
27
28namespace __sanitizer {
29
30StaticSpinMutex CommonSanitizerReportMutex;
31
32static int AppendChar(char **buff, const char *buff_end, char c) {
33  if (*buff < buff_end) {
34    **buff = c;
35    (*buff)++;
36  }
37  return 1;
38}
39
40// Appends number in a given base to buffer. If its length is less than
41// |minimal_num_length|, it is padded with leading zeroes or spaces, depending
42// on the value of |pad_with_zero|.
43static int AppendNumber(char **buff, const char *buff_end, u64 absolute_value,
44                        u8 base, u8 minimal_num_length, bool pad_with_zero,
45                        bool negative) {
46  uptr const kMaxLen = 30;
47  RAW_CHECK(base == 10 || base == 16);
48  RAW_CHECK(base == 10 || !negative);
49  RAW_CHECK(absolute_value || !negative);
50  RAW_CHECK(minimal_num_length < kMaxLen);
51  int result = 0;
52  if (negative && minimal_num_length)
53    --minimal_num_length;
54  if (negative && pad_with_zero)
55    result += AppendChar(buff, buff_end, '-');
56  uptr num_buffer[kMaxLen];
57  int pos = 0;
58  do {
59    RAW_CHECK_MSG((uptr)pos < kMaxLen, "AppendNumber buffer overflow");
60    num_buffer[pos++] = absolute_value % base;
61    absolute_value /= base;
62  } while (absolute_value > 0);
63  if (pos < minimal_num_length) {
64    // Make sure compiler doesn't insert call to memset here.
65    internal_memset(&num_buffer[pos], 0,
66                    sizeof(num_buffer[0]) * (minimal_num_length - pos));
67    pos = minimal_num_length;
68  }
69  RAW_CHECK(pos > 0);
70  pos--;
71  for (; pos >= 0 && num_buffer[pos] == 0; pos--) {
72    char c = (pad_with_zero || pos == 0) ? '0' : ' ';
73    result += AppendChar(buff, buff_end, c);
74  }
75  if (negative && !pad_with_zero) result += AppendChar(buff, buff_end, '-');
76  for (; pos >= 0; pos--) {
77    char digit = static_cast<char>(num_buffer[pos]);
78    result += AppendChar(buff, buff_end, (digit < 10) ? '0' + digit
79                                                      : 'a' + digit - 10);
80  }
81  return result;
82}
83
84static int AppendUnsigned(char **buff, const char *buff_end, u64 num, u8 base,
85                          u8 minimal_num_length, bool pad_with_zero) {
86  return AppendNumber(buff, buff_end, num, base, minimal_num_length,
87                      pad_with_zero, false /* negative */);
88}
89
90static int AppendSignedDecimal(char **buff, const char *buff_end, s64 num,
91                               u8 minimal_num_length, bool pad_with_zero) {
92  bool negative = (num < 0);
93  return AppendNumber(buff, buff_end, (u64)(negative ? -num : num), 10,
94                      minimal_num_length, pad_with_zero, negative);
95}
96
97static int AppendString(char **buff, const char *buff_end, int precision,
98                        const char *s) {
99  if (s == 0)
100    s = "<null>";
101  int result = 0;
102  for (; *s; s++) {
103    if (precision >= 0 && result >= precision)
104      break;
105    result += AppendChar(buff, buff_end, *s);
106  }
107  return result;
108}
109
110static int AppendPointer(char **buff, const char *buff_end, u64 ptr_value) {
111  int result = 0;
112  result += AppendString(buff, buff_end, -1, "0x");
113  result += AppendUnsigned(buff, buff_end, ptr_value, 16,
114                           SANITIZER_POINTER_FORMAT_LENGTH, true);
115  return result;
116}
117
118int VSNPrintf(char *buff, int buff_length,
119              const char *format, va_list args) {
120  static const char *kPrintfFormatsHelp =
121    "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x}; %p; %(\\.\\*)?s; %c\n";
122  RAW_CHECK(format);
123  RAW_CHECK(buff_length > 0);
124  const char *buff_end = &buff[buff_length - 1];
125  const char *cur = format;
126  int result = 0;
127  for (; *cur; cur++) {
128    if (*cur != '%') {
129      result += AppendChar(&buff, buff_end, *cur);
130      continue;
131    }
132    cur++;
133    bool have_width = (*cur >= '0' && *cur <= '9');
134    bool pad_with_zero = (*cur == '0');
135    int width = 0;
136    if (have_width) {
137      while (*cur >= '0' && *cur <= '9') {
138        width = width * 10 + *cur++ - '0';
139      }
140    }
141    bool have_precision = (cur[0] == '.' && cur[1] == '*');
142    int precision = -1;
143    if (have_precision) {
144      cur += 2;
145      precision = va_arg(args, int);
146    }
147    bool have_z = (*cur == 'z');
148    cur += have_z;
149    bool have_ll = !have_z && (cur[0] == 'l' && cur[1] == 'l');
150    cur += have_ll * 2;
151    s64 dval;
152    u64 uval;
153    bool have_flags = have_width | have_z | have_ll;
154    // Only %s supports precision for now
155    CHECK(!(precision >= 0 && *cur != 's'));
156    switch (*cur) {
157      case 'd': {
158        dval = have_ll ? va_arg(args, s64)
159             : have_z ? va_arg(args, sptr)
160             : va_arg(args, int);
161        result += AppendSignedDecimal(&buff, buff_end, dval, width,
162                                      pad_with_zero);
163        break;
164      }
165      case 'u':
166      case 'x': {
167        uval = have_ll ? va_arg(args, u64)
168             : have_z ? va_arg(args, uptr)
169             : va_arg(args, unsigned);
170        result += AppendUnsigned(&buff, buff_end, uval,
171                                 (*cur == 'u') ? 10 : 16, width, pad_with_zero);
172        break;
173      }
174      case 'p': {
175        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
176        result += AppendPointer(&buff, buff_end, va_arg(args, uptr));
177        break;
178      }
179      case 's': {
180        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
181        result += AppendString(&buff, buff_end, precision, va_arg(args, char*));
182        break;
183      }
184      case 'c': {
185        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
186        result += AppendChar(&buff, buff_end, va_arg(args, int));
187        break;
188      }
189      case '%' : {
190        RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
191        result += AppendChar(&buff, buff_end, '%');
192        break;
193      }
194      default: {
195        RAW_CHECK_MSG(false, kPrintfFormatsHelp);
196      }
197    }
198  }
199  RAW_CHECK(buff <= buff_end);
200  AppendChar(&buff, buff_end + 1, '\0');
201  return result;
202}
203
204static void (*PrintfAndReportCallback)(const char *);
205void SetPrintfAndReportCallback(void (*callback)(const char *)) {
206  PrintfAndReportCallback = callback;
207}
208
209// Can be overriden in frontend.
210#if SANITIZER_SUPPORTS_WEAK_HOOKS
211SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
212void OnPrint(const char *str) {
213  (void)str;
214}
215#elif defined(SANITIZER_GO) && defined(TSAN_EXTERNAL_HOOKS)
216void OnPrint(const char *str);
217#else
218void OnPrint(const char *str) {
219  (void)str;
220}
221#endif
222
223static void CallPrintfAndReportCallback(const char *str) {
224  OnPrint(str);
225  if (PrintfAndReportCallback)
226    PrintfAndReportCallback(str);
227}
228
229static void SharedPrintfCode(bool append_pid, const char *format,
230                             va_list args) {
231  va_list args2;
232  va_copy(args2, args);
233  const int kLen = 16 * 1024;
234  // |local_buffer| is small enough not to overflow the stack and/or violate
235  // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
236  // hand, the bigger the buffer is, the more the chance the error report will
237  // fit into it.
238  char local_buffer[400];
239  int needed_length;
240  char *buffer = local_buffer;
241  int buffer_size = ARRAY_SIZE(local_buffer);
242  // First try to print a message using a local buffer, and then fall back to
243  // mmaped buffer.
244  for (int use_mmap = 0; use_mmap < 2; use_mmap++) {
245    if (use_mmap) {
246      va_end(args);
247      va_copy(args, args2);
248      buffer = (char*)MmapOrDie(kLen, "Report");
249      buffer_size = kLen;
250    }
251    needed_length = 0;
252    if (append_pid) {
253      int pid = internal_getpid();
254      needed_length += internal_snprintf(buffer, buffer_size, "==%d==", pid);
255      if (needed_length >= buffer_size) {
256        // The pid doesn't fit into the current buffer.
257        if (!use_mmap)
258          continue;
259        RAW_CHECK_MSG(needed_length < kLen, "Buffer in Report is too short!\n");
260      }
261    }
262    needed_length += VSNPrintf(buffer + needed_length,
263                               buffer_size - needed_length, format, args);
264    if (needed_length >= buffer_size) {
265      // The message doesn't fit into the current buffer.
266      if (!use_mmap)
267        continue;
268      RAW_CHECK_MSG(needed_length < kLen, "Buffer in Report is too short!\n");
269    }
270    // If the message fit into the buffer, print it and exit.
271    break;
272  }
273  RawWrite(buffer);
274  AndroidLogWrite(buffer);
275  CallPrintfAndReportCallback(buffer);
276  // If we had mapped any memory, clean up.
277  if (buffer != local_buffer)
278    UnmapOrDie((void *)buffer, buffer_size);
279  va_end(args2);
280}
281
282FORMAT(1, 2)
283void Printf(const char *format, ...) {
284  va_list args;
285  va_start(args, format);
286  SharedPrintfCode(false, format, args);
287  va_end(args);
288}
289
290// Like Printf, but prints the current PID before the output string.
291FORMAT(1, 2)
292void Report(const char *format, ...) {
293  va_list args;
294  va_start(args, format);
295  SharedPrintfCode(true, format, args);
296  va_end(args);
297}
298
299// Writes at most "length" symbols to "buffer" (including trailing '\0').
300// Returns the number of symbols that should have been written to buffer
301// (not including trailing '\0'). Thus, the string is truncated
302// iff return value is not less than "length".
303FORMAT(3, 4)
304int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
305  va_list args;
306  va_start(args, format);
307  int needed_length = VSNPrintf(buffer, length, format, args);
308  va_end(args);
309  return needed_length;
310}
311
312FORMAT(2, 3)
313void InternalScopedString::append(const char *format, ...) {
314  CHECK_LT(length_, size());
315  va_list args;
316  va_start(args, format);
317  VSNPrintf(data() + length_, size() - length_, format, args);
318  va_end(args);
319  length_ += internal_strlen(data() + length_);
320  CHECK_LT(length_, size());
321}
322
323}  // namespace __sanitizer
324