369 lines · cpp
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-exception6//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 used13// 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#endif27 28namespace __sanitizer {29 30static 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 than39// |minimal_num_length|, it is padded with leading zeroes or spaces, depending40// on the value of |pad_with_zero|.41static 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 82static 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 89static 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 and99// interpret width == 0 as "no width requested":100// width == 0 - no width requested101// width < 0 - left-justify s within and pad it to -width chars, if necessary102// width > 0 - right-justify s, not implemented yet103static 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 119static 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 128int 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|l|ll)?{d,u,x,X}; %p; "132 "%[-]([0-9]*)?(\\.\\*)?s; %c\nProvided format: ";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_l = cur[0] == 'l' && cur[1] != 'l';164 cur += have_l;165 bool have_ll = cur[0] == 'l' && cur[1] == 'l';166 cur += have_ll * 2;167 const bool have_length = have_z || have_l || 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 s64 dval = have_ll ? va_arg(args, s64)174 : have_z ? va_arg(args, sptr)175 : have_l ? va_arg(args, long)176 : va_arg(args, int);177 result += AppendSignedDecimal(&buff, buff_end, dval, width,178 pad_with_zero);179 break;180 }181 case 'u':182 case 'x':183 case 'X': {184 u64 uval = have_ll ? va_arg(args, u64)185 : have_z ? va_arg(args, uptr)186 : have_l ? va_arg(args, unsigned long)187 : va_arg(args, unsigned);188 bool uppercase = (*cur == 'X');189 result += AppendUnsigned(&buff, buff_end, uval, (*cur == 'u') ? 10 : 16,190 width, pad_with_zero, uppercase);191 break;192 }193 case 'p': {194 RAW_CHECK_VA(!have_flags, kPrintfFormatsHelp, format);195 result += AppendPointer(&buff, buff_end, va_arg(args, uptr));196 break;197 }198 case 's': {199 RAW_CHECK_VA(!have_length, kPrintfFormatsHelp, format);200 // Only left-justified width is supported.201 CHECK(!have_width || left_justified);202 result += AppendString(&buff, buff_end, left_justified ? -width : width,203 precision, va_arg(args, char*));204 break;205 }206 case 'c': {207 RAW_CHECK_VA(!have_flags, kPrintfFormatsHelp, format);208 result += AppendChar(&buff, buff_end, va_arg(args, int));209 break;210 }211 case '%' : {212 RAW_CHECK_VA(!have_flags, kPrintfFormatsHelp, format);213 result += AppendChar(&buff, buff_end, '%');214 break;215 }216 default: {217 RAW_CHECK_VA(false, kPrintfFormatsHelp, format);218 }219 }220 }221 RAW_CHECK(buff <= buff_end);222 AppendChar(&buff, buff_end + 1, '\0');223 return result;224}225 226static void (*PrintfAndReportCallback)(const char *);227void SetPrintfAndReportCallback(void (*callback)(const char *)) {228 PrintfAndReportCallback = callback;229}230 231// Can be overriden in frontend.232#if SANITIZER_GO && defined(TSAN_EXTERNAL_HOOKS)233// Implementation must be defined in frontend.234extern "C" void __sanitizer_on_print(const char *str);235#else236SANITIZER_INTERFACE_WEAK_DEF(void, __sanitizer_on_print, const char *str) {237 (void)str;238}239#endif240 241static void CallPrintfAndReportCallback(const char *str) {242 __sanitizer_on_print(str);243 if (PrintfAndReportCallback)244 PrintfAndReportCallback(str);245}246 247static void NOINLINE SharedPrintfCodeNoBuffer(bool append_pid,248 char *local_buffer,249 int buffer_size,250 const char *format,251 va_list args) {252 va_list args2;253 va_copy(args2, args);254 InternalMmapVector<char> v;255 int needed_length = 0;256 char *buffer = local_buffer;257 // First try to print a message using a local buffer, and then fall back to258 // mmaped buffer.259 for (int use_mmap = 0;; use_mmap++) {260 if (use_mmap) {261 va_end(args);262 va_copy(args, args2);263 v.resize(needed_length + 1);264 buffer_size = v.capacity();265 v.resize(buffer_size);266 buffer = &v[0];267 }268 needed_length = 0;269 // Fuchsia's logging infrastructure always keeps track of the logging270 // process, thread, and timestamp, so never prepend such information.271 if (!SANITIZER_FUCHSIA && append_pid) {272 int pid = internal_getpid();273 const char *exe_name = GetProcessName();274 if (common_flags()->log_exe_name && exe_name) {275 needed_length += internal_snprintf(buffer, buffer_size,276 "==%s", exe_name);277 if (needed_length >= buffer_size)278 continue;279 }280 needed_length += internal_snprintf(281 buffer + needed_length, buffer_size - needed_length, "==%d==", pid);282 if (needed_length >= buffer_size)283 continue;284 }285 needed_length += VSNPrintf(buffer + needed_length,286 buffer_size - needed_length, format, args);287 if (needed_length >= buffer_size)288 continue;289 // If the message fit into the buffer, print it and exit.290 break;291 }292 RawWrite(buffer);293 294 // Remove color sequences from the message.295 RemoveANSIEscapeSequencesFromString(buffer);296 CallPrintfAndReportCallback(buffer);297 LogMessageOnPrintf(buffer);298 299 va_end(args2);300}301 302static void NOINLINE SharedPrintfCode(bool append_pid, const char *format,303 va_list args) {304 // |local_buffer| is small enough not to overflow the stack and/or violate305 // the stack limit enforced by TSan (-Wframe-larger-than=512). On the other306 // hand, the bigger the buffer is, the more the chance the error report will307 // fit into it.308 char local_buffer[400];309 SharedPrintfCodeNoBuffer(append_pid, local_buffer, ARRAY_SIZE(local_buffer),310 format, args);311}312 313void Printf(const char *format, ...) {314 va_list args;315 va_start(args, format);316 SharedPrintfCode(false, format, args);317 va_end(args);318}319 320// Like Printf, but prints the current PID before the output string.321void Report(const char *format, ...) {322 va_list args;323 va_start(args, format);324 SharedPrintfCode(true, format, args);325 va_end(args);326}327 328// Writes at most "length" symbols to "buffer" (including trailing '\0').329// Returns the number of symbols that should have been written to buffer330// (not including trailing '\0'). Thus, the string is truncated331// iff return value is not less than "length".332int internal_snprintf(char *buffer, uptr length, const char *format, ...) {333 va_list args;334 va_start(args, format);335 int needed_length = VSNPrintf(buffer, length, format, args);336 va_end(args);337 return needed_length;338}339 340void InternalScopedString::Append(const char *str) {341 uptr prev_len = length();342 uptr str_len = internal_strlen(str);343 buffer_.resize(prev_len + str_len + 1);344 internal_memcpy(buffer_.data() + prev_len, str, str_len + 1);345}346 347void InternalScopedString::AppendF(const char *format, ...) {348 uptr prev_len = length();349 350 while (true) {351 buffer_.resize(buffer_.capacity());352 353 va_list args;354 va_start(args, format);355 uptr sz = VSNPrintf(buffer_.data() + prev_len, buffer_.size() - prev_len,356 format, args);357 va_end(args);358 if (sz < buffer_.size() - prev_len) {359 buffer_.resize(prev_len + sz + 1);360 break;361 }362 363 buffer_.reserve(buffer_.capacity() * 2);364 }365 CHECK_EQ(buffer_[length()], '\0');366}367 368} // namespace __sanitizer369