1 //===-- xray_log_interface.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-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file is a part of XRay, a function call tracing system. 10 // 11 //===----------------------------------------------------------------------===// 12 #include "xray/xray_log_interface.h" 13 14 #include "sanitizer_common/sanitizer_allocator_internal.h" 15 #include "sanitizer_common/sanitizer_atomic.h" 16 #include "sanitizer_common/sanitizer_mutex.h" 17 #include "xray/xray_interface.h" 18 #include "xray_defs.h" 19 20 namespace __xray { 21 static SpinMutex XRayImplMutex; 22 static XRayLogImpl CurrentXRayImpl{nullptr, nullptr, nullptr, nullptr}; 23 static XRayLogImpl *GlobalXRayImpl = nullptr; 24 25 // This is the default implementation of a buffer iterator, which always yields 26 // a null buffer. 27 XRayBuffer NullBufferIterator(XRayBuffer) XRAY_NEVER_INSTRUMENT { 28 return {nullptr, 0}; 29 } 30 31 // This is the global function responsible for iterating through given buffers. 32 atomic_uintptr_t XRayBufferIterator{ 33 reinterpret_cast<uintptr_t>(&NullBufferIterator)}; 34 35 // We use a linked list of Mode to XRayLogImpl mappings. This is a linked list 36 // when it should be a map because we're avoiding having to depend on C++ 37 // standard library data structures at this level of the implementation. 38 struct ModeImpl { 39 ModeImpl *Next; 40 const char *Mode; 41 XRayLogImpl Impl; 42 }; 43 44 static ModeImpl SentinelModeImpl{ 45 nullptr, nullptr, {nullptr, nullptr, nullptr, nullptr}}; 46 static ModeImpl *ModeImpls = &SentinelModeImpl; 47 static const ModeImpl *CurrentMode = nullptr; 48 49 } // namespace __xray 50 51 using namespace __xray; 52 53 void __xray_log_set_buffer_iterator(XRayBuffer (*Iterator)(XRayBuffer)) 54 XRAY_NEVER_INSTRUMENT { 55 atomic_store(&__xray::XRayBufferIterator, 56 reinterpret_cast<uintptr_t>(Iterator), memory_order_release); 57 } 58 59 void __xray_log_remove_buffer_iterator() XRAY_NEVER_INSTRUMENT { 60 __xray_log_set_buffer_iterator(&NullBufferIterator); 61 } 62 63 XRayLogRegisterStatus 64 __xray_log_register_mode(const char *Mode, 65 XRayLogImpl Impl) XRAY_NEVER_INSTRUMENT { 66 if (Impl.flush_log == nullptr || Impl.handle_arg0 == nullptr || 67 Impl.log_finalize == nullptr || Impl.log_init == nullptr) 68 return XRayLogRegisterStatus::XRAY_INCOMPLETE_IMPL; 69 70 SpinMutexLock Guard(&XRayImplMutex); 71 // First, look for whether the mode already has a registered implementation. 72 for (ModeImpl *it = ModeImpls; it != &SentinelModeImpl; it = it->Next) { 73 if (!internal_strcmp(Mode, it->Mode)) 74 return XRayLogRegisterStatus::XRAY_DUPLICATE_MODE; 75 } 76 auto *NewModeImpl = static_cast<ModeImpl *>(InternalAlloc(sizeof(ModeImpl))); 77 NewModeImpl->Next = ModeImpls; 78 NewModeImpl->Mode = internal_strdup(Mode); 79 NewModeImpl->Impl = Impl; 80 ModeImpls = NewModeImpl; 81 return XRayLogRegisterStatus::XRAY_REGISTRATION_OK; 82 } 83 84 XRayLogRegisterStatus 85 __xray_log_select_mode(const char *Mode) XRAY_NEVER_INSTRUMENT { 86 SpinMutexLock Guard(&XRayImplMutex); 87 for (ModeImpl *it = ModeImpls; it != &SentinelModeImpl; it = it->Next) { 88 if (!internal_strcmp(Mode, it->Mode)) { 89 CurrentMode = it; 90 CurrentXRayImpl = it->Impl; 91 GlobalXRayImpl = &CurrentXRayImpl; 92 __xray_set_handler(it->Impl.handle_arg0); 93 return XRayLogRegisterStatus::XRAY_REGISTRATION_OK; 94 } 95 } 96 return XRayLogRegisterStatus::XRAY_MODE_NOT_FOUND; 97 } 98 99 const char *__xray_log_get_current_mode() XRAY_NEVER_INSTRUMENT { 100 SpinMutexLock Guard(&XRayImplMutex); 101 if (CurrentMode != nullptr) 102 return CurrentMode->Mode; 103 return nullptr; 104 } 105 106 void __xray_set_log_impl(XRayLogImpl Impl) XRAY_NEVER_INSTRUMENT { 107 if (Impl.log_init == nullptr || Impl.log_finalize == nullptr || 108 Impl.handle_arg0 == nullptr || Impl.flush_log == nullptr) { 109 SpinMutexLock Guard(&XRayImplMutex); 110 GlobalXRayImpl = nullptr; 111 CurrentMode = nullptr; 112 __xray_remove_handler(); 113 __xray_remove_handler_arg1(); 114 return; 115 } 116 117 SpinMutexLock Guard(&XRayImplMutex); 118 CurrentXRayImpl = Impl; 119 GlobalXRayImpl = &CurrentXRayImpl; 120 __xray_set_handler(Impl.handle_arg0); 121 } 122 123 void __xray_remove_log_impl() XRAY_NEVER_INSTRUMENT { 124 SpinMutexLock Guard(&XRayImplMutex); 125 GlobalXRayImpl = nullptr; 126 __xray_remove_handler(); 127 __xray_remove_handler_arg1(); 128 } 129 130 XRayLogInitStatus __xray_log_init(size_t BufferSize, size_t MaxBuffers, 131 void *Args, 132 size_t ArgsSize) XRAY_NEVER_INSTRUMENT { 133 SpinMutexLock Guard(&XRayImplMutex); 134 if (!GlobalXRayImpl) 135 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 136 return GlobalXRayImpl->log_init(BufferSize, MaxBuffers, Args, ArgsSize); 137 } 138 139 XRayLogInitStatus __xray_log_init_mode(const char *Mode, const char *Config) 140 XRAY_NEVER_INSTRUMENT { 141 SpinMutexLock Guard(&XRayImplMutex); 142 if (!GlobalXRayImpl) 143 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 144 145 if (Config == nullptr) 146 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 147 148 // Check first whether the current mode is the same as what we expect. 149 if (CurrentMode == nullptr || internal_strcmp(CurrentMode->Mode, Mode) != 0) 150 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 151 152 // Here we do some work to coerce the pointer we're provided, so that 153 // the implementations that still take void* pointers can handle the 154 // data provided in the Config argument. 155 return GlobalXRayImpl->log_init( 156 0, 0, const_cast<void *>(static_cast<const void *>(Config)), 0); 157 } 158 159 XRayLogInitStatus 160 __xray_log_init_mode_bin(const char *Mode, const char *Config, 161 size_t ConfigSize) XRAY_NEVER_INSTRUMENT { 162 SpinMutexLock Guard(&XRayImplMutex); 163 if (!GlobalXRayImpl) 164 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 165 166 if (Config == nullptr) 167 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 168 169 // Check first whether the current mode is the same as what we expect. 170 if (CurrentMode == nullptr || internal_strcmp(CurrentMode->Mode, Mode) != 0) 171 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 172 173 // Here we do some work to coerce the pointer we're provided, so that 174 // the implementations that still take void* pointers can handle the 175 // data provided in the Config argument. 176 return GlobalXRayImpl->log_init( 177 0, 0, const_cast<void *>(static_cast<const void *>(Config)), ConfigSize); 178 } 179 180 XRayLogInitStatus __xray_log_finalize() XRAY_NEVER_INSTRUMENT { 181 SpinMutexLock Guard(&XRayImplMutex); 182 if (!GlobalXRayImpl) 183 return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED; 184 return GlobalXRayImpl->log_finalize(); 185 } 186 187 XRayLogFlushStatus __xray_log_flushLog() XRAY_NEVER_INSTRUMENT { 188 SpinMutexLock Guard(&XRayImplMutex); 189 if (!GlobalXRayImpl) 190 return XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING; 191 return GlobalXRayImpl->flush_log(); 192 } 193 194 XRayLogFlushStatus __xray_log_process_buffers( 195 void (*Processor)(const char *, XRayBuffer)) XRAY_NEVER_INSTRUMENT { 196 // We want to make sure that there will be no changes to the global state for 197 // the log by synchronising on the XRayBufferIteratorMutex. 198 if (!GlobalXRayImpl) 199 return XRayLogFlushStatus::XRAY_LOG_NOT_FLUSHING; 200 auto Iterator = reinterpret_cast<XRayBuffer (*)(XRayBuffer)>( 201 atomic_load(&XRayBufferIterator, memory_order_acquire)); 202 auto Buffer = (*Iterator)(XRayBuffer{nullptr, 0}); 203 auto Mode = CurrentMode ? CurrentMode->Mode : nullptr; 204 while (Buffer.Data != nullptr) { 205 (*Processor)(Mode, Buffer); 206 Buffer = (*Iterator)(Buffer); 207 } 208 return XRayLogFlushStatus::XRAY_LOG_FLUSHED; 209 } 210