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