lib/ExecutionEngine/OProfileJIT/OProfileWrapper.cpp

   1 //===-- OProfileWrapper.cpp - OProfile JIT API Wrapper implementation -----===//
   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 implements the interface in OProfileWrapper.h. It is responsible
  10 // for loading the opagent dynamic library when the first call to an op_
  11 // function occurs.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/ExecutionEngine/OProfileWrapper.h"
  16 #include "llvm/ADT/SmallString.h"
  17 #include "llvm/Support/Debug.h"
  18 #include "llvm/Support/DynamicLibrary.h"
  19 #include "llvm/Support/Mutex.h"
  20 #include "llvm/Support/raw_ostream.h"
  21 #include <cstring>
  22 #include <dirent.h>
  23 #include <fcntl.h>
  24 #include <mutex>
  25 #include <stddef.h>
  26 #include <sys/stat.h>
  27 #include <unistd.h>
  28
  29 #define DEBUG_TYPE "oprofile-wrapper"
  30
  31 namespace {
  32
  33 // Global mutex to ensure a single thread initializes oprofile agent.
  34 llvm::sys::Mutex OProfileInitializationMutex;
  35
  36 } // anonymous namespace
  37
  38 namespace llvm {
  39
  40 OProfileWrapper::OProfileWrapper()
  41 : Agent(0),
  42   OpenAgentFunc(0),
  43   CloseAgentFunc(0),
  44   WriteNativeCodeFunc(0),
  45   WriteDebugLineInfoFunc(0),
  46   UnloadNativeCodeFunc(0),
  47   MajorVersionFunc(0),
  48   MinorVersionFunc(0),
  49   IsOProfileRunningFunc(0),
  50   Initialized(false) {
  51 }
  52
  53 bool OProfileWrapper::initialize() {
  54   using namespace llvm;
  55   using namespace llvm::sys;
  56
  57   std::lock_guard<sys::Mutex> Guard(OProfileInitializationMutex);
  58
  59   if (Initialized)
  60     return OpenAgentFunc != 0;
  61
  62   Initialized = true;
  63
  64   // If the oprofile daemon is not running, don't load the opagent library
  65   if (!isOProfileRunning()) {
  66     LLVM_DEBUG(dbgs() << "OProfile daemon is not detected.\n");
  67     return false;
  68   }
  69
  70   std::string error;
  71   if(!DynamicLibrary::LoadLibraryPermanently("libopagent.so", &error)) {
  72     LLVM_DEBUG(
  73         dbgs()
  74         << "OProfile connector library libopagent.so could not be loaded: "
  75         << error << "\n");
  76   }
  77
  78   // Get the addresses of the opagent functions
  79   OpenAgentFunc = (op_open_agent_ptr_t)(intptr_t)
  80           DynamicLibrary::SearchForAddressOfSymbol("op_open_agent");
  81   CloseAgentFunc = (op_close_agent_ptr_t)(intptr_t)
  82           DynamicLibrary::SearchForAddressOfSymbol("op_close_agent");
  83   WriteNativeCodeFunc = (op_write_native_code_ptr_t)(intptr_t)
  84           DynamicLibrary::SearchForAddressOfSymbol("op_write_native_code");
  85   WriteDebugLineInfoFunc = (op_write_debug_line_info_ptr_t)(intptr_t)
  86           DynamicLibrary::SearchForAddressOfSymbol("op_write_debug_line_info");
  87   UnloadNativeCodeFunc = (op_unload_native_code_ptr_t)(intptr_t)
  88           DynamicLibrary::SearchForAddressOfSymbol("op_unload_native_code");
  89   MajorVersionFunc = (op_major_version_ptr_t)(intptr_t)
  90           DynamicLibrary::SearchForAddressOfSymbol("op_major_version");
  91   MinorVersionFunc = (op_major_version_ptr_t)(intptr_t)
  92           DynamicLibrary::SearchForAddressOfSymbol("op_minor_version");
  93
  94   // With missing functions, we can do nothing
  95   if (!OpenAgentFunc
  96       || !CloseAgentFunc
  97       || !WriteNativeCodeFunc
  98       || !WriteDebugLineInfoFunc
  99       || !UnloadNativeCodeFunc) {
 100     OpenAgentFunc = 0;
 101     CloseAgentFunc = 0;
 102     WriteNativeCodeFunc = 0;
 103     WriteDebugLineInfoFunc = 0;
 104     UnloadNativeCodeFunc = 0;
 105     return false;
 106   }
 107
 108   return true;
 109 }
 110
 111 bool OProfileWrapper::isOProfileRunning() {
 112   if (IsOProfileRunningFunc != 0)
 113     return IsOProfileRunningFunc();
 114   return checkForOProfileProcEntry();
 115 }
 116
 117 bool OProfileWrapper::checkForOProfileProcEntry() {
 118   DIR* ProcDir;
 119
 120   ProcDir = opendir("/proc");
 121   if (!ProcDir)
 122     return false;
 123
 124   // Walk the /proc tree looking for the oprofile daemon
 125   struct dirent* Entry;
 126   while (0 != (Entry = readdir(ProcDir))) {
 127     if (Entry->d_type == DT_DIR) {
 128       // Build a path from the current entry name
 129       SmallString<256> CmdLineFName;
 130       raw_svector_ostream(CmdLineFName) << "/proc/" << Entry->d_name
 131                                         << "/cmdline";
 132
 133       // Open the cmdline file
 134       int CmdLineFD = open(CmdLineFName.c_str(), S_IRUSR);
 135       if (CmdLineFD != -1) {
 136         char    ExeName[PATH_MAX+1];
 137         char*   BaseName = 0;
 138
 139         // Read the cmdline file
 140         ssize_t NumRead = read(CmdLineFD, ExeName, PATH_MAX+1);
 141         close(CmdLineFD);
 142         ssize_t Idx = 0;
 143
 144         if (ExeName[0] != '/') {
 145           BaseName = ExeName;
 146         }
 147
 148         // Find the terminator for the first string
 149         while (Idx < NumRead-1 && ExeName[Idx] != 0) {
 150           Idx++;
 151         }
 152
 153         // Go back to the last non-null character
 154         Idx--;
 155
 156         // Find the last path separator in the first string
 157         while (Idx > 0) {
 158           if (ExeName[Idx] == '/') {
 159             BaseName = ExeName + Idx + 1;
 160             break;
 161           }
 162           Idx--;
 163         }
 164
 165         // Test this to see if it is the oprofile daemon
 166         if (BaseName != 0 && (!strcmp("oprofiled", BaseName) ||
 167                               !strcmp("operf", BaseName))) {
 168           // If it is, we're done
 169           closedir(ProcDir);
 170           return true;
 171         }
 172       }
 173     }
 174   }
 175
 176   // We've looked through all the files and didn't find the daemon
 177   closedir(ProcDir);
 178   return false;
 179 }
 180
 181 bool OProfileWrapper::op_open_agent() {
 182   if (!Initialized)
 183     initialize();
 184
 185   if (OpenAgentFunc != 0) {
 186     Agent = OpenAgentFunc();
 187     return Agent != 0;
 188   }
 189
 190   return false;
 191 }
 192
 193 int OProfileWrapper::op_close_agent() {
 194   if (!Initialized)
 195     initialize();
 196
 197   int ret = -1;
 198   if (Agent && CloseAgentFunc) {
 199     ret = CloseAgentFunc(Agent);
 200     if (ret == 0) {
 201       Agent = 0;
 202     }
 203   }
 204   return ret;
 205 }
 206
 207 bool OProfileWrapper::isAgentAvailable() {
 208   return Agent != 0;
 209 }
 210
 211 int OProfileWrapper::op_write_native_code(const char* Name,
 212                                           uint64_t Addr,
 213                                           void const* Code,
 214                                           const unsigned int Size) {
 215   if (!Initialized)
 216     initialize();
 217
 218   if (Agent && WriteNativeCodeFunc)
 219     return WriteNativeCodeFunc(Agent, Name, Addr, Code, Size);
 220
 221   return -1;
 222 }
 223
 224 int OProfileWrapper::op_write_debug_line_info(
 225   void const* Code,
 226   size_t NumEntries,
 227   struct debug_line_info const* Info) {
 228   if (!Initialized)
 229     initialize();
 230
 231   if (Agent && WriteDebugLineInfoFunc)
 232     return WriteDebugLineInfoFunc(Agent, Code, NumEntries, Info);
 233
 234   return -1;
 235 }
 236
 237 int OProfileWrapper::op_major_version() {
 238   if (!Initialized)
 239     initialize();
 240
 241   if (Agent && MajorVersionFunc)
 242     return MajorVersionFunc();
 243
 244   return -1;
 245 }
 246
 247 int OProfileWrapper::op_minor_version() {
 248   if (!Initialized)
 249     initialize();
 250
 251   if (Agent && MinorVersionFunc)
 252     return MinorVersionFunc();
 253
 254   return -1;
 255 }
 256
 257 int  OProfileWrapper::op_unload_native_code(uint64_t Addr) {
 258   if (!Initialized)
 259     initialize();
 260
 261   if (Agent && UnloadNativeCodeFunc)
 262     return UnloadNativeCodeFunc(Agent, Addr);
 263
 264   return -1;
 265 }
 266
 267 } // namespace llvm