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 } 305