tools/perf/jvmti/libjvmti.c

   1 #include <sys/types.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #include <err.h>
   6 #include <jvmti.h>
   7 #include <jvmticmlr.h>
   8 #include <limits.h>
   9
  10 #include "jvmti_agent.h"
  11
  12 static int has_line_numbers;
  13 void *jvmti_agent;
  14
  15 static jvmtiError
  16 do_get_line_numbers(jvmtiEnv *jvmti, void *pc, jmethodID m, jint bci,
  17                     jvmti_line_info_t *tab, jint *nr)
  18 {
  19         jint i, lines = 0;
  20         jint nr_lines = 0;
  21         jvmtiLineNumberEntry *loc_tab = NULL;
  22         jvmtiError ret;
  23
  24         ret = (*jvmti)->GetLineNumberTable(jvmti, m, &nr_lines, &loc_tab);
  25         if (ret != JVMTI_ERROR_NONE)
  26                 return ret;
  27
  28         for (i = 0; i < nr_lines; i++) {
  29                 if (loc_tab[i].start_location < bci) {
  30                         tab[lines].pc = (unsigned long)pc;
  31                         tab[lines].line_number = loc_tab[i].line_number;
  32                         tab[lines].discrim = 0; /* not yet used */
  33                         lines++;
  34                 } else {
  35                         break;
  36                 }
  37         }
  38         (*jvmti)->Deallocate(jvmti, (unsigned char *)loc_tab);
  39         *nr = lines;
  40         return JVMTI_ERROR_NONE;
  41 }
  42
  43 static jvmtiError
  44 get_line_numbers(jvmtiEnv *jvmti, const void *compile_info, jvmti_line_info_t **tab, int *nr_lines)
  45 {
  46         const jvmtiCompiledMethodLoadRecordHeader *hdr;
  47         jvmtiCompiledMethodLoadInlineRecord *rec;
  48         jvmtiLineNumberEntry *lne = NULL;
  49         PCStackInfo *c;
  50         jint nr, ret;
  51         int nr_total = 0;
  52         int i, lines_total = 0;
  53
  54         if (!(tab && nr_lines))
  55                 return JVMTI_ERROR_NULL_POINTER;
  56
  57         /*
  58          * Phase 1 -- get the number of lines necessary
  59          */
  60         for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
  61                 if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
  62                         rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
  63                         for (i = 0; i < rec->numpcs; i++) {
  64                                 c = rec->pcinfo + i;
  65                                 nr = 0;
  66                                 /*
  67                                  * unfortunately, need a tab to get the number of lines!
  68                                  */
  69                                 ret = (*jvmti)->GetLineNumberTable(jvmti, c->methods[0], &nr, &lne);
  70                                 if (ret == JVMTI_ERROR_NONE) {
  71                                         /* free what was allocated for nothing */
  72                                         (*jvmti)->Deallocate(jvmti, (unsigned char *)lne);
  73                                         nr_total += (int)nr;
  74                                 }
  75                         }
  76                 }
  77         }
  78
  79         if (nr_total == 0)
  80                 return JVMTI_ERROR_NOT_FOUND;
  81
  82         /*
  83          * Phase 2 -- allocate big enough line table
  84          */
  85         *tab = malloc(nr_total * sizeof(**tab));
  86         if (!*tab)
  87                 return JVMTI_ERROR_OUT_OF_MEMORY;
  88
  89         for (hdr = compile_info; hdr != NULL; hdr = hdr->next) {
  90                 if (hdr->kind == JVMTI_CMLR_INLINE_INFO) {
  91                         rec = (jvmtiCompiledMethodLoadInlineRecord *)hdr;
  92                         for (i = 0; i < rec->numpcs; i++) {
  93                                 c = rec->pcinfo + i;
  94                                 nr = 0;
  95                                 ret = do_get_line_numbers(jvmti, c->pc,
  96                                                           c->methods[0],
  97                                                           c->bcis[0],
  98                                                           *tab + lines_total,
  99                                                           &nr);
 100                                 if (ret == JVMTI_ERROR_NONE)
 101                                         lines_total += nr;
 102                         }
 103                 }
 104         }
 105         *nr_lines = lines_total;
 106         return JVMTI_ERROR_NONE;
 107 }
 108
 109 static void JNICALL
 110 compiled_method_load_cb(jvmtiEnv *jvmti,
 111                         jmethodID method,
 112                         jint code_size,
 113                         void const *code_addr,
 114                         jint map_length,
 115                         jvmtiAddrLocationMap const *map,
 116                         const void *compile_info)
 117 {
 118         jvmti_line_info_t *line_tab = NULL;
 119         jclass decl_class;
 120         char *class_sign = NULL;
 121         char *func_name = NULL;
 122         char *func_sign = NULL;
 123         char *file_name= NULL;
 124         char fn[PATH_MAX];
 125         uint64_t addr = (uint64_t)(uintptr_t)code_addr;
 126         jvmtiError ret;
 127         int nr_lines = 0; /* in line_tab[] */
 128         size_t len;
 129
 130         ret = (*jvmti)->GetMethodDeclaringClass(jvmti, method,
 131                                                 &decl_class);
 132         if (ret != JVMTI_ERROR_NONE) {
 133                 warnx("jvmti: cannot get declaring class");
 134                 return;
 135         }
 136
 137         if (has_line_numbers && map && map_length) {
 138                 ret = get_line_numbers(jvmti, compile_info, &line_tab, &nr_lines);
 139                 if (ret != JVMTI_ERROR_NONE) {
 140                         warnx("jvmti: cannot get line table for method");
 141                         nr_lines = 0;
 142                 }
 143         }
 144
 145         ret = (*jvmti)->GetSourceFileName(jvmti, decl_class, &file_name);
 146         if (ret != JVMTI_ERROR_NONE) {
 147                 warnx("jvmti: cannot get source filename ret=%d", ret);
 148                 goto error;
 149         }
 150
 151         ret = (*jvmti)->GetClassSignature(jvmti, decl_class,
 152                                           &class_sign, NULL);
 153         if (ret != JVMTI_ERROR_NONE) {
 154                 warnx("jvmti: getclassignature failed");
 155                 goto error;
 156         }
 157
 158         ret = (*jvmti)->GetMethodName(jvmti, method, &func_name,
 159                                       &func_sign, NULL);
 160         if (ret != JVMTI_ERROR_NONE) {
 161                 warnx("jvmti: failed getmethodname");
 162                 goto error;
 163         }
 164
 165         /*
 166          * Assume path name is class hierarchy, this is a common practice with Java programs
 167          */
 168         if (*class_sign == 'L') {
 169                 int j, i = 0;
 170                 char *p = strrchr(class_sign, '/');
 171                 if (p) {
 172                         /* drop the 'L' prefix and copy up to the final '/' */
 173                         for (i = 0; i < (p - class_sign); i++)
 174                                 fn[i] = class_sign[i+1];
 175                 }
 176                 /*
 177                  * append file name, we use loops and not string ops to avoid modifying
 178                  * class_sign which is used later for the symbol name
 179                  */
 180                 for (j = 0; i < (PATH_MAX - 1) && file_name && j < strlen(file_name); j++, i++)
 181                         fn[i] = file_name[j];
 182                 fn[i] = '\0';
 183         } else {
 184                 /* fallback case */
 185                 strcpy(fn, file_name);
 186         }
 187         /*
 188          * write source line info record if we have it
 189          */
 190         if (jvmti_write_debug_info(jvmti_agent, addr, fn, line_tab, nr_lines))
 191                 warnx("jvmti: write_debug_info() failed");
 192
 193         len = strlen(func_name) + strlen(class_sign) + strlen(func_sign) + 2;
 194         {
 195                 char str[len];
 196                 snprintf(str, len, "%s%s%s", class_sign, func_name, func_sign);
 197
 198                 if (jvmti_write_code(jvmti_agent, str, addr, code_addr, code_size))
 199                         warnx("jvmti: write_code() failed");
 200         }
 201 error:
 202         (*jvmti)->Deallocate(jvmti, (unsigned char *)func_name);
 203         (*jvmti)->Deallocate(jvmti, (unsigned char *)func_sign);
 204         (*jvmti)->Deallocate(jvmti, (unsigned char *)class_sign);
 205         (*jvmti)->Deallocate(jvmti, (unsigned char *)file_name);
 206         free(line_tab);
 207 }
 208
 209 static void JNICALL
 210 code_generated_cb(jvmtiEnv *jvmti,
 211                   char const *name,
 212                   void const *code_addr,
 213                   jint code_size)
 214 {
 215         uint64_t addr = (uint64_t)(unsigned long)code_addr;
 216         int ret;
 217
 218         ret = jvmti_write_code(jvmti_agent, name, addr, code_addr, code_size);
 219         if (ret)
 220                 warnx("jvmti: write_code() failed for code_generated");
 221 }
 222
 223 JNIEXPORT jint JNICALL
 224 Agent_OnLoad(JavaVM *jvm, char *options, void *reserved __unused)
 225 {
 226         jvmtiEventCallbacks cb;
 227         jvmtiCapabilities caps1;
 228         jvmtiJlocationFormat format;
 229         jvmtiEnv *jvmti = NULL;
 230         jint ret;
 231
 232         jvmti_agent = jvmti_open();
 233         if (!jvmti_agent) {
 234                 warnx("jvmti: open_agent failed");
 235                 return -1;
 236         }
 237
 238         /*
 239          * Request a JVMTI interface version 1 environment
 240          */
 241         ret = (*jvm)->GetEnv(jvm, (void *)&jvmti, JVMTI_VERSION_1);
 242         if (ret != JNI_OK) {
 243                 warnx("jvmti: jvmti version 1 not supported");
 244                 return -1;
 245         }
 246
 247         /*
 248          * acquire method_load capability, we require it
 249          * request line numbers (optional)
 250          */
 251         memset(&caps1, 0, sizeof(caps1));
 252         caps1.can_generate_compiled_method_load_events = 1;
 253
 254         ret = (*jvmti)->AddCapabilities(jvmti, &caps1);
 255         if (ret != JVMTI_ERROR_NONE) {
 256                 warnx("jvmti: acquire compiled_method capability failed");
 257                 return -1;
 258         }
 259         ret = (*jvmti)->GetJLocationFormat(jvmti, &format);
 260         if (ret == JVMTI_ERROR_NONE && format == JVMTI_JLOCATION_JVMBCI) {
 261                 memset(&caps1, 0, sizeof(caps1));
 262                 caps1.can_get_line_numbers = 1;
 263                 caps1.can_get_source_file_name = 1;
 264                 ret = (*jvmti)->AddCapabilities(jvmti, &caps1);
 265                 if (ret == JVMTI_ERROR_NONE)
 266                         has_line_numbers = 1;
 267         }
 268
 269         memset(&cb, 0, sizeof(cb));
 270
 271         cb.CompiledMethodLoad   = compiled_method_load_cb;
 272         cb.DynamicCodeGenerated = code_generated_cb;
 273
 274         ret = (*jvmti)->SetEventCallbacks(jvmti, &cb, sizeof(cb));
 275         if (ret != JVMTI_ERROR_NONE) {
 276                 warnx("jvmti: cannot set event callbacks");
 277                 return -1;
 278         }
 279
 280         ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
 281                         JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
 282         if (ret != JVMTI_ERROR_NONE) {
 283                 warnx("jvmti: setnotification failed for method_load");
 284                 return -1;
 285         }
 286
 287         ret = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
 288                         JVMTI_EVENT_DYNAMIC_CODE_GENERATED, NULL);
 289         if (ret != JVMTI_ERROR_NONE) {
 290                 warnx("jvmti: setnotification failed on code_generated");
 291                 return -1;
 292         }
 293         return 0;
 294 }
 295
 296 JNIEXPORT void JNICALL
 297 Agent_OnUnload(JavaVM *jvm __unused)
 298 {
 299         int ret;
 300
 301         ret = jvmti_close(jvmti_agent);
 302         if (ret)
 303                 errx(1, "Error: op_close_agent()");
 304 }