1 /* Copyright (C) 2021-2023 Free Software Foundation, Inc.
2 Contributed by Oracle.
3
4 This file is part of GNU Binutils.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 /*
22 * Profile handling
23 *
24 * Note: SIGPROF signal-handling and interval timer (once exclusive to
25 * profile handling) are now common services provided by the dispatcher.
26 */
27
28 #include "config.h"
29 #include <dlfcn.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <ucontext.h>
33 #include <unistd.h>
34
35 #include "gp-defs.h"
36 #include "collector_module.h"
37 #include "gp-experiment.h"
38 #include "data_pckts.h"
39 #include "libcol_util.h"
40 #include "hwprofile.h"
41 #include "tsd.h"
42
43 /* TprintfT(<level>,...) definitions. Adjust per module as needed */
44 #define DBG_LT0 0 // for high-level configuration, unexpected errors/warnings
45 #define DBG_LT1 1 // for configuration details, warnings
46 #define DBG_LT2 2
47 #define DBG_LT3 3
48
49 static int init_interface (CollectorInterface*);
50 static int open_experiment (const char *);
51 static int start_data_collection (void);
52 static int stop_data_collection (void);
53 static int close_experiment (void);
54 static int detach_experiment (void);
55
56 static ModuleInterface module_interface ={
57 SP_PROFILE_FILE, /* description */
58 init_interface, /* initInterface */
59 open_experiment, /* openExperiment */
60 start_data_collection, /* startDataCollection */
61 stop_data_collection, /* stopDataCollection */
62 close_experiment, /* closeExperiment */
63 detach_experiment /* detachExperiment (fork child) */
64 };
65
66 static CollectorInterface *collector_interface = NULL;
67 static int prof_mode = 0;
68 static CollectorModule prof_hndl = COLLECTOR_MODULE_ERR;
69 static unsigned prof_key = COLLECTOR_TSD_INVALID_KEY;
70
71 typedef struct ClockPacket
72 { /* clock profiling packet */
73 CM_Packet comm;
74 pthread_t lwp_id;
75 pthread_t thr_id;
76 uint32_t cpu_id;
77 hrtime_t tstamp __attribute__ ((packed));
78 uint64_t frinfo __attribute__ ((packed));
79 int mstate; /* kernel microstate */
80 int nticks; /* number of ticks in that state */
81 } ClockPacket;
82
83 /* XXX should be able to use local types */
84 #define CLOCK_TYPE OPROF_PCKT
85
86 #define CHCK_REENTRANCE(x) ( !prof_mode || ((x) = collector_interface->getKey( prof_key )) == NULL || (*(x) != 0) )
87 #define PUSH_REENTRANCE(x) ((*(x))++)
88 #define POP_REENTRANCE(x) ((*(x))--)
89
90 #ifdef DEBUG
91 #define Tprintf(...) if (collector_interface) collector_interface->writeDebugInfo( 0, __VA_ARGS__ )
92 #define TprintfT(...) if (collector_interface) collector_interface->writeDebugInfo( 1, __VA_ARGS__ )
93 #else
94 #define Tprintf(...)
95 #define TprintfT(...)
96 #endif
97
98 static void init_module () __attribute__ ((constructor));
99
100 static void
101 init_module ()
102 {
103 __collector_dlsym_guard = 1;
104 RegModuleFunc reg_module = (RegModuleFunc) dlsym (RTLD_DEFAULT, "__collector_register_module");
105 __collector_dlsym_guard = 0;
106 if (reg_module == NULL)
107 {
108 TprintfT (0, "clockprof: init_module FAILED -- reg_module = NULL\n");
109 return;
110 }
111 prof_hndl = reg_module (&module_interface);
112 if (prof_hndl == COLLECTOR_MODULE_ERR && collector_interface != NULL)
113 {
114 Tprintf (0, "clockprof: ERROR: handle not created.\n");
115 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">data handle not created</event>\n", SP_JCMD_CERROR, COL_ERROR_PROFINIT);
116 }
117 TprintfT (0, "clockprof: init_module, prof_hndl = %d\n", prof_hndl);
118 return;
119 }
120
121 static int
122 init_interface (CollectorInterface *_collector_interface)
123 {
124 collector_interface = _collector_interface;
125 return COL_ERROR_NONE;
126 }
127
128 static int
129 open_experiment (const char *exp)
130 {
131 if (collector_interface == NULL)
132 {
133 Tprintf (0, "clockprof: ERROR: collector_interface is null.\n");
134 return COL_ERROR_PROFINIT;
135 }
136 const char *params = collector_interface->getParams ();
137 while (params)
138 {
139 if (__collector_strStartWith (params, "p:") == 0)
140 {
141 params += 2;
142 break;
143 }
144 while (*params != 0 && *params != ';')
145 params++;
146 if (*params == 0)
147 params = NULL;
148 else
149 params++;
150 }
151 if (params == NULL) /* Clock profiling not specified */
152 return COL_ERROR_PROFINIT;
153 TprintfT (0, "clockprof: open_experiment %s -- %s\n", exp, params);
154 int prof_interval = CALL_UTIL (strtol)(params, NULL, 0);
155 prof_key = collector_interface->createKey (sizeof ( int), NULL, NULL);
156 if (prof_key == (unsigned) - 1)
157 {
158 Tprintf (0, "clockprof: ERROR: TSD key create failed.\n");
159 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">TSD key not created</event>\n", SP_JCMD_CERROR, COL_ERROR_PROFINIT);
160 return COL_ERROR_PROFINIT;
161 }
162
163 /* set dispatcher interval timer period used for all timed activities */
164 int prof_interval_actual = __collector_ext_itimer_set (prof_interval);
165 TprintfT (0, "clockprof: open_experiment(): __collector_ext_itimer_set (actual period=%d, req_period=%d)\n",
166 prof_interval_actual, prof_interval);
167 if (prof_interval_actual <= 0)
168 {
169 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">itimer could not be set</event>\n", SP_JCMD_CERROR, COL_ERROR_PROFINIT);
170 return COL_ERROR_PROFINIT;
171 }
172 if ((prof_interval_actual >= (prof_interval + prof_interval / 10)) ||
173 (prof_interval_actual <= (prof_interval - prof_interval / 10)))
174 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">%d -> %d</event>\n", SP_JCMD_CWARN, COL_WARN_PROFRND, prof_interval, prof_interval_actual);
175 else if (prof_interval_actual != prof_interval)
176 collector_interface->writeLog ("<event kind=\"%s\" id=\"%d\">%d -> %d</event>\n", SP_JCMD_COMMENT, COL_WARN_PROFRND, prof_interval, prof_interval_actual);
177 prof_interval = prof_interval_actual;
178 collector_interface->writeLog ("<profile name=\"%s\" ptimer=\"%d\" numstates=\"%d\">\n",
179 SP_JCMD_PROFILE, prof_interval, LMS_MAGIC_ID_LINUX);
180 collector_interface->writeLog (" <profdata fname=\"%s\"/>\n",
181 module_interface.description);
182
183 /* Record Profile packet description */
184 ClockPacket *cp = NULL;
185 collector_interface->writeLog (" <profpckt kind=\"%d\" uname=\"" STXT ("Clock profiling data") "\">\n", CLOCK_TYPE);
186 collector_interface->writeLog (" <field name=\"LWPID\" uname=\"" STXT ("Lightweight process id") "\" offset=\"%d\" type=\"%s\"/>\n",
187 &cp->lwp_id, sizeof (cp->lwp_id) == 4 ? "INT32" : "INT64");
188 collector_interface->writeLog (" <field name=\"THRID\" uname=\"" STXT ("Thread number") "\" offset=\"%d\" type=\"%s\"/>\n",
189 &cp->thr_id, sizeof (cp->thr_id) == 4 ? "INT32" : "INT64");
190 collector_interface->writeLog (" <field name=\"CPUID\" uname=\"" STXT ("CPU id") "\" offset=\"%d\" type=\"%s\"/>\n",
191 &cp->cpu_id, sizeof (cp->cpu_id) == 4 ? "INT32" : "INT64");
192 collector_interface->writeLog (" <field name=\"TSTAMP\" uname=\"" STXT ("High resolution timestamp") "\" offset=\"%d\" type=\"%s\"/>\n",
193 &cp->tstamp, sizeof (cp->tstamp) == 4 ? "INT32" : "INT64");
194 collector_interface->writeLog (" <field name=\"FRINFO\" offset=\"%d\" type=\"%s\"/>\n",
195 &cp->frinfo, sizeof (cp->frinfo) == 4 ? "INT32" : "INT64");
196 collector_interface->writeLog (" <field name=\"MSTATE\" uname=\"" STXT ("Thread state") "\" offset=\"%d\" type=\"%s\"/>\n",
197 &cp->mstate, sizeof (cp->mstate) == 4 ? "INT32" : "INT64");
198 collector_interface->writeLog (" <field name=\"NTICK\" uname=\"" STXT ("Duration") "\" offset=\"%d\" type=\"%s\"/>\n",
199 &cp->nticks, sizeof (cp->nticks) == 4 ? "INT32" : "INT64");
200 collector_interface->writeLog (" </profpckt>\n");
201 collector_interface->writeLog ("</profile>\n");
202 return COL_ERROR_NONE;
203 }
204
205 static int
206 start_data_collection (void)
207 {
208 TprintfT (0, "clockprof: start_data_collection\n");
209 prof_mode = 1;
210 return 0;
211 }
212
213 static int
214 stop_data_collection (void)
215 {
216 prof_mode = 0;
217 TprintfT (0, "clockprof: stop_data_collection\n");
218 return 0;
219 }
220
221 static int
222 close_experiment (void)
223 {
224 prof_mode = 0;
225 prof_key = COLLECTOR_TSD_INVALID_KEY;
226 TprintfT (0, "clockprof: close_experiment\n");
227 return 0;
228 }
229
230 /* fork child. Clean up state but don't write to experiment */
231 static int
232 detach_experiment (void)
233 {
234 prof_mode = 0;
235 prof_key = COLLECTOR_TSD_INVALID_KEY;
236 TprintfT (0, "clockprof: detach_experiment\n");
237 return 0;
238 }
239
240 /*
241 * void collector_lost_profile_context
242 * Placeholder/marker function used when profiling given NULL context.
243 */
244 void
245 __collector_lost_profile_context (void) { }
246
247 /*
248 * void __collector_ext_profile_handler( siginfo_t *info, ucontext_t *context )
249 * Handle real profile events to collect profile data.
250 */
251 void
252 __collector_ext_profile_handler (siginfo_t *info, ucontext_t *context)
253 {
254 int *guard;
255 if (!prof_mode) /* sigprof timer running only because hwprofile.c needs it */
256 return;
257 if (CHCK_REENTRANCE (guard))
258 {
259 TprintfT (0, "__collector_ext_profile_handler: ERROR: prof_mode=%d guard=%d!\n",
260 prof_mode, guard ? *guard : -2);
261 return;
262 }
263 PUSH_REENTRANCE (guard);
264 TprintfT (DBG_LT3, "__collector_ext_profile_handler\n");
265 ucontext_t uctxmem;
266 if (context == NULL)
267 {
268 /* assume this case is rare, and accept overhead of creating dummy_uc */
269 TprintfT (0, "collector_profile_handler: ERROR: got NULL context!\n");
270 context = &uctxmem;
271 CALL_UTIL (getcontext) (context); /* initialize dummy context */
272 SETFUNCTIONCONTEXT (context, &__collector_lost_profile_context);
273 }
274 ClockPacket pckt;
275 CALL_UTIL (memset)(&pckt, 0, sizeof ( pckt));
276 pckt.comm.tsize = sizeof ( pckt);
277 pckt.comm.type = CLOCK_TYPE;
278 pckt.lwp_id = __collector_lwp_self ();
279 pckt.thr_id = __collector_thr_self ();
280 pckt.cpu_id = CALL_UTIL (getcpuid)();
281 pckt.tstamp = collector_interface->getHiResTime ();
282 pckt.frinfo = collector_interface->getFrameInfo (COLLECTOR_MODULE_ERR, pckt.tstamp, FRINFO_FROM_UC, context);
283 pckt.mstate = LMS_LINUX_CPU;
284 pckt.nticks = 1;
285 collector_interface->writeDataPacket (prof_hndl, (CM_Packet*) & pckt);
286 POP_REENTRANCE (guard);
287 }