LLVM  10.0.0svn
OProfileWrapper.cpp
Go to the documentation of this file.
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 
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/Support/Debug.h"
19 #include "llvm/Support/Mutex.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 
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)
81  CloseAgentFunc = (op_close_agent_ptr_t)(intptr_t)
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 
182  if (!Initialized)
183  initialize();
184 
185  if (OpenAgentFunc != 0) {
186  Agent = OpenAgentFunc();
187  return Agent != 0;
188  }
189 
190  return false;
191 }
192 
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 
208  return Agent != 0;
209 }
210 
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 
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 
238  if (!Initialized)
239  initialize();
240 
241  if (Agent && MajorVersionFunc)
242  return MajorVersionFunc();
243 
244  return -1;
245 }
246 
248  if (!Initialized)
249  initialize();
250 
251  if (Agent && MinorVersionFunc)
252  return MinorVersionFunc();
253 
254  return -1;
255 }
256 
258  if (!Initialized)
259  initialize();
260 
261  if (Agent && UnloadNativeCodeFunc)
262  return UnloadNativeCodeFunc(Agent, Addr);
263 
264  return -1;
265 }
266 
267 } // namespace llvm
static void * SearchForAddressOfSymbol(const char *symbolName)
This function will search through all previously loaded dynamic libraries for the symbol symbolName...
This class represents lattice values for constants.
Definition: AllocatorList.h:23
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:530
#define error(X)
int op_write_debug_line_info(void const *code, size_t num_entries, struct debug_line_info const *info)
static bool LoadLibraryPermanently(const char *Filename, std::string *ErrMsg=nullptr)
This function permanently loads the dynamic library at the given path.
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T, ArrayRef< StringRef > StandardNames)
Initialize the set of available library functions based on the specified target triple.
int op_write_native_code(const char *name, uint64_t addr, void const *code, const unsigned int size)
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:65
const char * c_str()
Definition: SmallString.h:269
uint32_t Size
Definition: Profile.cpp:46
int op_unload_native_code(uint64_t addr)
#define LLVM_DEBUG(X)
Definition: Debug.h:122