1 //===-- sanitizer_printf.cpp ----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file is shared between AddressSanitizer and ThreadSanitizer.
10 //
11 // Internal printf function, used inside run-time libraries.
12 // We can't use libc printf because we intercept some of the functions used
13 // inside it.
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 
28 namespace __sanitizer {
29 
30 static int AppendChar(char **buff, const char *buff_end, char c) {
31   if (*buff < buff_end) {
32     **buff = c;
33     (*buff)++;
34   }
35   return 1;
36 }
37 
38 // Appends number in a given base to buffer. If its length is less than
39 // |minimal_num_length|, it is padded with leading zeroes or spaces, depending
40 // on the value of |pad_with_zero|.
41 static int AppendNumber(char **buff, const char *buff_end, u64 absolute_value,
42                         u8 base, u8 minimal_num_length, bool pad_with_zero,
43                         bool negative, bool uppercase) {
44   uptr const kMaxLen = 30;
45   RAW_CHECK(base == 10 || base == 16);
46   RAW_CHECK(base == 10 || !negative);
47   RAW_CHECK(absolute_value || !negative);
48   RAW_CHECK(minimal_num_length < kMaxLen);
49   int result = 0;
50   if (negative && minimal_num_length)
51     --minimal_num_length;
52   if (negative && pad_with_zero)
53     result += AppendChar(buff, buff_end, '-');
54   uptr num_buffer[kMaxLen];
55   int pos = 0;
56   do {
57     RAW_CHECK_MSG((uptr)pos < kMaxLen, "AppendNumber buffer overflow");
58     num_buffer[pos++] = absolute_value % base;
59     absolute_value /= base;
60   } while (absolute_value > 0);
61   if (pos < minimal_num_length) {
62     // Make sure compiler doesn't insert call to memset here.
63     internal_memset(&num_buffer[pos], 0,
64                     sizeof(num_buffer[0]) * (minimal_num_length - pos));
65     pos = minimal_num_length;
66   }
67   RAW_CHECK(pos > 0);
68   pos--;
69   for (; pos >= 0 && num_buffer[pos] == 0; pos--) {
70     char c = (pad_with_zero || pos == 0) ? '0' : ' ';
71     result += AppendChar(buff, buff_end, c);
72   }
73   if (negative && !pad_with_zero) result += AppendChar(buff, buff_end, '-');
74   for (; pos >= 0; pos--) {
75     char digit = static_cast<char>(num_buffer[pos]);
76     digit = (digit < 10) ? '0' + digit : (uppercase ? 'A' : 'a') + digit - 10;
77     result += AppendChar(buff, buff_end, digit);
78   }
79   return result;
80 }
81 
82 static int AppendUnsigned(char **buff, const char *buff_end, u64 num, u8 base,
83                           u8 minimal_num_length, bool pad_with_zero,
84                           bool uppercase) {
85   return AppendNumber(buff, buff_end, num, base, minimal_num_length,
86                       pad_with_zero, false /* negative */, uppercase);
87 }
88 
89 static int AppendSignedDecimal(char **buff, const char *buff_end, s64 num,
90                                u8 minimal_num_length, bool pad_with_zero) {
91   bool negative = (num < 0);
92   return AppendNumber(buff, buff_end, (u64)(negative ? -num : num), 10,
93                       minimal_num_length, pad_with_zero, negative,
94                       false /* uppercase */);
95 }
96 
97 
98 // Use the fact that explicitly requesting 0 width (%0s) results in UB and
99 // interpret width == 0 as "no width requested":
100 // width == 0 - no width requested
101 // width  < 0 - left-justify s within and pad it to -width chars, if necessary
102 // width  > 0 - right-justify s, not implemented yet
103 static int AppendString(char **buff, const char *buff_end, int width,
104                         int max_chars, const char *s) {
105   if (!s)
106     s = "<null>";
107   int result = 0;
108   for (; *s; s++) {
109     if (max_chars >= 0 && result >= max_chars)
110       break;
111     result += AppendChar(buff, buff_end, *s);
112   }
113   // Only the left justified strings are supported.
114   while (width < -result)
115     result += AppendChar(buff, buff_end, ' ');
116   return result;
117 }
118 
119 static int AppendPointer(char **buff, const char *buff_end, u64 ptr_value) {
120   int result = 0;
121   result += AppendString(buff, buff_end, 0, -1, "0x");
122   result += AppendUnsigned(buff, buff_end, ptr_value, 16,
123                            SANITIZER_POINTER_FORMAT_LENGTH,
124                            true /* pad_with_zero */, false /* uppercase */);
125   return result;
126 }
127 
128 int VSNPrintf(char *buff, int buff_length,
129               const char *format, va_list args) {
130   static const char *kPrintfFormatsHelp =
131       "Supported Printf formats: %([0-9]*)?(z|ll)?{d,u,x,X}; %p; "
132       "%[-]([0-9]*)?(\\.\\*)?s; %c\n";
133   RAW_CHECK(format);
134   RAW_CHECK(buff_length > 0);
135   const char *buff_end = &buff[buff_length - 1];
136   const char *cur = format;
137   int result = 0;
138   for (; *cur; cur++) {
139     if (*cur != '%') {
140       result += AppendChar(&buff, buff_end, *cur);
141       continue;
142     }
143     cur++;
144     bool left_justified = *cur == '-';
145     if (left_justified)
146       cur++;
147     bool have_width = (*cur >= '0' && *cur <= '9');
148     bool pad_with_zero = (*cur == '0');
149     int width = 0;
150     if (have_width) {
151       while (*cur >= '0' && *cur <= '9') {
152         width = width * 10 + *cur++ - '0';
153       }
154     }
155     bool have_precision = (cur[0] == '.' && cur[1] == '*');
156     int precision = -1;
157     if (have_precision) {
158       cur += 2;
159       precision = va_arg(args, int);
160     }
161     bool have_z = (*cur == 'z');
162     cur += have_z;
163     bool have_ll = !have_z && (cur[0] == 'l' && cur[1] == 'l');
164     cur += have_ll * 2;
165     s64 dval;
166     u64 uval;
167     const bool have_length = have_z || have_ll;
168     const bool have_flags = have_width || have_length;
169     // At the moment only %s supports precision and left-justification.
170     CHECK(!((precision >= 0 || left_justified) && *cur != 's'));
171     switch (*cur) {
172       case 'd': {
173         dval = have_ll ? va_arg(args, s64)
174              : have_z ? va_arg(args, sptr)
175              : va_arg(args, int);
176         result += AppendSignedDecimal(&buff, buff_end, dval, width,
177                                       pad_with_zero);
178         break;
179       }
180       case 'u':
181       case 'x':
182       case 'X': {
183         uval = have_ll ? va_arg(args, u64)
184              : have_z ? va_arg(args, uptr)
185              : va_arg(args, unsigned);
186         bool uppercase = (*cur == 'X');
187         result += AppendUnsigned(&buff, buff_end, uval, (*cur == 'u') ? 10 : 16,
188                                  width, pad_with_zero, uppercase);
189         break;
190       }
191       case 'p': {
192         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
193         result += AppendPointer(&buff, buff_end, va_arg(args, uptr));
194         break;
195       }
196       case 's': {
197         RAW_CHECK_MSG(!have_length, kPrintfFormatsHelp);
198         // Only left-justified width is supported.
199         CHECK(!have_width || left_justified);
200         result += AppendString(&buff, buff_end, left_justified ? -width : width,
201                                precision, va_arg(args, char*));
202         break;
203       }
204       case 'c': {
205         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
206         result += AppendChar(&buff, buff_end, va_arg(args, int));
207         break;
208       }
209       case '%' : {
210         RAW_CHECK_MSG(!have_flags, kPrintfFormatsHelp);
211         result += AppendChar(&buff, buff_end, '%');
212         break;
213       }
214       default: {
215         RAW_CHECK_MSG(false, kPrintfFormatsHelp);
216       }
217     }
218   }
219   RAW_CHECK(buff <= buff_end);
220   AppendChar(&buff, buff_end + 1, '\0');
221   return result;
222 }
223 
224 static void (*PrintfAndReportCallback)(const char *);
225 void SetPrintfAndReportCallback(void (*callback)(const char *)) {
226   PrintfAndReportCallback = callback;
227 }
228 
229 // Can be overriden in frontend.
230 #if SANITIZER_GO && defined(TSAN_EXTERNAL_HOOKS)
231 // Implementation must be defined in frontend.
232 // TODO(morehouse): Remove OnPrint after migrating Go to __sanitizer_on_print.
233 extern "C" void OnPrint(const char *str);
234 extern "C" void __sanitizer_on_print(const char *str);
235 #else
236 SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_on_print, const char *str) {
237   (void)str;
238 }
239 #endif
240 
241 static void CallPrintfAndReportCallback(const char *str) {
242 #if SANITIZER_GO && defined(TSAN_EXTERNAL_HOOKS)
243   // TODO(morehouse): Remove OnPrint after migrating Go to __sanitizer_on_print.
244   OnPrint(str);
245 #endif
246   __sanitizer_on_print(str);
247   if (PrintfAndReportCallback)
248     PrintfAndReportCallback(str);
249 }
250 
251 static void NOINLINE SharedPrintfCodeNoBuffer(bool append_pid,
252                                               char *local_buffer,
253                                               int buffer_size,
254                                               const char *format,
255                                               va_list args) {
256   va_list args2;
257   va_copy(args2, args);
258   const int kLen = 16 * 1024;
259   int needed_length;
260   char *buffer = local_buffer;
261   // First try to print a message using a local buffer, and then fall back to
262   // mmaped buffer.
263   for (int use_mmap = 0; use_mmap < 2; use_mmap++) {
264     if (use_mmap) {
265       va_end(args);
266       va_copy(args, args2);
267       buffer = (char*)MmapOrDie(kLen, "Report");
268       buffer_size = kLen;
269     }
270     needed_length = 0;
271     // Check that data fits into the current buffer.
272 #   define CHECK_NEEDED_LENGTH \
273       if (needed_length >= buffer_size) { \
274         if (!use_mmap) continue; \
275         RAW_CHECK_MSG(needed_length < kLen, \
276                       "Buffer in Report is too short!\n"); \
277       }
278     // Fuchsia's logging infrastructure always keeps track of the logging
279     // process, thread, and timestamp, so never prepend such information.
280     if (!SANITIZER_FUCHSIA && append_pid) {
281       int pid = internal_getpid();
282       const char *exe_name = GetProcessName();
283       if (common_flags()->log_exe_name && exe_name) {
284         needed_length += internal_snprintf(buffer, buffer_size,
285                                            "==%s", exe_name);
286         CHECK_NEEDED_LENGTH
287       }
288       needed_length += internal_snprintf(
289           buffer + needed_length, buffer_size - needed_length, "==%d==", pid);
290       CHECK_NEEDED_LENGTH
291     }
292     needed_length += VSNPrintf(buffer + needed_length,
293                                buffer_size - needed_length, format, args);
294     CHECK_NEEDED_LENGTH
295     // If the message fit into the buffer, print it and exit.
296     break;
297 #   undef CHECK_NEEDED_LENGTH
298   }
299   RawWrite(buffer);
300 
301   // Remove color sequences from the message.
302   RemoveANSIEscapeSequencesFromString(buffer);
303   CallPrintfAndReportCallback(buffer);
304   LogMessageOnPrintf(buffer);
305 
306   // If we had mapped any memory, clean up.
307   if (buffer != local_buffer)
308     UnmapOrDie((void *)buffer, buffer_size);
309   va_end(args2);
310 }
311 
312 static void NOINLINE SharedPrintfCode(bool append_pid, const char *format,
313                                       va_list args) {
314   // |local_buffer| is small enough not to overflow the stack and/or violate
315   // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other
316   // hand, the bigger the buffer is, the more the chance the error report will
317   // fit into it.
318   char local_buffer[400];
319   SharedPrintfCodeNoBuffer(append_pid, local_buffer, ARRAY_SIZE(local_buffer),
320                            format, args);
321 }
322 
323 FORMAT(1, 2)
324 void Printf(const char *format, ...) {
325   va_list args;
326   va_start(args, format);
327   SharedPrintfCode(false, format, args);
328   va_end(args);
329 }
330 
331 // Like Printf, but prints the current PID before the output string.
332 FORMAT(1, 2)
333 void Report(const char *format, ...) {
334   va_list args;
335   va_start(args, format);
336   SharedPrintfCode(true, format, args);
337   va_end(args);
338 }
339 
340 // Writes at most "length" symbols to "buffer" (including trailing '\0').
341 // Returns the number of symbols that should have been written to buffer
342 // (not including trailing '\0'). Thus, the string is truncated
343 // iff return value is not less than "length".
344 FORMAT(3, 4)
345 int internal_snprintf(char *buffer, uptr length, const char *format, ...) {
346   va_list args;
347   va_start(args, format);
348   int needed_length = VSNPrintf(buffer, length, format, args);
349   va_end(args);
350   return needed_length;
351 }
352 
353 FORMAT(2, 3)
354 void InternalScopedString::append(const char *format, ...) {
355   CHECK_LT(length_, size());
356   va_list args;
357   va_start(args, format);
358   VSNPrintf(data() + length_, size() - length_, format, args);
359   va_end(args);
360   length_ += internal_strlen(data() + length_);
361   CHECK_LT(length_, size());
362 }
363 
364 } // namespace __sanitizer
365