| //===-- xray_log_interface.cc ---------------------------------------------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file is a part of XRay, a function call tracing system. |
| // |
| //===----------------------------------------------------------------------===// |
| #include "xray/xray_log_interface.h" |
| |
| #include "sanitizer_common/sanitizer_allocator_internal.h" |
| #include "sanitizer_common/sanitizer_atomic.h" |
| #include "sanitizer_common/sanitizer_mutex.h" |
| #include "xray/xray_interface.h" |
| #include "xray_defs.h" |
| |
| namespace __xray { |
| static SpinMutex XRayImplMutex; |
| static XRayLogImpl CurrentXRayImpl{nullptr, nullptr, nullptr, nullptr}; |
| static XRayLogImpl *GlobalXRayImpl = nullptr; |
| |
| // This is the default implementation of a buffer iterator, which always yields |
| // a null buffer. |
| XRayBuffer NullBufferIterator(XRayBuffer) XRAY_NEVER_INSTRUMENT { |
| return {nullptr, 0}; |
| } |
| |
| // This is the global function responsible for iterating through given buffers. |
| atomic_uintptr_t XRayBufferIterator{ |
| reinterpret_cast<uintptr_t>(&NullBufferIterator)}; |
| |
| // We use a linked list of Mode to XRayLogImpl mappings. This is a linked list |
| // when it should be a map because we're avoiding having to depend on C++ |
| // standard library data structures at this level of the implementation. |
| struct ModeImpl { |
| ModeImpl *Next; |
| const char *Mode; |
| XRayLogImpl Impl; |
| }; |
| |
| static ModeImpl SentinelModeImpl{ |
| nullptr, nullptr, {nullptr, nullptr, nullptr, nullptr}}; |
| static ModeImpl *ModeImpls = &SentinelModeImpl; |
| static const ModeImpl *CurrentMode = nullptr; |
| |
| } // namespace __xray |
| |
| using namespace __xray; |
| |
| void __xray_log_set_buffer_iterator(XRayBuffer (*Iterator)(XRayBuffer)) |
| XRAY_NEVER_INSTRUMENT { |
| atomic_store(&__xray::XRayBufferIterator, |
| reinterpret_cast<uintptr_t>(Iterator), memory_order_release); |
| } |
| |
| void __xray_log_remove_buffer_iterator() XRAY_NEVER_INSTRUMENT { |
| __xray_log_set_buffer_iterator(&NullBufferIterator); |
| } |
| |
| XRayLogRegisterStatus |
| __xray_log_register_mode(const char *Mode, |
| XRayLogImpl Impl) XRAY_NEVER_INSTRUMENT { |
| if (Impl.flush_log == nullptr || Impl.handle_arg0 == nullptr || |
| Impl.log_finalize == nullptr || Impl.log_init == nullptr) |
| return XRayLogRegisterStatus::XRAY_INCOMPLETE_IMPL; |
| |
| SpinMutexLock Guard(&XRayImplMutex); |
| // First, look for whether the mode already has a registered implementation. |
| for (ModeImpl *it = ModeImpls; it != &SentinelModeImpl; it = it->Next) { |
| if (!internal_strcmp(Mode, it->Mode)) |
| return XRayLogRegisterStatus::XRAY_DUPLICATE_MODE; |
| } |
| auto *NewModeImpl = static_cast<ModeImpl *>(InternalAlloc(sizeof(ModeImpl))); |
| NewModeImpl->Next = ModeImpls; |
| NewModeImpl->Mode = internal_strdup(Mode); |
| NewModeImpl->Impl = Impl; |
| ModeImpls = NewModeImpl; |
| return XRayLogRegisterStatus::XRAY_REGISTRATION_OK; |
| } |
| |
| XRayLogRegisterStatus |
| __xray_log_select_mode(const char *Mode) XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| for (ModeImpl *it = ModeImpls; it != &SentinelModeImpl; it = it->Next) { |
| if (!internal_strcmp(Mode, it->Mode)) { |
| CurrentMode = it; |
| CurrentXRayImpl = it->Impl; |
| GlobalXRayImpl = &CurrentXRayImpl; |
| __xray_set_handler(it->Impl.handle_arg0); |
| return XRayLogRegisterStatus::XRAY_REGISTRATION_OK; |
| } |
| } |
| return XRayLogRegisterStatus::XRAY_MODE_NOT_FOUND; |
| } |
| |
| const char *__xray_log_get_current_mode() XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| if (CurrentMode != nullptr) |
| return CurrentMode->Mode; |
| return nullptr; |
| } |
| |
| void __xray_set_log_impl(XRayLogImpl Impl) XRAY_NEVER_INSTRUMENT { |
| if (Impl.log_init == nullptr || Impl.log_finalize == nullptr || |
| Impl.handle_arg0 == nullptr || Impl.flush_log == nullptr) { |
| SpinMutexLock Guard(&XRayImplMutex); |
| GlobalXRayImpl = nullptr; |
| CurrentMode = nullptr; |
| __xray_remove_handler(); |
| __xray_remove_handler_arg1(); |
| return; |
| } |
| |
| SpinMutexLock Guard(&XRayImplMutex); |
| CurrentXRayImpl = Impl; |
| GlobalXRayImpl = &CurrentXRayImpl; |
| __xray_set_handler(Impl.handle_arg0); |
| } |
| |
| void __xray_remove_log_impl() XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| GlobalXRayImpl = nullptr; |
| __xray_remove_handler(); |
| __xray_remove_handler_arg1(); |
| } |
| |
| XRayLogInitStatus __xray_log_init(size_t BufferSize, size_t MaxBuffers, |
| void *Args, |
| size_t ArgsSize) XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| if (!GlobalXRayImpl) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| return GlobalXRayImpl->log_init(BufferSize, MaxBuffers, Args, ArgsSize); |
| } |
| |
| XRayLogInitStatus __xray_log_init_mode(const char *Mode, const char *Config) |
| XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| if (!GlobalXRayImpl) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| |
| if (Config == nullptr) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| |
| // Check first whether the current mode is the same as what we expect. |
| if (CurrentMode == nullptr || internal_strcmp(CurrentMode->Mode, Mode) != 0) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| |
| // Here we do some work to coerce the pointer we're provided, so that |
| // the implementations that still take void* pointers can handle the |
| // data provided in the Config argument. |
| return GlobalXRayImpl->log_init( |
| 0, 0, const_cast<void *>(static_cast<const void *>(Config)), 0); |
| } |
| |
| XRayLogInitStatus |
| __xray_log_init_mode_bin(const char *Mode, const char *Config, |
| size_t ConfigSize) XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| if (!GlobalXRayImpl) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| |
| if (Config == nullptr) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| |
| // Check first whether the current mode is the same as what we expect. |
| if (CurrentMode == nullptr || internal_strcmp(CurrentMode->Mode, Mode) != 0) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| |
| // Here we do some work to coerce the pointer we're provided, so that |
| // the implementations that still take void* pointers can handle the |
| // data provided in the Config argument. |
| return GlobalXRayImpl->log_init( |
| 0, 0, const_cast<void *>(static_cast<const void *>(Config)), ConfigSize); |
| } |
| |
| XRayLogInitStatus __xray_log_finalize() XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| if (!GlobalXRayImpl) |
| return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; |
| return GlobalXRayImpl->log_finalize(); |
| } |
| |
| XRayLogFlushStatus __xray_log_flushLog() XRAY_NEVER_INSTRUMENT { |
| SpinMutexLock Guard(&XRayImplMutex); |
| if (!GlobalXRayImpl) |
| return XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING; |
| return GlobalXRayImpl->flush_log(); |
| } |
| |
| XRayLogFlushStatus __xray_log_process_buffers( |
| void (*Processor)(const char *, XRayBuffer)) XRAY_NEVER_INSTRUMENT { |
| // We want to make sure that there will be no changes to the global state for |
| // the log by synchronising on the XRayBufferIteratorMutex. |
| if (!GlobalXRayImpl) |
| return XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING; |
| auto Iterator = reinterpret_cast<XRayBuffer (*)(XRayBuffer)>( |
| atomic_load(&XRayBufferIterator, memory_order_acquire)); |
| auto Buffer = (*Iterator)(XRayBuffer{nullptr, 0}); |
| auto Mode = CurrentMode ? CurrentMode->Mode : nullptr; |
| while (Buffer.Data != nullptr) { |
| (*Processor)(Mode, Buffer); |
| Buffer = (*Iterator)(Buffer); |
| } |
| return XRayLogFlushStatus::XRAY_LOG_FLUSHED; |
| } |