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