sanitizer_symbolizer_libcdep.cpp revision 360784
1174704Skmacy//===-- sanitizer_symbolizer_libcdep.cpp ----------------------------------===// 2174704Skmacy// 3174704Skmacy// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4174704Skmacy// See https://llvm.org/LICENSE.txt for license information. 5174704Skmacy// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6174704Skmacy// 7174704Skmacy//===----------------------------------------------------------------------===// 8174704Skmacy// 9174704Skmacy// This file is shared between AddressSanitizer and ThreadSanitizer 10174704Skmacy// run-time libraries. 11174704Skmacy//===----------------------------------------------------------------------===// 12174704Skmacy 13174704Skmacy#include "sanitizer_allocator_internal.h" 14174704Skmacy#include "sanitizer_internal_defs.h" 15174704Skmacy#include "sanitizer_symbolizer_internal.h" 16174704Skmacy 17174704Skmacynamespace __sanitizer { 18174704Skmacy 19174704SkmacySymbolizer *Symbolizer::GetOrInit() { 20174704Skmacy SpinMutexLock l(&init_mu_); 21174704Skmacy if (symbolizer_) 22174704Skmacy return symbolizer_; 23174704Skmacy symbolizer_ = PlatformInit(); 24174704Skmacy CHECK(symbolizer_); 25174704Skmacy return symbolizer_; 26174704Skmacy} 27174704Skmacy 28174704Skmacy// See sanitizer_symbolizer_markup.cpp. 29174704Skmacy#if !SANITIZER_SYMBOLIZER_MARKUP 30174704Skmacy 31174704Skmacyconst char *ExtractToken(const char *str, const char *delims, char **result) { 32174704Skmacy uptr prefix_len = internal_strcspn(str, delims); 33174704Skmacy *result = (char*)InternalAlloc(prefix_len + 1); 34174704Skmacy internal_memcpy(*result, str, prefix_len); 35174704Skmacy (*result)[prefix_len] = '\0'; 36174704Skmacy const char *prefix_end = str + prefix_len; 37174704Skmacy if (*prefix_end != '\0') prefix_end++; 38174704Skmacy return prefix_end; 39174704Skmacy} 40174704Skmacy 41174704Skmacyconst char *ExtractInt(const char *str, const char *delims, int *result) { 42174704Skmacy char *buff; 43174704Skmacy const char *ret = ExtractToken(str, delims, &buff); 44174704Skmacy if (buff != 0) { 45174704Skmacy *result = (int)internal_atoll(buff); 46174704Skmacy } 47174704Skmacy InternalFree(buff); 48174704Skmacy return ret; 49174704Skmacy} 50174704Skmacy 51174704Skmacyconst char *ExtractUptr(const char *str, const char *delims, uptr *result) { 52174704Skmacy char *buff; 53174704Skmacy const char *ret = ExtractToken(str, delims, &buff); 54174704Skmacy if (buff != 0) { 55174704Skmacy *result = (uptr)internal_atoll(buff); 56174704Skmacy } 57174704Skmacy InternalFree(buff); 58174704Skmacy return ret; 59174704Skmacy} 60174704Skmacy 61174704Skmacyconst char *ExtractSptr(const char *str, const char *delims, sptr *result) { 62174704Skmacy char *buff; 63174704Skmacy const char *ret = ExtractToken(str, delims, &buff); 64174704Skmacy if (buff != 0) { 65174704Skmacy *result = (sptr)internal_atoll(buff); 66174704Skmacy } 67174704Skmacy InternalFree(buff); 68174704Skmacy return ret; 69174704Skmacy} 70174704Skmacy 71174704Skmacyconst char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter, 72174704Skmacy char **result) { 73174704Skmacy const char *found_delimiter = internal_strstr(str, delimiter); 74174704Skmacy uptr prefix_len = 75174704Skmacy found_delimiter ? found_delimiter - str : internal_strlen(str); 76174704Skmacy *result = (char *)InternalAlloc(prefix_len + 1); 77174704Skmacy internal_memcpy(*result, str, prefix_len); 78174704Skmacy (*result)[prefix_len] = '\0'; 79174704Skmacy const char *prefix_end = str + prefix_len; 80174704Skmacy if (*prefix_end != '\0') prefix_end += internal_strlen(delimiter); 81174704Skmacy return prefix_end; 82174704Skmacy} 83174704Skmacy 84174704SkmacySymbolizedStack *Symbolizer::SymbolizePC(uptr addr) { 85174704Skmacy BlockingMutexLock l(&mu_); 86174704Skmacy const char *module_name; 87174704Skmacy uptr module_offset; 88174704Skmacy ModuleArch arch; 89174704Skmacy SymbolizedStack *res = SymbolizedStack::New(addr); 90174704Skmacy if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset, 91174704Skmacy &arch)) 92174704Skmacy return res; 93174704Skmacy // Always fill data about module name and offset. 94174704Skmacy res->info.FillModuleInfo(module_name, module_offset, arch); 95174704Skmacy for (auto &tool : tools_) { 96174704Skmacy SymbolizerScope sym_scope(this); 97174704Skmacy if (tool.SymbolizePC(addr, res)) { 98174704Skmacy return res; 99174704Skmacy } 100174704Skmacy } 101174704Skmacy return res; 102174704Skmacy} 103174704Skmacy 104174704Skmacybool Symbolizer::SymbolizeData(uptr addr, DataInfo *info) { 105174704Skmacy BlockingMutexLock l(&mu_); 106174704Skmacy const char *module_name; 107174704Skmacy uptr module_offset; 108174704Skmacy ModuleArch arch; 109174704Skmacy if (!FindModuleNameAndOffsetForAddress(addr, &module_name, &module_offset, 110174704Skmacy &arch)) 111174704Skmacy return false; 112174704Skmacy info->Clear(); 113174704Skmacy info->module = internal_strdup(module_name); 114174704Skmacy info->module_offset = module_offset; 115174704Skmacy info->module_arch = arch; 116174704Skmacy for (auto &tool : tools_) { 117174704Skmacy SymbolizerScope sym_scope(this); 118174704Skmacy if (tool.SymbolizeData(addr, info)) { 119174704Skmacy return true; 120174704Skmacy } 121174704Skmacy } 122174704Skmacy return true; 123174704Skmacy} 124174704Skmacy 125174704Skmacybool Symbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) { 126174704Skmacy BlockingMutexLock l(&mu_); 127174704Skmacy const char *module_name; 128174704Skmacy if (!FindModuleNameAndOffsetForAddress( 129174704Skmacy addr, &module_name, &info->module_offset, &info->module_arch)) 130174704Skmacy return false; 131174704Skmacy info->module = internal_strdup(module_name); 132174704Skmacy for (auto &tool : tools_) { 133174704Skmacy SymbolizerScope sym_scope(this); 134174704Skmacy if (tool.SymbolizeFrame(addr, info)) { 135174704Skmacy return true; 136174704Skmacy } 137174704Skmacy } 138174704Skmacy return true; 139174704Skmacy} 140174704Skmacy 141174704Skmacybool Symbolizer::GetModuleNameAndOffsetForPC(uptr pc, const char **module_name, 142174704Skmacy uptr *module_address) { 143174704Skmacy BlockingMutexLock l(&mu_); 144174704Skmacy const char *internal_module_name = nullptr; 145174704Skmacy ModuleArch arch; 146174704Skmacy if (!FindModuleNameAndOffsetForAddress(pc, &internal_module_name, 147174704Skmacy module_address, &arch)) 148174704Skmacy return false; 149174704Skmacy 150174704Skmacy if (module_name) 151174704Skmacy *module_name = module_names_.GetOwnedCopy(internal_module_name); 152174704Skmacy return true; 153174704Skmacy} 154174704Skmacy 155174704Skmacyvoid Symbolizer::Flush() { 156174704Skmacy BlockingMutexLock l(&mu_); 157174704Skmacy for (auto &tool : tools_) { 158174704Skmacy SymbolizerScope sym_scope(this); 159174704Skmacy tool.Flush(); 160174704Skmacy } 161174704Skmacy} 162174704Skmacy 163174704Skmacyconst char *Symbolizer::Demangle(const char *name) { 164174704Skmacy BlockingMutexLock l(&mu_); 165174704Skmacy for (auto &tool : tools_) { 166174704Skmacy SymbolizerScope sym_scope(this); 167174704Skmacy if (const char *demangled = tool.Demangle(name)) 168174704Skmacy return demangled; 169174704Skmacy } 170174704Skmacy return PlatformDemangle(name); 171174704Skmacy} 172174704Skmacy 173174704Skmacybool Symbolizer::FindModuleNameAndOffsetForAddress(uptr address, 174174704Skmacy const char **module_name, 175174704Skmacy uptr *module_offset, 176174704Skmacy ModuleArch *module_arch) { 177174704Skmacy const LoadedModule *module = FindModuleForAddress(address); 178174704Skmacy if (module == nullptr) 179174704Skmacy return false; 180174704Skmacy *module_name = module->full_name(); 181174704Skmacy *module_offset = address - module->base_address(); 182174704Skmacy *module_arch = module->arch(); 183174704Skmacy return true; 184174704Skmacy} 185174704Skmacy 186174704Skmacyvoid Symbolizer::RefreshModules() { 187195654Slstewart modules_.init(); 188195654Slstewart fallback_modules_.fallbackInit(); 189195654Slstewart RAW_CHECK(modules_.size() > 0); 190195654Slstewart modules_fresh_ = true; 191195654Slstewart} 192195654Slstewart 193195654Slstewartstatic const LoadedModule *SearchForModule(const ListOfModules &modules, 194195654Slstewart uptr address) { 195195654Slstewart for (uptr i = 0; i < modules.size(); i++) { 196195654Slstewart if (modules[i].containsAddress(address)) { 197195654Slstewart return &modules[i]; 198195654Slstewart } 199195654Slstewart } 200174704Skmacy return nullptr; 201174704Skmacy} 202174704Skmacy 203174704Skmacyconst LoadedModule *Symbolizer::FindModuleForAddress(uptr address) { 204174704Skmacy bool modules_were_reloaded = false; 205174704Skmacy if (!modules_fresh_) { 206174704Skmacy RefreshModules(); 207174704Skmacy modules_were_reloaded = true; 208174704Skmacy } 209174704Skmacy const LoadedModule *module = SearchForModule(modules_, address); 210174704Skmacy if (module) return module; 211174704Skmacy 212174704Skmacy // dlopen/dlclose interceptors invalidate the module list, but when 213174704Skmacy // interception is disabled, we need to retry if the lookup fails in 214174704Skmacy // case the module list changed. 215174704Skmacy#if !SANITIZER_INTERCEPT_DLOPEN_DLCLOSE 216174704Skmacy if (!modules_were_reloaded) { 217174704Skmacy RefreshModules(); 218174704Skmacy module = SearchForModule(modules_, address); 219174704Skmacy if (module) return module; 220174704Skmacy } 221174704Skmacy#endif 222174704Skmacy 223174704Skmacy if (fallback_modules_.size()) { 224174704Skmacy module = SearchForModule(fallback_modules_, address); 225174704Skmacy } 226174704Skmacy return module; 227174704Skmacy} 228174704Skmacy 229174704Skmacy// For now we assume the following protocol: 230174704Skmacy// For each request of the form 231174704Skmacy// <module_name> <module_offset> 232174757Skmacy// passed to STDIN, external symbolizer prints to STDOUT response: 233174757Skmacy// <function_name> 234174757Skmacy// <file_name>:<line_number>:<column_number> 235174757Skmacy// <function_name> 236174704Skmacy// <file_name>:<line_number>:<column_number> 237174704Skmacy// ... 238174704Skmacy// <empty line> 239174704Skmacyclass LLVMSymbolizerProcess : public SymbolizerProcess { 240174704Skmacy public: 241174704Skmacy explicit LLVMSymbolizerProcess(const char *path) 242174704Skmacy : SymbolizerProcess(path, /*use_posix_spawn=*/SANITIZER_MAC) {} 243174704Skmacy 244174704Skmacy private: 245178302Skmacy bool ReachedEndOfOutput(const char *buffer, uptr length) const override { 246174704Skmacy // Empty line marks the end of llvm-symbolizer output. 247178302Skmacy return length >= 2 && buffer[length - 1] == '\n' && 248178302Skmacy buffer[length - 2] == '\n'; 249178302Skmacy } 250178302Skmacy 251178302Skmacy // When adding a new architecture, don't forget to also update 252174704Skmacy // script/asan_symbolize.py and sanitizer_common.h. 253174704Skmacy void GetArgV(const char *path_to_binary, 254174704Skmacy const char *(&argv)[kArgVMax]) const override { 255174704Skmacy#if defined(__x86_64h__) 256174704Skmacy const char* const kSymbolizerArch = "--default-arch=x86_64h"; 257174757Skmacy#elif defined(__x86_64__) 258174704Skmacy const char* const kSymbolizerArch = "--default-arch=x86_64"; 259174704Skmacy#elif defined(__i386__) 260174704Skmacy const char* const kSymbolizerArch = "--default-arch=i386"; 261174704Skmacy#elif defined(__aarch64__) 262174704Skmacy const char* const kSymbolizerArch = "--default-arch=arm64"; 263174704Skmacy#elif defined(__arm__) 264174704Skmacy const char* const kSymbolizerArch = "--default-arch=arm"; 265174704Skmacy#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ 266174704Skmacy const char* const kSymbolizerArch = "--default-arch=powerpc64"; 267174704Skmacy#elif defined(__powerpc64__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 268174704Skmacy const char* const kSymbolizerArch = "--default-arch=powerpc64le"; 269174704Skmacy#elif defined(__s390x__) 270174704Skmacy const char* const kSymbolizerArch = "--default-arch=s390x"; 271174704Skmacy#elif defined(__s390__) 272174704Skmacy const char* const kSymbolizerArch = "--default-arch=s390"; 273174704Skmacy#else 274174704Skmacy const char* const kSymbolizerArch = "--default-arch=unknown"; 275174757Skmacy#endif 276174704Skmacy 277174704Skmacy const char *const inline_flag = common_flags()->symbolize_inline_frames 278174704Skmacy ? "--inlining=true" 279174704Skmacy : "--inlining=false"; 280174704Skmacy int i = 0; 281174704Skmacy argv[i++] = path_to_binary; 282174704Skmacy argv[i++] = inline_flag; 283174704Skmacy argv[i++] = kSymbolizerArch; 284174704Skmacy argv[i++] = nullptr; 285174704Skmacy } 286174757Skmacy}; 287174704Skmacy 288174704SkmacyLLVMSymbolizer::LLVMSymbolizer(const char *path, LowLevelAllocator *allocator) 289174704Skmacy : symbolizer_process_(new(*allocator) LLVMSymbolizerProcess(path)) {} 290174704Skmacy 291174704Skmacy// Parse a <file>:<line>[:<column>] buffer. The file path may contain colons on 292174704Skmacy// Windows, so extract tokens from the right hand side first. The column info is 293174704Skmacy// also optional. 294174704Skmacystatic const char *ParseFileLineInfo(AddressInfo *info, const char *str) { 295174704Skmacy char *file_line_info = 0; 296174704Skmacy str = ExtractToken(str, "\n", &file_line_info); 297174757Skmacy CHECK(file_line_info); 298174704Skmacy 299174704Skmacy if (uptr size = internal_strlen(file_line_info)) { 300174704Skmacy char *back = file_line_info + size - 1; 301174704Skmacy for (int i = 0; i < 2; ++i) { 302174704Skmacy while (back > file_line_info && IsDigit(*back)) --back; 303174704Skmacy if (*back != ':' || !IsDigit(back[1])) break; 304174704Skmacy info->column = info->line; 305174704Skmacy info->line = internal_atoll(back + 1); 306174704Skmacy // Truncate the string at the colon to keep only filename. 307174704Skmacy *back = '\0'; 308174757Skmacy --back; 309174704Skmacy } 310174704Skmacy ExtractToken(file_line_info, "", &info->file); 311174704Skmacy } 312174704Skmacy 313174704Skmacy InternalFree(file_line_info); 314174704Skmacy return str; 315174704Skmacy} 316174704Skmacy 317174704Skmacy// Parses one or more two-line strings in the following format: 318174704Skmacy// <function_name> 319174757Skmacy// <file_name>:<line_number>[:<column_number>] 320174704Skmacy// Used by LLVMSymbolizer, Addr2LinePool and InternalSymbolizer, since all of 321174704Skmacy// them use the same output format. 322174704Skmacyvoid ParseSymbolizePCOutput(const char *str, SymbolizedStack *res) { 323174704Skmacy bool top_frame = true; 324174704Skmacy SymbolizedStack *last = res; 325174704Skmacy while (true) { 326174704Skmacy char *function_name = 0; 327174704Skmacy str = ExtractToken(str, "\n", &function_name); 328174704Skmacy CHECK(function_name); 329174757Skmacy if (function_name[0] == '\0') { 330174704Skmacy // There are no more frames. 331174704Skmacy InternalFree(function_name); 332174704Skmacy break; 333174704Skmacy } 334174704Skmacy SymbolizedStack *cur; 335174704Skmacy if (top_frame) { 336174704Skmacy cur = res; 337174704Skmacy top_frame = false; 338174704Skmacy } else { 339174757Skmacy cur = SymbolizedStack::New(res->info.address); 340174704Skmacy cur->info.FillModuleInfo(res->info.module, res->info.module_offset, 341174704Skmacy res->info.module_arch); 342174704Skmacy last->next = cur; 343174704Skmacy last = cur; 344174704Skmacy } 345174704Skmacy 346178302Skmacy AddressInfo *info = &cur->info; 347178302Skmacy info->function = function_name; 348174704Skmacy str = ParseFileLineInfo(info, str); 349180648Skmacy 350180648Skmacy // Functions and filenames can be "??", in which case we write 0 351180648Skmacy // to address info to mark that names are unknown. 352180648Skmacy if (0 == internal_strcmp(info->function, "??")) { 353180648Skmacy InternalFree(info->function); 354174704Skmacy info->function = 0; 355 } 356 if (0 == internal_strcmp(info->file, "??")) { 357 InternalFree(info->file); 358 info->file = 0; 359 } 360 } 361} 362 363// Parses a two-line string in the following format: 364// <symbol_name> 365// <start_address> <size> 366// Used by LLVMSymbolizer and InternalSymbolizer. 367void ParseSymbolizeDataOutput(const char *str, DataInfo *info) { 368 str = ExtractToken(str, "\n", &info->name); 369 str = ExtractUptr(str, " ", &info->start); 370 str = ExtractUptr(str, "\n", &info->size); 371} 372 373static void ParseSymbolizeFrameOutput(const char *str, 374 InternalMmapVector<LocalInfo> *locals) { 375 if (internal_strncmp(str, "??", 2) == 0) 376 return; 377 378 while (*str) { 379 LocalInfo local; 380 str = ExtractToken(str, "\n", &local.function_name); 381 str = ExtractToken(str, "\n", &local.name); 382 383 AddressInfo addr; 384 str = ParseFileLineInfo(&addr, str); 385 local.decl_file = addr.file; 386 local.decl_line = addr.line; 387 388 local.has_frame_offset = internal_strncmp(str, "??", 2) != 0; 389 str = ExtractSptr(str, " ", &local.frame_offset); 390 391 local.has_size = internal_strncmp(str, "??", 2) != 0; 392 str = ExtractUptr(str, " ", &local.size); 393 394 local.has_tag_offset = internal_strncmp(str, "??", 2) != 0; 395 str = ExtractUptr(str, "\n", &local.tag_offset); 396 397 locals->push_back(local); 398 } 399} 400 401bool LLVMSymbolizer::SymbolizePC(uptr addr, SymbolizedStack *stack) { 402 AddressInfo *info = &stack->info; 403 const char *buf = FormatAndSendCommand( 404 "CODE", info->module, info->module_offset, info->module_arch); 405 if (buf) { 406 ParseSymbolizePCOutput(buf, stack); 407 return true; 408 } 409 return false; 410} 411 412bool LLVMSymbolizer::SymbolizeData(uptr addr, DataInfo *info) { 413 const char *buf = FormatAndSendCommand( 414 "DATA", info->module, info->module_offset, info->module_arch); 415 if (buf) { 416 ParseSymbolizeDataOutput(buf, info); 417 info->start += (addr - info->module_offset); // Add the base address. 418 return true; 419 } 420 return false; 421} 422 423bool LLVMSymbolizer::SymbolizeFrame(uptr addr, FrameInfo *info) { 424 const char *buf = FormatAndSendCommand( 425 "FRAME", info->module, info->module_offset, info->module_arch); 426 if (buf) { 427 ParseSymbolizeFrameOutput(buf, &info->locals); 428 return true; 429 } 430 return false; 431} 432 433const char *LLVMSymbolizer::FormatAndSendCommand(const char *command_prefix, 434 const char *module_name, 435 uptr module_offset, 436 ModuleArch arch) { 437 CHECK(module_name); 438 if (arch == kModuleArchUnknown) { 439 if (internal_snprintf(buffer_, kBufferSize, "%s \"%s\" 0x%zx\n", 440 command_prefix, module_name, 441 module_offset) >= static_cast<int>(kBufferSize)) { 442 Report("WARNING: Command buffer too small"); 443 return nullptr; 444 } 445 } else { 446 if (internal_snprintf(buffer_, kBufferSize, "%s \"%s:%s\" 0x%zx\n", 447 command_prefix, module_name, ModuleArchToString(arch), 448 module_offset) >= static_cast<int>(kBufferSize)) { 449 Report("WARNING: Command buffer too small"); 450 return nullptr; 451 } 452 } 453 return symbolizer_process_->SendCommand(buffer_); 454} 455 456SymbolizerProcess::SymbolizerProcess(const char *path, bool use_posix_spawn) 457 : path_(path), 458 input_fd_(kInvalidFd), 459 output_fd_(kInvalidFd), 460 times_restarted_(0), 461 failed_to_start_(false), 462 reported_invalid_path_(false), 463 use_posix_spawn_(use_posix_spawn) { 464 CHECK(path_); 465 CHECK_NE(path_[0], '\0'); 466} 467 468static bool IsSameModule(const char* path) { 469 if (const char* ProcessName = GetProcessName()) { 470 if (const char* SymbolizerName = StripModuleName(path)) { 471 return !internal_strcmp(ProcessName, SymbolizerName); 472 } 473 } 474 return false; 475} 476 477const char *SymbolizerProcess::SendCommand(const char *command) { 478 if (failed_to_start_) 479 return nullptr; 480 if (IsSameModule(path_)) { 481 Report("WARNING: Symbolizer was blocked from starting itself!\n"); 482 failed_to_start_ = true; 483 return nullptr; 484 } 485 for (; times_restarted_ < kMaxTimesRestarted; times_restarted_++) { 486 // Start or restart symbolizer if we failed to send command to it. 487 if (const char *res = SendCommandImpl(command)) 488 return res; 489 Restart(); 490 } 491 if (!failed_to_start_) { 492 Report("WARNING: Failed to use and restart external symbolizer!\n"); 493 failed_to_start_ = true; 494 } 495 return 0; 496} 497 498const char *SymbolizerProcess::SendCommandImpl(const char *command) { 499 if (input_fd_ == kInvalidFd || output_fd_ == kInvalidFd) 500 return 0; 501 if (!WriteToSymbolizer(command, internal_strlen(command))) 502 return 0; 503 if (!ReadFromSymbolizer(buffer_, kBufferSize)) 504 return 0; 505 return buffer_; 506} 507 508bool SymbolizerProcess::Restart() { 509 if (input_fd_ != kInvalidFd) 510 CloseFile(input_fd_); 511 if (output_fd_ != kInvalidFd) 512 CloseFile(output_fd_); 513 return StartSymbolizerSubprocess(); 514} 515 516bool SymbolizerProcess::ReadFromSymbolizer(char *buffer, uptr max_length) { 517 if (max_length == 0) 518 return true; 519 uptr read_len = 0; 520 while (true) { 521 uptr just_read = 0; 522 bool success = ReadFromFile(input_fd_, buffer + read_len, 523 max_length - read_len - 1, &just_read); 524 // We can't read 0 bytes, as we don't expect external symbolizer to close 525 // its stdout. 526 if (!success || just_read == 0) { 527 Report("WARNING: Can't read from symbolizer at fd %d\n", input_fd_); 528 return false; 529 } 530 read_len += just_read; 531 if (ReachedEndOfOutput(buffer, read_len)) 532 break; 533 if (read_len + 1 == max_length) { 534 Report("WARNING: Symbolizer buffer too small\n"); 535 read_len = 0; 536 break; 537 } 538 } 539 buffer[read_len] = '\0'; 540 return true; 541} 542 543bool SymbolizerProcess::WriteToSymbolizer(const char *buffer, uptr length) { 544 if (length == 0) 545 return true; 546 uptr write_len = 0; 547 bool success = WriteToFile(output_fd_, buffer, length, &write_len); 548 if (!success || write_len != length) { 549 Report("WARNING: Can't write to symbolizer at fd %d\n", output_fd_); 550 return false; 551 } 552 return true; 553} 554 555#endif // !SANITIZER_SYMBOLIZER_MARKUP 556 557} // namespace __sanitizer 558