|
1 /* |
|
2 * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. |
|
3 * |
|
4 * Redistribution and use in source and binary forms, with or without |
|
5 * modification, are permitted provided that the following conditions |
|
6 * are met: |
|
7 * |
|
8 * - Redistributions of source code must retain the above copyright |
|
9 * notice, this list of conditions and the following disclaimer. |
|
10 * |
|
11 * - Redistributions in binary form must reproduce the above copyright |
|
12 * notice, this list of conditions and the following disclaimer in the |
|
13 * documentation and/or other materials provided with the distribution. |
|
14 * |
|
15 * - Neither the name of Oracle nor the names of its |
|
16 * contributors may be used to endorse or promote products derived |
|
17 * from this software without specific prior written permission. |
|
18 * |
|
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS |
|
20 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, |
|
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
|
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
|
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
|
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
|
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
|
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
|
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
|
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
|
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
30 */ |
|
31 |
|
32 /* |
|
33 * This source code is provided to illustrate the usage of a given feature |
|
34 * or technique and has been deliberately simplified. Additional steps |
|
35 * required for a production-quality application, such as security checks, |
|
36 * input validation and proper error handling, might not be present in |
|
37 * this sample code. |
|
38 */ |
|
39 |
|
40 |
|
41 /* Functionality for checking hprof format=b output. */ |
|
42 |
|
43 /* ONLY used with logflags=4. */ |
|
44 |
|
45 /* Verifies and write a verbose textual version of a format=b file. |
|
46 * Textual output file is gdata->checkfilename, fd is gdata->check_fd. |
|
47 * Buffer is in gdata too, see gdata->check* variables. |
|
48 * Could probably be isolated to a separate library or utility. |
|
49 */ |
|
50 |
|
51 #include "hprof.h" |
|
52 |
|
53 typedef TableIndex HprofId; |
|
54 |
|
55 #include "hprof_b_spec.h" |
|
56 |
|
57 static int type_size[ /*HprofType*/ ] = HPROF_TYPE_SIZES; |
|
58 |
|
59 /* For map from HPROF_UTF8 to a string */ |
|
60 typedef struct UmapInfo { |
|
61 char *str; |
|
62 } UmapInfo; |
|
63 |
|
64 /* Field information */ |
|
65 typedef struct Finfo { |
|
66 HprofId id; |
|
67 HprofType ty; |
|
68 } Finfo; |
|
69 |
|
70 /* Class information map from class ID (ClassIndex) to class information */ |
|
71 typedef struct CmapInfo { |
|
72 int max_finfo; |
|
73 int n_finfo; |
|
74 Finfo *finfo; |
|
75 int inst_size; |
|
76 HprofId sup; |
|
77 } CmapInfo; |
|
78 |
|
79 /* Read raw bytes from the file image, update the pointer */ |
|
80 static void |
|
81 read_raw(unsigned char **pp, unsigned char *buf, int len) |
|
82 { |
|
83 while ( len > 0 ) { |
|
84 *buf = **pp; |
|
85 buf++; |
|
86 (*pp)++; |
|
87 len--; |
|
88 } |
|
89 } |
|
90 |
|
91 /* Read various sized elements, properly converted from big to right endian. |
|
92 * File will contain big endian format. |
|
93 */ |
|
94 static unsigned |
|
95 read_u1(unsigned char **pp) |
|
96 { |
|
97 unsigned char b; |
|
98 |
|
99 read_raw(pp, &b, 1); |
|
100 return b; |
|
101 } |
|
102 static unsigned |
|
103 read_u2(unsigned char **pp) |
|
104 { |
|
105 unsigned short s; |
|
106 |
|
107 read_raw(pp, (void*)&s, 2); |
|
108 return md_htons(s); |
|
109 } |
|
110 static unsigned |
|
111 read_u4(unsigned char **pp) |
|
112 { |
|
113 unsigned int u; |
|
114 |
|
115 read_raw(pp, (void*)&u, 4); |
|
116 return md_htonl(u); |
|
117 } |
|
118 static jlong |
|
119 read_u8(unsigned char **pp) |
|
120 { |
|
121 unsigned int high; |
|
122 unsigned int low; |
|
123 jlong x; |
|
124 |
|
125 high = read_u4(pp); |
|
126 low = read_u4(pp); |
|
127 x = high; |
|
128 x = (x << 32) | low; |
|
129 return x; |
|
130 } |
|
131 static HprofId |
|
132 read_id(unsigned char **pp) |
|
133 { |
|
134 return (HprofId)read_u4(pp); |
|
135 } |
|
136 |
|
137 /* System error routine */ |
|
138 static void |
|
139 system_error(const char *system_call, int rc, int errnum) |
|
140 { |
|
141 char buf[256]; |
|
142 char details[256]; |
|
143 |
|
144 details[0] = 0; |
|
145 if ( errnum != 0 ) { |
|
146 md_system_error(details, (int)sizeof(details)); |
|
147 } else if ( rc >= 0 ) { |
|
148 (void)strcpy(details,"Only part of buffer processed"); |
|
149 } |
|
150 if ( details[0] == 0 ) { |
|
151 (void)strcpy(details,"Unknown system error condition"); |
|
152 } |
|
153 (void)md_snprintf(buf, sizeof(buf), "System %s failed: %s\n", |
|
154 system_call, details); |
|
155 HPROF_ERROR(JNI_TRUE, buf); |
|
156 } |
|
157 |
|
158 /* Write to a fd */ |
|
159 static void |
|
160 system_write(int fd, void *buf, int len) |
|
161 { |
|
162 int res; |
|
163 |
|
164 HPROF_ASSERT(fd>=0); |
|
165 res = md_write(fd, buf, len); |
|
166 if (res < 0 || res!=len) { |
|
167 system_error("write", res, errno); |
|
168 } |
|
169 } |
|
170 |
|
171 /* Flush check buffer */ |
|
172 static void |
|
173 check_flush(void) |
|
174 { |
|
175 if ( gdata->check_fd < 0 ) { |
|
176 return; |
|
177 } |
|
178 if (gdata->check_buffer_index) { |
|
179 system_write(gdata->check_fd, gdata->check_buffer, gdata->check_buffer_index); |
|
180 gdata->check_buffer_index = 0; |
|
181 } |
|
182 } |
|
183 |
|
184 /* Read out a given typed element */ |
|
185 static jvalue |
|
186 read_val(unsigned char **pp, HprofType ty) |
|
187 { |
|
188 jvalue val; |
|
189 static jvalue empty_val; |
|
190 |
|
191 val = empty_val; |
|
192 switch ( ty ) { |
|
193 case 0: |
|
194 case HPROF_ARRAY_OBJECT: |
|
195 case HPROF_NORMAL_OBJECT: |
|
196 val.i = read_id(pp); |
|
197 break; |
|
198 case HPROF_BYTE: |
|
199 case HPROF_BOOLEAN: |
|
200 val.b = read_u1(pp); |
|
201 break; |
|
202 case HPROF_CHAR: |
|
203 case HPROF_SHORT: |
|
204 val.s = read_u2(pp); |
|
205 break; |
|
206 case HPROF_FLOAT: |
|
207 case HPROF_INT: |
|
208 val.i = read_u4(pp); |
|
209 break; |
|
210 case HPROF_DOUBLE: |
|
211 case HPROF_LONG: |
|
212 val.j = read_u8(pp); |
|
213 break; |
|
214 default: |
|
215 HPROF_ERROR(JNI_TRUE, "bad type number"); |
|
216 break; |
|
217 } |
|
218 return val; |
|
219 } |
|
220 |
|
221 /* Move arbitrary byte stream into gdata->check_fd */ |
|
222 static void |
|
223 check_raw(void *buf, int len) |
|
224 { |
|
225 if ( gdata->check_fd < 0 ) { |
|
226 return; |
|
227 } |
|
228 |
|
229 if ( len <= 0 ) { |
|
230 return; |
|
231 } |
|
232 |
|
233 if (gdata->check_buffer_index + len > gdata->check_buffer_size) { |
|
234 check_flush(); |
|
235 if (len > gdata->check_buffer_size) { |
|
236 system_write(gdata->check_fd, buf, len); |
|
237 return; |
|
238 } |
|
239 } |
|
240 (void)memcpy(gdata->check_buffer + gdata->check_buffer_index, buf, len); |
|
241 gdata->check_buffer_index += len; |
|
242 } |
|
243 |
|
244 /* Printf for gdata->check_fd */ |
|
245 static void |
|
246 check_printf(char *fmt, ...) |
|
247 { |
|
248 char buf[1024]; |
|
249 va_list args; |
|
250 |
|
251 if ( gdata->check_fd < 0 ) { |
|
252 return; |
|
253 } |
|
254 |
|
255 va_start(args, fmt); |
|
256 (void)md_vsnprintf(buf, sizeof(buf), fmt, args); |
|
257 buf[sizeof(buf)-1] = 0; |
|
258 check_raw(buf, (int)strlen(buf)); |
|
259 va_end(args); |
|
260 } |
|
261 |
|
262 /* Printf of an element for gdata->check_fd */ |
|
263 static void |
|
264 check_printf_val(HprofType ty, jvalue val, int long_form) |
|
265 { |
|
266 jint low; |
|
267 jint high; |
|
268 |
|
269 switch ( ty ) { |
|
270 case HPROF_ARRAY_OBJECT: |
|
271 check_printf("0x%08x", val.i); |
|
272 break; |
|
273 case HPROF_NORMAL_OBJECT: |
|
274 check_printf("0x%08x", val.i); |
|
275 break; |
|
276 case HPROF_BOOLEAN: |
|
277 check_printf("0x%02x", val.b); |
|
278 break; |
|
279 case HPROF_CHAR: |
|
280 if ( long_form ) { |
|
281 if ( val.s < 0 || val.s > 0x7f || !isprint(val.s) ) { |
|
282 check_printf("0x%04x", val.s); |
|
283 } else { |
|
284 check_printf("0x%04x(%c)", val.s, val.s); |
|
285 } |
|
286 } else { |
|
287 if ( val.s < 0 || val.s > 0x7f || !isprint(val.s) ) { |
|
288 check_printf("\\u%04x", val.s); |
|
289 } else { |
|
290 check_printf("%c", val.s); |
|
291 } |
|
292 } |
|
293 break; |
|
294 case HPROF_FLOAT: |
|
295 low = jlong_low(val.j); |
|
296 check_printf("0x%08x(%f)", low, (double)val.f); |
|
297 break; |
|
298 case HPROF_DOUBLE: |
|
299 high = jlong_high(val.j); |
|
300 low = jlong_low(val.j); |
|
301 check_printf("0x%08x%08x(%f)", high, low, val.d); |
|
302 break; |
|
303 case HPROF_BYTE: |
|
304 check_printf("0x%02x", val.b); |
|
305 break; |
|
306 case HPROF_SHORT: |
|
307 check_printf("0x%04x", val.s); |
|
308 break; |
|
309 case HPROF_INT: |
|
310 check_printf("0x%08x", val.i); |
|
311 break; |
|
312 case HPROF_LONG: |
|
313 high = jlong_high(val.j); |
|
314 low = jlong_low(val.j); |
|
315 check_printf("0x%08x%08x", high, low); |
|
316 break; |
|
317 } |
|
318 } |
|
319 |
|
320 /* Printf of a string for gdata->check_fd */ |
|
321 static void |
|
322 check_printf_str(char *str) |
|
323 { |
|
324 int len; |
|
325 int i; |
|
326 |
|
327 if ( str == NULL ) { |
|
328 check_printf("<null>"); |
|
329 } |
|
330 check_printf("\""); |
|
331 len = (int)strlen(str); |
|
332 for (i = 0; i < len; i++) { |
|
333 unsigned char c; |
|
334 c = str[i]; |
|
335 if ( isprint(c) ) { |
|
336 check_printf("%c", c); |
|
337 } else { |
|
338 check_printf("\\x%02x", c); |
|
339 } |
|
340 } |
|
341 check_printf("\""); |
|
342 } |
|
343 |
|
344 /* Printf of a utf8 id for gdata->check_fd */ |
|
345 static void |
|
346 check_print_utf8(struct LookupTable *utab, char *prefix, HprofId id) |
|
347 { |
|
348 TableIndex uindex; |
|
349 |
|
350 if ( id == 0 ) { |
|
351 check_printf("%s0x%x", prefix, id); |
|
352 } else { |
|
353 uindex = table_find_entry(utab, &id, sizeof(id)); |
|
354 if ( uindex == 0 ) { |
|
355 check_printf("%s0x%x", prefix, id); |
|
356 } else { |
|
357 UmapInfo *umap; |
|
358 |
|
359 umap = (UmapInfo*)table_get_info(utab, uindex); |
|
360 HPROF_ASSERT(umap!=NULL); |
|
361 HPROF_ASSERT(umap->str!=NULL); |
|
362 check_printf("%s0x%x->", prefix, id); |
|
363 check_printf_str(umap->str); |
|
364 } |
|
365 } |
|
366 } |
|
367 |
|
368 /* Add a instance field information to this cmap. */ |
|
369 static void |
|
370 add_inst_field_to_cmap(CmapInfo *cmap, HprofId id, HprofType ty) |
|
371 { |
|
372 int i; |
|
373 |
|
374 HPROF_ASSERT(cmap!=NULL); |
|
375 i = cmap->n_finfo++; |
|
376 if ( i+1 >= cmap->max_finfo ) { |
|
377 int osize; |
|
378 Finfo *new_finfo; |
|
379 |
|
380 osize = cmap->max_finfo; |
|
381 cmap->max_finfo += 12; |
|
382 new_finfo = (Finfo*)HPROF_MALLOC(cmap->max_finfo*(int)sizeof(Finfo)); |
|
383 (void)memset(new_finfo,0,cmap->max_finfo*(int)sizeof(Finfo)); |
|
384 if ( i == 0 ) { |
|
385 cmap->finfo = new_finfo; |
|
386 } else { |
|
387 (void)memcpy(new_finfo,cmap->finfo,osize*(int)sizeof(Finfo)); |
|
388 HPROF_FREE(cmap->finfo); |
|
389 cmap->finfo = new_finfo; |
|
390 } |
|
391 } |
|
392 cmap->finfo[i].id = id; |
|
393 cmap->finfo[i].ty = ty; |
|
394 } |
|
395 |
|
396 /* LookupTable callback for cmap entry cleanup */ |
|
397 static void |
|
398 cmap_cleanup(TableIndex i, void *key_ptr, int key_len, void*info, void*data) |
|
399 { |
|
400 CmapInfo *cmap = info; |
|
401 |
|
402 if ( cmap == NULL ) { |
|
403 return; |
|
404 } |
|
405 if ( cmap->finfo != NULL ) { |
|
406 HPROF_FREE(cmap->finfo); |
|
407 cmap->finfo = NULL; |
|
408 } |
|
409 } |
|
410 |
|
411 /* Case label for a switch on hprof heap dump elements */ |
|
412 #define CASE_HEAP(name) case name: label = #name; |
|
413 |
|
414 /* Given the heap dump data and the utf8 map, check/write the heap dump. */ |
|
415 static int |
|
416 check_heap_tags(struct LookupTable *utab, unsigned char *pstart, int nbytes) |
|
417 { |
|
418 int nrecords; |
|
419 unsigned char *p; |
|
420 unsigned char *psave; |
|
421 struct LookupTable *ctab; |
|
422 CmapInfo cmap; |
|
423 char *label; |
|
424 unsigned tag; |
|
425 HprofType ty; |
|
426 HprofId id, id2, fr, sup; |
|
427 int num_elements; |
|
428 int num_bytes; |
|
429 SerialNumber trace_serial_num; |
|
430 SerialNumber thread_serial_num; |
|
431 int npos; |
|
432 int i; |
|
433 int inst_size; |
|
434 |
|
435 ctab = table_initialize("temp ctab", 64, 64, 512, sizeof(CmapInfo)); |
|
436 |
|
437 /* First pass over heap records just fills in the CmapInfo table */ |
|
438 nrecords = 0; |
|
439 p = pstart; |
|
440 while ( p < (pstart+nbytes) ) { |
|
441 nrecords++; |
|
442 /*LINTED*/ |
|
443 npos = (int)(p - pstart); |
|
444 tag = read_u1(&p); |
|
445 switch ( tag ) { |
|
446 CASE_HEAP(HPROF_GC_ROOT_UNKNOWN) |
|
447 id = read_id(&p); |
|
448 break; |
|
449 CASE_HEAP(HPROF_GC_ROOT_JNI_GLOBAL) |
|
450 id = read_id(&p); |
|
451 id2 = read_id(&p); |
|
452 break; |
|
453 CASE_HEAP(HPROF_GC_ROOT_JNI_LOCAL) |
|
454 id = read_id(&p); |
|
455 thread_serial_num = read_u4(&p); |
|
456 fr = read_u4(&p); |
|
457 break; |
|
458 CASE_HEAP(HPROF_GC_ROOT_JAVA_FRAME) |
|
459 id = read_id(&p); |
|
460 thread_serial_num = read_u4(&p); |
|
461 fr = read_u4(&p); |
|
462 break; |
|
463 CASE_HEAP(HPROF_GC_ROOT_NATIVE_STACK) |
|
464 id = read_id(&p); |
|
465 thread_serial_num = read_u4(&p); |
|
466 break; |
|
467 CASE_HEAP(HPROF_GC_ROOT_STICKY_CLASS) |
|
468 id = read_id(&p); |
|
469 break; |
|
470 CASE_HEAP(HPROF_GC_ROOT_THREAD_BLOCK) |
|
471 id = read_id(&p); |
|
472 thread_serial_num = read_u4(&p); |
|
473 break; |
|
474 CASE_HEAP(HPROF_GC_ROOT_MONITOR_USED) |
|
475 id = read_id(&p); |
|
476 break; |
|
477 CASE_HEAP(HPROF_GC_ROOT_THREAD_OBJ) |
|
478 id = read_id(&p); |
|
479 thread_serial_num = read_u4(&p); |
|
480 trace_serial_num = read_u4(&p); |
|
481 break; |
|
482 CASE_HEAP(HPROF_GC_CLASS_DUMP) |
|
483 (void)memset((void*)&cmap, 0, sizeof(cmap)); |
|
484 id = read_id(&p); |
|
485 trace_serial_num = read_u4(&p); |
|
486 { |
|
487 HprofId ld, si, pr, re1, re2; |
|
488 |
|
489 sup = read_id(&p); |
|
490 ld = read_id(&p); |
|
491 si = read_id(&p); |
|
492 pr = read_id(&p); |
|
493 re1 = read_id(&p); |
|
494 re2 = read_id(&p); |
|
495 cmap.sup = sup; |
|
496 } |
|
497 inst_size = read_u4(&p); |
|
498 cmap.inst_size = inst_size; |
|
499 num_elements = read_u2(&p); |
|
500 for(i=0; i<num_elements; i++) { |
|
501 (void)read_u2(&p); |
|
502 ty = read_u1(&p); |
|
503 (void)read_val(&p, ty); |
|
504 } |
|
505 num_elements = read_u2(&p); |
|
506 for(i=0; i<num_elements; i++) { |
|
507 (void)read_id(&p); |
|
508 ty = read_u1(&p); |
|
509 (void)read_val(&p, ty); |
|
510 } |
|
511 num_elements = read_u2(&p); |
|
512 for(i=0; i<num_elements; i++) { |
|
513 HprofType ty; |
|
514 HprofId id; |
|
515 |
|
516 id = read_id(&p); |
|
517 ty = read_u1(&p); |
|
518 add_inst_field_to_cmap(&cmap, id, ty); |
|
519 } |
|
520 (void)table_create_entry(ctab, &id, sizeof(id), &cmap); |
|
521 break; |
|
522 CASE_HEAP(HPROF_GC_INSTANCE_DUMP) |
|
523 id = read_id(&p); |
|
524 trace_serial_num = read_u4(&p); |
|
525 id2 = read_id(&p); /* class id */ |
|
526 num_bytes = read_u4(&p); |
|
527 p += num_bytes; |
|
528 break; |
|
529 CASE_HEAP(HPROF_GC_OBJ_ARRAY_DUMP) |
|
530 id = read_id(&p); |
|
531 trace_serial_num = read_u4(&p); |
|
532 num_elements = read_u4(&p); |
|
533 id2 = read_id(&p); |
|
534 p += num_elements*(int)sizeof(HprofId); |
|
535 break; |
|
536 CASE_HEAP(HPROF_GC_PRIM_ARRAY_DUMP) |
|
537 id = read_id(&p); |
|
538 trace_serial_num = read_u4(&p); |
|
539 num_elements = read_u4(&p); |
|
540 ty = read_u1(&p); |
|
541 p += type_size[ty]*num_elements; |
|
542 break; |
|
543 default: |
|
544 label = "UNKNOWN"; |
|
545 check_printf("H#%d@%d %s: ERROR!\n", |
|
546 nrecords, npos, label); |
|
547 HPROF_ERROR(JNI_TRUE, "unknown heap record type"); |
|
548 break; |
|
549 } |
|
550 } |
|
551 CHECK_FOR_ERROR(p==pstart+nbytes); |
|
552 |
|
553 /* Scan again once we have our cmap */ |
|
554 nrecords = 0; |
|
555 p = pstart; |
|
556 while ( p < (pstart+nbytes) ) { |
|
557 nrecords++; |
|
558 /*LINTED*/ |
|
559 npos = (int)(p - pstart); |
|
560 tag = read_u1(&p); |
|
561 switch ( tag ) { |
|
562 CASE_HEAP(HPROF_GC_ROOT_UNKNOWN) |
|
563 id = read_id(&p); |
|
564 check_printf("H#%d@%d %s: id=0x%x\n", |
|
565 nrecords, npos, label, id); |
|
566 break; |
|
567 CASE_HEAP(HPROF_GC_ROOT_JNI_GLOBAL) |
|
568 id = read_id(&p); |
|
569 id2 = read_id(&p); |
|
570 check_printf("H#%d@%d %s: id=0x%x, id2=0x%x\n", |
|
571 nrecords, npos, label, id, id2); |
|
572 break; |
|
573 CASE_HEAP(HPROF_GC_ROOT_JNI_LOCAL) |
|
574 id = read_id(&p); |
|
575 thread_serial_num = read_u4(&p); |
|
576 fr = read_u4(&p); |
|
577 check_printf("H#%d@%d %s: id=0x%x, thread_serial_num=%u, fr=0x%x\n", |
|
578 nrecords, npos, label, id, thread_serial_num, fr); |
|
579 break; |
|
580 CASE_HEAP(HPROF_GC_ROOT_JAVA_FRAME) |
|
581 id = read_id(&p); |
|
582 thread_serial_num = read_u4(&p); |
|
583 fr = read_u4(&p); |
|
584 check_printf("H#%d@%d %s: id=0x%x, thread_serial_num=%u, fr=0x%x\n", |
|
585 nrecords, npos, label, id, thread_serial_num, fr); |
|
586 break; |
|
587 CASE_HEAP(HPROF_GC_ROOT_NATIVE_STACK) |
|
588 id = read_id(&p); |
|
589 thread_serial_num = read_u4(&p); |
|
590 check_printf("H#%d@%d %s: id=0x%x, thread_serial_num=%u\n", |
|
591 nrecords, npos, label, id, thread_serial_num); |
|
592 break; |
|
593 CASE_HEAP(HPROF_GC_ROOT_STICKY_CLASS) |
|
594 id = read_id(&p); |
|
595 check_printf("H#%d@%d %s: id=0x%x\n", |
|
596 nrecords, npos, label, id); |
|
597 break; |
|
598 CASE_HEAP(HPROF_GC_ROOT_THREAD_BLOCK) |
|
599 id = read_id(&p); |
|
600 thread_serial_num = read_u4(&p); |
|
601 check_printf("H#%d@%d %s: id=0x%x, thread_serial_num=%u\n", |
|
602 nrecords, npos, label, id, thread_serial_num); |
|
603 break; |
|
604 CASE_HEAP(HPROF_GC_ROOT_MONITOR_USED) |
|
605 id = read_id(&p); |
|
606 check_printf("H#%d@%d %s: id=0x%x\n", |
|
607 nrecords, npos, label, id); |
|
608 break; |
|
609 CASE_HEAP(HPROF_GC_ROOT_THREAD_OBJ) |
|
610 id = read_id(&p); |
|
611 thread_serial_num = read_u4(&p); |
|
612 trace_serial_num = read_u4(&p); |
|
613 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
614 check_printf("H#%d@%d %s: id=0x%x, thread_serial_num=%u," |
|
615 " trace_serial_num=%u\n", |
|
616 nrecords, npos, label, id, thread_serial_num, |
|
617 trace_serial_num); |
|
618 break; |
|
619 CASE_HEAP(HPROF_GC_CLASS_DUMP) |
|
620 id = read_id(&p); |
|
621 trace_serial_num = read_u4(&p); |
|
622 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
623 check_printf("H#%d@%d %s: id=0x%x, trace_serial_num=%u\n", |
|
624 nrecords, npos, label, id, trace_serial_num); |
|
625 { |
|
626 HprofId ld, si, pr, re1, re2; |
|
627 |
|
628 sup = read_id(&p); |
|
629 ld = read_id(&p); |
|
630 si = read_id(&p); |
|
631 pr = read_id(&p); |
|
632 re1 = read_id(&p); |
|
633 re2 = read_id(&p); |
|
634 check_printf(" su=0x%x, ld=0x%x, si=0x%x," |
|
635 " pr=0x%x, re1=0x%x, re2=0x%x\n", |
|
636 sup, ld, si, pr, re1, re2); |
|
637 } |
|
638 inst_size = read_u4(&p); |
|
639 check_printf(" instance_size=%d\n", inst_size); |
|
640 |
|
641 num_elements = read_u2(&p); |
|
642 for(i=0; i<num_elements; i++) { |
|
643 HprofType ty; |
|
644 unsigned cpi; |
|
645 jvalue val; |
|
646 |
|
647 cpi = read_u2(&p); |
|
648 ty = read_u1(&p); |
|
649 val = read_val(&p, ty); |
|
650 check_printf(" constant_pool %d: cpi=%d, ty=%d, val=", |
|
651 i, cpi, ty); |
|
652 check_printf_val(ty, val, 1); |
|
653 check_printf("\n"); |
|
654 } |
|
655 |
|
656 num_elements = read_u2(&p); |
|
657 check_printf(" static_field_count=%d\n", num_elements); |
|
658 for(i=0; i<num_elements; i++) { |
|
659 HprofType ty; |
|
660 HprofId id; |
|
661 jvalue val; |
|
662 |
|
663 id = read_id(&p); |
|
664 ty = read_u1(&p); |
|
665 val = read_val(&p, ty); |
|
666 check_printf(" static field %d: ", i); |
|
667 check_print_utf8(utab, "id=", id); |
|
668 check_printf(", ty=%d, val=", ty); |
|
669 check_printf_val(ty, val, 1); |
|
670 check_printf("\n"); |
|
671 } |
|
672 |
|
673 num_elements = read_u2(&p); |
|
674 check_printf(" instance_field_count=%d\n", num_elements); |
|
675 for(i=0; i<num_elements; i++) { |
|
676 HprofType ty; |
|
677 HprofId id; |
|
678 |
|
679 id = read_id(&p); |
|
680 ty = read_u1(&p); |
|
681 check_printf(" instance_field %d: ", i); |
|
682 check_print_utf8(utab, "id=", id); |
|
683 check_printf(", ty=%d\n", ty); |
|
684 } |
|
685 break; |
|
686 CASE_HEAP(HPROF_GC_INSTANCE_DUMP) |
|
687 id = read_id(&p); |
|
688 trace_serial_num = read_u4(&p); |
|
689 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
690 id2 = read_id(&p); /* class id */ |
|
691 num_bytes = read_u4(&p); |
|
692 check_printf("H#%d@%d %s: id=0x%x, trace_serial_num=%u," |
|
693 " cid=0x%x, nbytes=%d\n", |
|
694 nrecords, npos, label, id, trace_serial_num, |
|
695 id2, num_bytes); |
|
696 /* This is a packed set of bytes for the instance fields */ |
|
697 if ( num_bytes > 0 ) { |
|
698 TableIndex cindex; |
|
699 int ifield; |
|
700 CmapInfo *map; |
|
701 |
|
702 cindex = table_find_entry(ctab, &id2, sizeof(id2)); |
|
703 HPROF_ASSERT(cindex!=0); |
|
704 map = (CmapInfo*)table_get_info(ctab, cindex); |
|
705 HPROF_ASSERT(map!=NULL); |
|
706 HPROF_ASSERT(num_bytes==map->inst_size); |
|
707 |
|
708 psave = p; |
|
709 ifield = 0; |
|
710 |
|
711 do { |
|
712 for(i=0;i<map->n_finfo;i++) { |
|
713 HprofType ty; |
|
714 HprofId id; |
|
715 jvalue val; |
|
716 |
|
717 ty = map->finfo[i].ty; |
|
718 id = map->finfo[i].id; |
|
719 HPROF_ASSERT(ty!=0); |
|
720 HPROF_ASSERT(id!=0); |
|
721 val = read_val(&p, ty); |
|
722 check_printf(" field %d: ", ifield); |
|
723 check_print_utf8(utab, "id=", id); |
|
724 check_printf(", ty=%d, val=", ty); |
|
725 check_printf_val(ty, val, 1); |
|
726 check_printf("\n"); |
|
727 ifield++; |
|
728 } |
|
729 id2 = map->sup; |
|
730 map = NULL; |
|
731 cindex = 0; |
|
732 if ( id2 != 0 ) { |
|
733 cindex = table_find_entry(ctab, &id2, sizeof(id2)); |
|
734 HPROF_ASSERT(cindex!=0); |
|
735 map = (CmapInfo*)table_get_info(ctab, cindex); |
|
736 HPROF_ASSERT(map!=NULL); |
|
737 } |
|
738 } while ( map != NULL ); |
|
739 HPROF_ASSERT(num_bytes==(p-psave)); |
|
740 } |
|
741 break; |
|
742 CASE_HEAP(HPROF_GC_OBJ_ARRAY_DUMP) |
|
743 id = read_id(&p); |
|
744 trace_serial_num = read_u4(&p); |
|
745 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
746 num_elements = read_u4(&p); |
|
747 id2 = read_id(&p); |
|
748 check_printf("H#%d@%d %s: id=0x%x, trace_serial_num=%u, nelems=%d, eid=0x%x\n", |
|
749 nrecords, npos, label, id, trace_serial_num, num_elements, id2); |
|
750 for(i=0; i<num_elements; i++) { |
|
751 HprofId id; |
|
752 |
|
753 id = read_id(&p); |
|
754 check_printf(" [%d]: id=0x%x\n", i, id); |
|
755 } |
|
756 break; |
|
757 CASE_HEAP(HPROF_GC_PRIM_ARRAY_DUMP) |
|
758 id = read_id(&p); |
|
759 trace_serial_num = read_u4(&p); |
|
760 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
761 num_elements = read_u4(&p); |
|
762 ty = read_u1(&p); |
|
763 psave = p; |
|
764 check_printf("H#%d@%d %s: id=0x%x, trace_serial_num=%u, " |
|
765 "nelems=%d, ty=%d\n", |
|
766 nrecords, npos, label, id, trace_serial_num, num_elements, ty); |
|
767 HPROF_ASSERT(HPROF_TYPE_IS_PRIMITIVE(ty)); |
|
768 if ( num_elements > 0 ) { |
|
769 int count; |
|
770 int long_form; |
|
771 int max_count; |
|
772 char *quote; |
|
773 |
|
774 quote = ""; |
|
775 long_form = 1; |
|
776 max_count = 8; |
|
777 count = 0; |
|
778 switch ( ty ) { |
|
779 case HPROF_CHAR: |
|
780 long_form = 0; |
|
781 max_count = 72; |
|
782 quote = "\""; |
|
783 /*FALLTHRU*/ |
|
784 case HPROF_INT: |
|
785 case HPROF_DOUBLE: |
|
786 case HPROF_LONG: |
|
787 case HPROF_BYTE: |
|
788 case HPROF_BOOLEAN: |
|
789 case HPROF_SHORT: |
|
790 case HPROF_FLOAT: |
|
791 check_printf(" val=%s", quote); |
|
792 for(i=0; i<num_elements; i++) { |
|
793 jvalue val; |
|
794 |
|
795 if ( i > 0 && count == 0 ) { |
|
796 check_printf(" %s", quote); |
|
797 } |
|
798 val = read_val(&p, ty); |
|
799 check_printf_val(ty, val, long_form); |
|
800 count += 1; |
|
801 if ( count >= max_count ) { |
|
802 check_printf("\"\n"); |
|
803 count = 0; |
|
804 } |
|
805 } |
|
806 if ( count != 0 ) { |
|
807 check_printf("%s\n", quote); |
|
808 } |
|
809 break; |
|
810 } |
|
811 } |
|
812 HPROF_ASSERT(type_size[ty]*num_elements==(p-psave)); |
|
813 break; |
|
814 default: |
|
815 label = "UNKNOWN"; |
|
816 check_printf("H#%d@%d %s: ERROR!\n", |
|
817 nrecords, npos, label); |
|
818 HPROF_ERROR(JNI_TRUE, "unknown heap record type"); |
|
819 break; |
|
820 } |
|
821 } |
|
822 CHECK_FOR_ERROR(p==pstart+nbytes); |
|
823 |
|
824 table_cleanup(ctab, &cmap_cleanup, NULL); |
|
825 |
|
826 return nrecords; |
|
827 } |
|
828 |
|
829 /* LookupTable cleanup callback for utab */ |
|
830 static void |
|
831 utab_cleanup(TableIndex i, void *key_ptr, int key_len, void*info, void*data) |
|
832 { |
|
833 UmapInfo *umap = info; |
|
834 |
|
835 if ( umap == NULL ) { |
|
836 return; |
|
837 } |
|
838 if ( umap->str != NULL ) { |
|
839 HPROF_FREE(umap->str); |
|
840 umap->str = NULL; |
|
841 } |
|
842 } |
|
843 |
|
844 /* Check all the heap tags in a heap dump */ |
|
845 static int |
|
846 check_tags(unsigned char *pstart, int nbytes) |
|
847 { |
|
848 unsigned char *p; |
|
849 int nrecord; |
|
850 struct LookupTable *utab; |
|
851 UmapInfo umap; |
|
852 |
|
853 check_printf("\nCHECK TAGS: starting\n"); |
|
854 |
|
855 utab = table_initialize("temp utf8 map", 64, 64, 512, sizeof(UmapInfo)); |
|
856 |
|
857 /* Walk the tags, assumes UTF8 tags are defined before used */ |
|
858 p = pstart; |
|
859 nrecord = 0; |
|
860 while ( p < (pstart+nbytes) ) { |
|
861 unsigned tag; |
|
862 unsigned size; |
|
863 int nheap_records; |
|
864 int npos; |
|
865 char *label; |
|
866 HprofId id, nm, sg, so, gr, gn; |
|
867 int i, li, num_elements; |
|
868 HprofType ty; |
|
869 SerialNumber trace_serial_num; |
|
870 SerialNumber thread_serial_num; |
|
871 SerialNumber class_serial_num; |
|
872 unsigned flags; |
|
873 unsigned depth; |
|
874 float cutoff; |
|
875 unsigned temp; |
|
876 jint nblive; |
|
877 jint nilive; |
|
878 jlong tbytes; |
|
879 jlong tinsts; |
|
880 jint total_samples; |
|
881 jint trace_count; |
|
882 |
|
883 nrecord++; |
|
884 /*LINTED*/ |
|
885 npos = (int)(p - pstart); |
|
886 tag = read_u1(&p); |
|
887 (void)read_u4(&p); /* microsecs */ |
|
888 size = read_u4(&p); |
|
889 #define CASE_TAG(name) case name: label = #name; |
|
890 switch ( tag ) { |
|
891 CASE_TAG(HPROF_UTF8) |
|
892 CHECK_FOR_ERROR(size>=(int)sizeof(HprofId)); |
|
893 id = read_id(&p); |
|
894 check_printf("#%d@%d: %s, sz=%d, name_id=0x%x, \"", |
|
895 nrecord, npos, label, size, id); |
|
896 num_elements = size-(int)sizeof(HprofId); |
|
897 check_raw(p, num_elements); |
|
898 check_printf("\"\n"); |
|
899 /* Create entry in umap */ |
|
900 umap.str = HPROF_MALLOC(num_elements+1); |
|
901 (void)strncpy(umap.str, (char*)p, (size_t)num_elements); |
|
902 umap.str[num_elements] = 0; |
|
903 (void)table_create_entry(utab, &id, sizeof(id), &umap); |
|
904 p += num_elements; |
|
905 break; |
|
906 CASE_TAG(HPROF_LOAD_CLASS) |
|
907 CHECK_FOR_ERROR(size==2*4+2*(int)sizeof(HprofId)); |
|
908 class_serial_num = read_u4(&p); |
|
909 CHECK_CLASS_SERIAL_NO(class_serial_num); |
|
910 id = read_id(&p); |
|
911 trace_serial_num = read_u4(&p); |
|
912 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
913 nm = read_id(&p); |
|
914 check_printf("#%d@%d: %s, sz=%d, class_serial_num=%u," |
|
915 " id=0x%x, trace_serial_num=%u, name_id=0x%x\n", |
|
916 nrecord, npos, label, size, class_serial_num, |
|
917 id, trace_serial_num, nm); |
|
918 break; |
|
919 CASE_TAG(HPROF_UNLOAD_CLASS) |
|
920 CHECK_FOR_ERROR(size==4); |
|
921 class_serial_num = read_u4(&p); |
|
922 CHECK_CLASS_SERIAL_NO(class_serial_num); |
|
923 check_printf("#%d@%d: %s, sz=%d, class_serial_num=%u\n", |
|
924 nrecord, npos, label, size, class_serial_num); |
|
925 break; |
|
926 CASE_TAG(HPROF_FRAME) |
|
927 CHECK_FOR_ERROR(size==2*4+4*(int)sizeof(HprofId)); |
|
928 id = read_id(&p); |
|
929 nm = read_id(&p); |
|
930 sg = read_id(&p); |
|
931 so = read_id(&p); |
|
932 class_serial_num = read_u4(&p); |
|
933 CHECK_CLASS_SERIAL_NO(class_serial_num); |
|
934 li = read_u4(&p); |
|
935 check_printf("#%d@%d: %s, sz=%d, ", nrecord, npos, label, size); |
|
936 check_print_utf8(utab, "id=", id); |
|
937 check_printf(" name_id=0x%x, sig_id=0x%x, source_id=0x%x," |
|
938 " class_serial_num=%u, lineno=%d\n", |
|
939 nm, sg, so, class_serial_num, li); |
|
940 break; |
|
941 CASE_TAG(HPROF_TRACE) |
|
942 CHECK_FOR_ERROR(size>=3*4); |
|
943 trace_serial_num = read_u4(&p); |
|
944 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
945 thread_serial_num = read_u4(&p); /* Can be 0 */ |
|
946 num_elements = read_u4(&p); |
|
947 check_printf("#%d@%d: %s, sz=%d, trace_serial_num=%u," |
|
948 " thread_serial_num=%u, nelems=%d [", |
|
949 nrecord, npos, label, size, |
|
950 trace_serial_num, thread_serial_num, num_elements); |
|
951 for(i=0; i< num_elements; i++) { |
|
952 check_printf("0x%x,", read_id(&p)); |
|
953 } |
|
954 check_printf("]\n"); |
|
955 break; |
|
956 CASE_TAG(HPROF_ALLOC_SITES) |
|
957 CHECK_FOR_ERROR(size>=2+4*4+2*8); |
|
958 flags = read_u2(&p); |
|
959 temp = read_u4(&p); |
|
960 cutoff = *((float*)&temp); |
|
961 nblive = read_u4(&p); |
|
962 nilive = read_u4(&p); |
|
963 tbytes = read_u8(&p); |
|
964 tinsts = read_u8(&p); |
|
965 num_elements = read_u4(&p); |
|
966 check_printf("#%d@%d: %s, sz=%d, flags=0x%x, cutoff=%g," |
|
967 " nblive=%d, nilive=%d, tbytes=(%d,%d)," |
|
968 " tinsts=(%d,%d), num_elements=%d\n", |
|
969 nrecord, npos, label, size, |
|
970 flags, cutoff, nblive, nilive, |
|
971 jlong_high(tbytes), jlong_low(tbytes), |
|
972 jlong_high(tinsts), jlong_low(tinsts), |
|
973 num_elements); |
|
974 for(i=0; i< num_elements; i++) { |
|
975 ty = read_u1(&p); |
|
976 class_serial_num = read_u4(&p); |
|
977 CHECK_CLASS_SERIAL_NO(class_serial_num); |
|
978 trace_serial_num = read_u4(&p); |
|
979 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
980 nblive = read_u4(&p); |
|
981 nilive = read_u4(&p); |
|
982 tbytes = read_u4(&p); |
|
983 tinsts = read_u4(&p); |
|
984 check_printf("\t %d: ty=%d, class_serial_num=%u," |
|
985 " trace_serial_num=%u, nblive=%d, nilive=%d," |
|
986 " tbytes=%d, tinsts=%d\n", |
|
987 i, ty, class_serial_num, trace_serial_num, |
|
988 nblive, nilive, (jint)tbytes, (jint)tinsts); |
|
989 } |
|
990 break; |
|
991 CASE_TAG(HPROF_HEAP_SUMMARY) |
|
992 CHECK_FOR_ERROR(size==2*4+2*8); |
|
993 nblive = read_u4(&p); |
|
994 nilive = read_u4(&p); |
|
995 tbytes = read_u8(&p); |
|
996 tinsts = read_u8(&p); |
|
997 check_printf("#%d@%d: %s, sz=%d," |
|
998 " nblive=%d, nilive=%d, tbytes=(%d,%d)," |
|
999 " tinsts=(%d,%d)\n", |
|
1000 nrecord, npos, label, size, |
|
1001 nblive, nilive, |
|
1002 jlong_high(tbytes), jlong_low(tbytes), |
|
1003 jlong_high(tinsts), jlong_low(tinsts)); |
|
1004 break; |
|
1005 CASE_TAG(HPROF_START_THREAD) |
|
1006 CHECK_FOR_ERROR(size==2*4+4*(int)sizeof(HprofId)); |
|
1007 thread_serial_num = read_u4(&p); |
|
1008 CHECK_THREAD_SERIAL_NO(thread_serial_num); |
|
1009 id = read_id(&p); |
|
1010 trace_serial_num = read_u4(&p); |
|
1011 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
1012 nm = read_id(&p); |
|
1013 gr = read_id(&p); |
|
1014 gn = read_id(&p); |
|
1015 check_printf("#%d@%d: %s, sz=%d, thread_serial_num=%u," |
|
1016 " id=0x%x, trace_serial_num=%u, ", |
|
1017 nrecord, npos, label, size, |
|
1018 thread_serial_num, id, trace_serial_num); |
|
1019 check_print_utf8(utab, "nm=", id); |
|
1020 check_printf(" trace_serial_num=%u, nm=0x%x," |
|
1021 " gr=0x%x, gn=0x%x\n", |
|
1022 trace_serial_num, nm, gr, gn); |
|
1023 break; |
|
1024 CASE_TAG(HPROF_END_THREAD) |
|
1025 CHECK_FOR_ERROR(size==4); |
|
1026 thread_serial_num = read_u4(&p); |
|
1027 CHECK_THREAD_SERIAL_NO(thread_serial_num); |
|
1028 check_printf("#%d@%d: %s, sz=%d, thread_serial_num=%u\n", |
|
1029 nrecord, npos, label, size, thread_serial_num); |
|
1030 break; |
|
1031 CASE_TAG(HPROF_HEAP_DUMP) |
|
1032 check_printf("#%d@%d: BEGIN: %s, sz=%d\n", |
|
1033 nrecord, npos, label, size); |
|
1034 nheap_records = check_heap_tags(utab, p, size); |
|
1035 check_printf("#%d@%d: END: %s, sz=%d, nheap_recs=%d\n", |
|
1036 nrecord, npos, label, size, nheap_records); |
|
1037 p += size; |
|
1038 break; |
|
1039 CASE_TAG(HPROF_HEAP_DUMP_SEGMENT) /* 1.0.2 */ |
|
1040 check_printf("#%d@%d: BEGIN SEGMENT: %s, sz=%d\n", |
|
1041 nrecord, npos, label, size); |
|
1042 nheap_records = check_heap_tags(utab, p, size); |
|
1043 check_printf("#%d@%d: END SEGMENT: %s, sz=%d, nheap_recs=%d\n", |
|
1044 nrecord, npos, label, size, nheap_records); |
|
1045 p += size; |
|
1046 break; |
|
1047 CASE_TAG(HPROF_HEAP_DUMP_END) /* 1.0.2 */ |
|
1048 check_printf("#%d@%d: SEGMENT END: %s, sz=%d\n", |
|
1049 nrecord, npos, label, size); |
|
1050 break; |
|
1051 CASE_TAG(HPROF_CPU_SAMPLES) |
|
1052 CHECK_FOR_ERROR(size>=2*4); |
|
1053 total_samples = read_u4(&p); |
|
1054 trace_count = read_u4(&p); |
|
1055 check_printf("#%d@%d: %s, sz=%d, total_samples=%d," |
|
1056 " trace_count=%d\n", |
|
1057 nrecord, npos, label, size, |
|
1058 total_samples, trace_count); |
|
1059 for(i=0; i< trace_count; i++) { |
|
1060 num_elements = read_u4(&p); |
|
1061 trace_serial_num = read_u4(&p); |
|
1062 CHECK_TRACE_SERIAL_NO(trace_serial_num); |
|
1063 check_printf("\t %d: samples=%d, trace_serial_num=%u\n", |
|
1064 trace_serial_num, num_elements); |
|
1065 } |
|
1066 break; |
|
1067 CASE_TAG(HPROF_CONTROL_SETTINGS) |
|
1068 CHECK_FOR_ERROR(size==4+2); |
|
1069 flags = read_u4(&p); |
|
1070 depth = read_u2(&p); |
|
1071 check_printf("#%d@%d: %s, sz=%d, flags=0x%x, depth=%d\n", |
|
1072 nrecord, npos, label, size, flags, depth); |
|
1073 break; |
|
1074 default: |
|
1075 label = "UNKNOWN"; |
|
1076 check_printf("#%d@%d: %s, sz=%d\n", |
|
1077 nrecord, npos, label, size); |
|
1078 HPROF_ERROR(JNI_TRUE, "unknown record type"); |
|
1079 p += size; |
|
1080 break; |
|
1081 } |
|
1082 CHECK_FOR_ERROR(p<=(pstart+nbytes)); |
|
1083 } |
|
1084 check_flush(); |
|
1085 CHECK_FOR_ERROR(p==(pstart+nbytes)); |
|
1086 table_cleanup(utab, &utab_cleanup, NULL); |
|
1087 return nrecord; |
|
1088 } |
|
1089 |
|
1090 /* Read the entire file into memory */ |
|
1091 static void * |
|
1092 get_binary_file_image(char *filename, int *pnbytes) |
|
1093 { |
|
1094 unsigned char *image; |
|
1095 int fd; |
|
1096 jlong nbytes; |
|
1097 int nread; |
|
1098 |
|
1099 *pnbytes = 0; |
|
1100 fd = md_open_binary(filename); |
|
1101 CHECK_FOR_ERROR(fd>=0); |
|
1102 if ( (nbytes = md_seek(fd, (jlong)-1)) == (jlong)-1 ) { |
|
1103 HPROF_ERROR(JNI_TRUE, "Cannot md_seek() to end of file"); |
|
1104 } |
|
1105 CHECK_FOR_ERROR(((jint)nbytes)>512); |
|
1106 if ( md_seek(fd, (jlong)0) != (jlong)0 ) { |
|
1107 HPROF_ERROR(JNI_TRUE, "Cannot md_seek() to start of file"); |
|
1108 } |
|
1109 image = HPROF_MALLOC(((jint)nbytes)+1); |
|
1110 CHECK_FOR_ERROR(image!=NULL); |
|
1111 |
|
1112 /* Read the entire file image into memory */ |
|
1113 nread = md_read(fd, image, (jint)nbytes); |
|
1114 if ( nread <= 0 ) { |
|
1115 HPROF_ERROR(JNI_TRUE, "System read failed."); |
|
1116 } |
|
1117 CHECK_FOR_ERROR(((jint)nbytes)==nread); |
|
1118 md_close(fd); |
|
1119 *pnbytes = (jint)nbytes; |
|
1120 return image; |
|
1121 } |
|
1122 |
|
1123 /* ------------------------------------------------------------------ */ |
|
1124 |
|
1125 void |
|
1126 check_binary_file(char *filename) |
|
1127 { |
|
1128 unsigned char *image; |
|
1129 unsigned char *p; |
|
1130 unsigned idsize; |
|
1131 int nbytes; |
|
1132 int nrecords; |
|
1133 |
|
1134 image = get_binary_file_image(filename, &nbytes); |
|
1135 if ( image == NULL ) { |
|
1136 check_printf("No file image: %s\n", filename); |
|
1137 return; |
|
1138 } |
|
1139 p = image; |
|
1140 CHECK_FOR_ERROR(strcmp((char*)p, gdata->header)==0); |
|
1141 check_printf("Filename=%s, nbytes=%d, header=\"%s\"\n", |
|
1142 filename, nbytes, p); |
|
1143 p+=((int)strlen((char*)p)+1); |
|
1144 idsize = read_u4(&p); |
|
1145 CHECK_FOR_ERROR(idsize==sizeof(HprofId)); |
|
1146 (void)read_u4(&p); |
|
1147 (void)read_u4(&p); |
|
1148 /* LINTED */ |
|
1149 nrecords = check_tags(p, nbytes - (int)( p - image ) ); |
|
1150 check_printf("#%d total records found in %d bytes\n", nrecords, nbytes); |
|
1151 HPROF_FREE(image); |
|
1152 } |