1 /* Copyright (C) 2021 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 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 } 288