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