1 /*

     2  * Copyright (c) 2003, 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 /* All I/O functionality for hprof. */

    42 

    43 /*

    44  * The hprof agent has many forms of output:

    45  *

    46  *   format=b   gdata->output_format=='b'

    47  *      Binary format. Defined below. This is used by HAT.

    48  *      This is NOT the same format as emitted by JVMPI.

    49  *

    50  *   format=a   gdata->output_format=='a'

    51  *      Ascii format. Not exactly an ascii representation of the binary format.

    52  *

    53  * And many forms of dumps:

    54  *

    55  *    heap=dump

    56  *        A large dump that in this implementation is written to a separate

    57  *        file first before being placed in the output file. Several reasons,

    58  *        the binary form needs a byte count of the length in the header, and

    59  *        references in this dump to other items need to be emitted first.

    60  *        So it's two pass, or use a temp file and copy.

    61  *    heap=sites

    62  *        Dumps the sites in the order of most allocations.

    63  *    cpu=samples

    64  *        Dumps the traces in order of most hits

    65  *    cpu=times

    66  *        Dumps the traces in the order of most time spent there.

    67  *    cpu=old   (format=a only)

    68  *        Dumps out an older form of cpu output (old -prof format)

    69  *    monitor=y (format=a only)

    70  *        Dumps out a list of monitors in order of most contended.

    71  *

    72  * This file also includes a binary format check function that will read

    73  *   back in the hprof binary format and verify the syntax looks correct.

    74  *

    75  * WARNING: Besides the comments below, there is little format spec on this,

    76  *          however see:

    77  *           http://java.sun.com/j2se/1.4.2/docs/guide/jvmpi/jvmpi.html#hprof

    78  */

    79 

    80 #include "hprof.h"

    81 

    82 typedef TableIndex HprofId;

    83 

    84 #include "hprof_ioname.h"

    85 #include "hprof_b_spec.h"

    86 

    87 static int type_size[ /*HprofType*/ ] =  HPROF_TYPE_SIZES;

    88 

    89 static void dump_heap_segment_and_reset(jlong segment_size);

    90 

    91 static void

    92 not_implemented(void)

    93 {

    94 }

    95 

    96 static IoNameIndex

    97 get_name_index(char *name)

    98 {

    99     if (name != NULL && gdata->output_format == 'b') {

   100         return ioname_find_or_create(name, NULL);

   101     }

   102     return 0;

   103 }

   104 

   105 static char *

   106 signature_to_name(char *sig)

   107 {

   108     char *ptr;

   109     char *basename;

   110     char *name;

   111     int i;

   112     int len;

   113     int name_len;

   114 

   115     if ( sig != NULL ) {

   116         switch ( sig[0] ) {

   117             case JVM_SIGNATURE_CLASS:

   118                 ptr = strchr(sig+1, JVM_SIGNATURE_ENDCLASS);

   119                 if ( ptr == NULL ) {

   120                     basename = "Unknown_class";

   121                     break;

   122                 }

   123                 /*LINTED*/

   124                 name_len = (jint)(ptr - (sig+1));

   125                 name = HPROF_MALLOC(name_len+1);

   126                 (void)memcpy(name, sig+1, name_len);

   127                 name[name_len] = 0;

   128                 for ( i = 0 ; i < name_len ; i++ ) {

   129                     if ( name[i] == '/' ) name[i] = '.';

   130                 }

   131                 return name;

   132             case JVM_SIGNATURE_ARRAY:

   133                 basename = signature_to_name(sig+1);

   134                 len = (int)strlen(basename);

   135                 name_len = len+2;

   136                 name = HPROF_MALLOC(name_len+1);

   137                 (void)memcpy(name, basename, len);

   138                 (void)memcpy(name+len, "[]", 2);

   139                 name[name_len] = 0;

   140                 HPROF_FREE(basename);

   141                 return name;

   142             case JVM_SIGNATURE_FUNC:

   143                 ptr = strchr(sig+1, JVM_SIGNATURE_ENDFUNC);

   144                 if ( ptr == NULL ) {

   145                     basename = "Unknown_method";

   146                     break;

   147                 }

   148                 basename = "()"; /* Someday deal with method signatures */

   149                 break;

   150             case JVM_SIGNATURE_BYTE:

   151                 basename = "byte";

   152                 break;

   153             case JVM_SIGNATURE_CHAR:

   154                 basename = "char";

   155                 break;

   156             case JVM_SIGNATURE_ENUM:

   157                 basename = "enum";

   158                 break;

   159             case JVM_SIGNATURE_FLOAT:

   160                 basename = "float";

   161                 break;

   162             case JVM_SIGNATURE_DOUBLE:

   163                 basename = "double";

   164                 break;

   165             case JVM_SIGNATURE_INT:

   166                 basename = "int";

   167                 break;

   168             case JVM_SIGNATURE_LONG:

   169                 basename = "long";

   170                 break;

   171             case JVM_SIGNATURE_SHORT:

   172                 basename = "short";

   173                 break;

   174             case JVM_SIGNATURE_VOID:

   175                 basename = "void";

   176                 break;

   177             case JVM_SIGNATURE_BOOLEAN:

   178                 basename = "boolean";

   179                 break;

   180             default:

   181                 basename = "Unknown_class";

   182                 break;

   183         }

   184     } else {

   185         basename = "Unknown_class";

   186     }

   187 

   188     /* Simple basename */

   189     name_len = (int)strlen(basename);

   190     name = HPROF_MALLOC(name_len+1);

   191     (void)strcpy(name, basename);

   192     return name;

   193 }

   194 

   195 static int

   196 size_from_field_info(int size)

   197 {

   198     if ( size == 0 ) {

   199         size = (int)sizeof(HprofId);

   200     }

   201     return size;

   202 }

   203 

   204 static void

   205 type_from_signature(const char *sig, HprofType *kind, jint *size)

   206 {

   207     *kind = HPROF_NORMAL_OBJECT;

   208     *size = 0;

   209     switch ( sig[0] ) {

   210         case JVM_SIGNATURE_ENUM:

   211         case JVM_SIGNATURE_CLASS:

   212         case JVM_SIGNATURE_ARRAY:

   213             *kind = HPROF_NORMAL_OBJECT;

   214             break;

   215         case JVM_SIGNATURE_BOOLEAN:

   216             *kind = HPROF_BOOLEAN;

   217             break;

   218         case JVM_SIGNATURE_CHAR:

   219             *kind = HPROF_CHAR;

   220             break;

   221         case JVM_SIGNATURE_FLOAT:

   222             *kind = HPROF_FLOAT;

   223             break;

   224         case JVM_SIGNATURE_DOUBLE:

   225             *kind = HPROF_DOUBLE;

   226             break;

   227         case JVM_SIGNATURE_BYTE:

   228             *kind = HPROF_BYTE;

   229             break;

   230         case JVM_SIGNATURE_SHORT:

   231             *kind = HPROF_SHORT;

   232             break;

   233         case JVM_SIGNATURE_INT:

   234             *kind = HPROF_INT;

   235             break;

   236         case JVM_SIGNATURE_LONG:

   237             *kind = HPROF_LONG;

   238             break;

   239         default:

   240             HPROF_ASSERT(0);

   241             break;

   242     }

   243     *size = type_size[*kind];

   244 }

   245 

   246 static void

   247 type_array(const char *sig, HprofType *kind, jint *elem_size)

   248 {

   249     *kind = 0;

   250     *elem_size = 0;

   251     switch ( sig[0] ) {

   252         case JVM_SIGNATURE_ARRAY:

   253             type_from_signature(sig+1, kind, elem_size);

   254             break;

   255     }

   256 }

   257 

   258 static void

   259 system_error(const char *system_call, int rc, int errnum)

   260 {

   261     char buf[256];

   262     char details[256];

   263 

   264     details[0] = 0;

   265     if ( errnum != 0 ) {

   266         md_system_error(details, (int)sizeof(details));

   267     } else if ( rc >= 0 ) {

   268         (void)strcpy(details,"Only part of buffer processed");

   269     }

   270     if ( details[0] == 0 ) {

   271         (void)strcpy(details,"Unknown system error condition");

   272     }

   273     (void)md_snprintf(buf, sizeof(buf), "System %s failed: %s\n",

   274                             system_call, details);

   275     HPROF_ERROR(JNI_TRUE, buf);

   276 }

   277 

   278 static void

   279 system_write(int fd, void *buf, int len, jboolean socket)

   280 {

   281     int res;

   282 

   283     HPROF_ASSERT(fd>=0);

   284     if (socket) {

   285         res = md_send(fd, buf, len, 0);

   286         if (res < 0 || res!=len) {

   287             system_error("send", res, errno);

   288         }

   289     } else {

   290         res = md_write(fd, buf, len);

   291         if (res < 0 || res!=len) {

   292             system_error("write", res, errno);

   293         }

   294     }

   295 }

   296 

   297 static void

   298 write_flush(void)

   299 {

   300     HPROF_ASSERT(gdata->fd >= 0);

   301     if (gdata->write_buffer_index) {

   302         system_write(gdata->fd, gdata->write_buffer, gdata->write_buffer_index,

   303                                 gdata->socket);

   304         gdata->write_buffer_index = 0;

   305     }

   306 }

   307 

   308 static void

   309 heap_flush(void)

   310 {

   311     HPROF_ASSERT(gdata->heap_fd >= 0);

   312     if (gdata->heap_buffer_index) {

   313         gdata->heap_write_count += (jlong)gdata->heap_buffer_index;

   314         system_write(gdata->heap_fd, gdata->heap_buffer, gdata->heap_buffer_index,

   315                                 JNI_FALSE);

   316         gdata->heap_buffer_index = 0;

   317     }

   318 }

   319 

   320 static void

   321 write_raw(void *buf, int len)

   322 {

   323     HPROF_ASSERT(gdata->fd >= 0);

   324     if (gdata->write_buffer_index + len > gdata->write_buffer_size) {

   325         write_flush();

   326         if (len > gdata->write_buffer_size) {

   327             system_write(gdata->fd, buf, len, gdata->socket);

   328             return;

   329         }

   330     }

   331     (void)memcpy(gdata->write_buffer + gdata->write_buffer_index, buf, len);

   332     gdata->write_buffer_index += len;

   333 }

   334 

   335 static void

   336 write_u4(unsigned i)

   337 {

   338     i = md_htonl(i);

   339     write_raw(&i, (jint)sizeof(unsigned));

   340 }

   341 

   342 static void

   343 write_u8(jlong t)

   344 {

   345     write_u4((jint)jlong_high(t));

   346     write_u4((jint)jlong_low(t));

   347 }

   348 

   349 static void

   350 write_u2(unsigned short i)

   351 {

   352     i = md_htons(i);

   353     write_raw(&i, (jint)sizeof(unsigned short));

   354 }

   355 

   356 static void

   357 write_u1(unsigned char i)

   358 {

   359     write_raw(&i, (jint)sizeof(unsigned char));

   360 }

   361 

   362 static void

   363 write_id(HprofId i)

   364 {

   365     write_u4(i);

   366 }

   367 

   368 static void

   369 write_current_ticks(void)

   370 {

   371     write_u4((jint)(md_get_microsecs() - gdata->micro_sec_ticks));

   372 }

   373 

   374 static void

   375 write_header(unsigned char type, jint length)

   376 {

   377     write_u1(type);

   378     write_current_ticks();

   379     write_u4(length);

   380 }

   381 

   382 static void

   383 write_index_id(HprofId index)

   384 {

   385     write_id(index);

   386 }

   387 

   388 static IoNameIndex

   389 write_name_first(char *name)

   390 {

   391     if ( name == NULL ) {

   392         return 0;

   393     }

   394     if (gdata->output_format == 'b') {

   395         IoNameIndex name_index;

   396         jboolean    new_one;

   397 

   398         new_one = JNI_FALSE;

   399         name_index = ioname_find_or_create(name, &new_one);

   400         if ( new_one ) {

   401             int      len;

   402 

   403             len = (int)strlen(name);

   404             write_header(HPROF_UTF8, len + (jint)sizeof(HprofId));

   405             write_index_id(name_index);

   406             write_raw(name, len);

   407 

   408         }

   409         return name_index;

   410     }

   411     return 0;

   412 }

   413 

   414 static void

   415 write_printf(char *fmt, ...)

   416 {

   417     char buf[1024];

   418     va_list args;

   419     va_start(args, fmt);

   420     (void)md_vsnprintf(buf, sizeof(buf), fmt, args);

   421     buf[sizeof(buf)-1] = 0;

   422     write_raw(buf, (int)strlen(buf));

   423     va_end(args);

   424 }

   425 

   426 static void

   427 write_thread_serial_number(SerialNumber thread_serial_num, int with_comma)

   428 {

   429     if ( thread_serial_num != 0 ) {

   430         CHECK_THREAD_SERIAL_NO(thread_serial_num);

   431         if ( with_comma ) {

   432             write_printf(" thread %d,", thread_serial_num);

   433         } else {

   434             write_printf(" thread %d", thread_serial_num);

   435         }

   436     } else {

   437         if ( with_comma ) {

   438             write_printf(" <unknown thread>,");

   439         } else {

   440             write_printf(" <unknown thread>");

   441         }

   442     }

   443 }

   444 

   445 static void

   446 heap_raw(void *buf, int len)

   447 {

   448     HPROF_ASSERT(gdata->heap_fd >= 0);

   449     if (gdata->heap_buffer_index + len > gdata->heap_buffer_size) {

   450         heap_flush();

   451         if (len > gdata->heap_buffer_size) {

   452             gdata->heap_write_count += (jlong)len;

   453             system_write(gdata->heap_fd, buf, len, JNI_FALSE);

   454             return;

   455         }

   456     }

   457     (void)memcpy(gdata->heap_buffer + gdata->heap_buffer_index, buf, len);

   458     gdata->heap_buffer_index += len;

   459 }

   460 

   461 static void

   462 heap_u4(unsigned i)

   463 {

   464     i = md_htonl(i);

   465     heap_raw(&i, (jint)sizeof(unsigned));

   466 }

   467 

   468 static void

   469 heap_u8(jlong i)

   470 {

   471     heap_u4((jint)jlong_high(i));

   472     heap_u4((jint)jlong_low(i));

   473 }

   474 

   475 static void

   476 heap_u2(unsigned short i)

   477 {

   478     i = md_htons(i);

   479     heap_raw(&i, (jint)sizeof(unsigned short));

   480 }

   481 

   482 static void

   483 heap_u1(unsigned char i)

   484 {

   485     heap_raw(&i, (jint)sizeof(unsigned char));

   486 }

   487 

   488 /* Write out the first byte of a heap tag */

   489 static void

   490 heap_tag(unsigned char tag)

   491 {

   492     jlong pos;

   493 

   494     /* Current position in virtual heap dump file */

   495     pos = gdata->heap_write_count + (jlong)gdata->heap_buffer_index;

   496     if ( gdata->segmented == JNI_TRUE ) { /* 1.0.2 */

   497         if ( pos >= gdata->maxHeapSegment ) {

   498             /* Flush all bytes to the heap dump file */

   499             heap_flush();

   500 

   501             /* Send out segment (up to last tag written out) */

   502             dump_heap_segment_and_reset(gdata->heap_last_tag_position);

   503 

   504             /* Get new current position */

   505             pos = gdata->heap_write_count + (jlong)gdata->heap_buffer_index;

   506         }

   507     }

   508     /* Save position of this tag */

   509     gdata->heap_last_tag_position = pos;

   510     /* Write out this tag */

   511     heap_u1(tag);

   512 }

   513 

   514 static void

   515 heap_id(HprofId i)

   516 {

   517     heap_u4(i);

   518 }

   519 

   520 static void

   521 heap_index_id(HprofId index)

   522 {

   523     heap_id(index);

   524 }

   525 

   526 static void

   527 heap_name(char *name)

   528 {

   529     heap_index_id(get_name_index(name));

   530 }

   531 

   532 static void

   533 heap_printf(char *fmt, ...)

   534 {

   535     char buf[1024];

   536     va_list args;

   537     va_start(args, fmt);

   538     (void)md_vsnprintf(buf, sizeof(buf), fmt, args);

   539     buf[sizeof(buf)-1] = 0;

   540     heap_raw(buf, (int)strlen(buf));

   541     va_end(args);

   542 }

   543 

   544 static void

   545 heap_element(HprofType kind, jint size, jvalue value)

   546 {

   547     if ( !HPROF_TYPE_IS_PRIMITIVE(kind) ) {

   548         HPROF_ASSERT(size==4);

   549         heap_id((HprofId)value.i);

   550     } else {

   551         switch ( size ) {

   552             case 8:

   553                 HPROF_ASSERT(size==8);

   554                 HPROF_ASSERT(kind==HPROF_LONG || kind==HPROF_DOUBLE);

   555                 heap_u8(value.j);

   556                 break;

   557             case 4:

   558                 HPROF_ASSERT(size==4);

   559                 HPROF_ASSERT(kind==HPROF_INT || kind==HPROF_FLOAT);

   560                 heap_u4(value.i);

   561                 break;

   562             case 2:

   563                 HPROF_ASSERT(size==2);

   564                 HPROF_ASSERT(kind==HPROF_SHORT || kind==HPROF_CHAR);

   565                 heap_u2(value.s);

   566                 break;

   567             case 1:

   568                 HPROF_ASSERT(size==1);

   569                 HPROF_ASSERT(kind==HPROF_BOOLEAN || kind==HPROF_BYTE);

   570                 HPROF_ASSERT(kind==HPROF_BOOLEAN?(value.b==0 || value.b==1):1);

   571                 heap_u1(value.b);

   572                 break;

   573             default:

   574                 HPROF_ASSERT(0);

   575                 break;

   576         }

   577     }

   578 }

   579 

   580 /* Dump out all elements of an array, objects in jvalues, prims packed */

   581 static void

   582 heap_elements(HprofType kind, jint num_elements, jint elem_size, void *elements)

   583 {

   584     int     i;

   585     jvalue  val;

   586     static jvalue empty_val;

   587 

   588     if ( num_elements == 0 ) {

   589         return;

   590     }

   591 

   592     switch ( kind ) {

   593         case 0:

   594         case HPROF_ARRAY_OBJECT:

   595         case HPROF_NORMAL_OBJECT:

   596             for (i = 0; i < num_elements; i++) {

   597                 val   = empty_val;

   598                 val.i = ((ObjectIndex*)elements)[i];

   599                 heap_element(kind, elem_size, val);

   600             }

   601             break;

   602         case HPROF_BYTE:

   603         case HPROF_BOOLEAN:

   604             HPROF_ASSERT(elem_size==1);

   605             for (i = 0; i < num_elements; i++) {

   606                 val   = empty_val;

   607                 val.b = ((jboolean*)elements)[i];

   608                 heap_element(kind, elem_size, val);

   609             }

   610             break;

   611         case HPROF_CHAR:

   612         case HPROF_SHORT:

   613             HPROF_ASSERT(elem_size==2);

   614             for (i = 0; i < num_elements; i++) {

   615                 val   = empty_val;

   616                 val.s = ((jshort*)elements)[i];

   617                 heap_element(kind, elem_size, val);

   618             }

   619             break;

   620         case HPROF_FLOAT:

   621         case HPROF_INT:

   622             HPROF_ASSERT(elem_size==4);

   623             for (i = 0; i < num_elements; i++) {

   624                 val   = empty_val;

   625                 val.i = ((jint*)elements)[i];

   626                 heap_element(kind, elem_size, val);

   627             }

   628             break;

   629         case HPROF_DOUBLE:

   630         case HPROF_LONG:

   631             HPROF_ASSERT(elem_size==8);

   632             for (i = 0; i < num_elements; i++) {

   633                 val   = empty_val;

   634                 val.j = ((jlong*)elements)[i];

   635                 heap_element(kind, elem_size, val);

   636             }

   637             break;

   638     }

   639 }

   640 

   641 /* ------------------------------------------------------------------ */

   642 

   643 void

   644 io_flush(void)

   645 {

   646     HPROF_ASSERT(gdata->header!=NULL);

   647     write_flush();

   648 }

   649 

   650 void

   651 io_setup(void)

   652 {

   653     gdata->write_buffer_size = FILE_IO_BUFFER_SIZE;

   654     gdata->write_buffer = HPROF_MALLOC(gdata->write_buffer_size);

   655     gdata->write_buffer_index = 0;

   656 

   657     gdata->heap_write_count = (jlong)0;

   658     gdata->heap_last_tag_position = (jlong)0;

   659     gdata->heap_buffer_size = FILE_IO_BUFFER_SIZE;

   660     gdata->heap_buffer = HPROF_MALLOC(gdata->heap_buffer_size);

   661     gdata->heap_buffer_index = 0;

   662 

   663     if ( gdata->logflags & LOG_CHECK_BINARY ) {

   664         gdata->check_buffer_size = FILE_IO_BUFFER_SIZE;

   665         gdata->check_buffer = HPROF_MALLOC(gdata->check_buffer_size);

   666         gdata->check_buffer_index = 0;

   667     }

   668 

   669     ioname_init();

   670 }

   671 

   672 void

   673 io_cleanup(void)

   674 {

   675     if ( gdata->write_buffer != NULL ) {

   676         HPROF_FREE(gdata->write_buffer);

   677     }

   678     gdata->write_buffer_size = 0;

   679     gdata->write_buffer = NULL;

   680     gdata->write_buffer_index = 0;

   681 

   682     if ( gdata->heap_buffer != NULL ) {

   683         HPROF_FREE(gdata->heap_buffer);

   684     }

   685     gdata->heap_write_count = (jlong)0;

   686     gdata->heap_last_tag_position = (jlong)0;

   687     gdata->heap_buffer_size = 0;

   688     gdata->heap_buffer = NULL;

   689     gdata->heap_buffer_index = 0;

   690 

   691     if ( gdata->logflags & LOG_CHECK_BINARY ) {

   692         if ( gdata->check_buffer != NULL ) {

   693             HPROF_FREE(gdata->check_buffer);

   694         }

   695         gdata->check_buffer_size = 0;

   696         gdata->check_buffer = NULL;

   697         gdata->check_buffer_index = 0;

   698     }

   699 

   700     ioname_cleanup();

   701 }

   702 

   703 void

   704 io_write_file_header(void)

   705 {

   706     HPROF_ASSERT(gdata->header!=NULL);

   707     if (gdata->output_format == 'b') {

   708         jint settings;

   709         jlong t;

   710 

   711         settings = 0;

   712         if (gdata->heap_dump || gdata->alloc_sites) {

   713             settings |= 1;

   714         }

   715         if (gdata->cpu_sampling) {

   716             settings |= 2;

   717         }

   718         t = md_get_timemillis();

   719 

   720         write_raw(gdata->header, (int)strlen(gdata->header) + 1);

   721         write_u4((jint)sizeof(HprofId));

   722         write_u8(t);

   723 

   724         write_header(HPROF_CONTROL_SETTINGS, 4 + 2);

   725         write_u4(settings);

   726         write_u2((unsigned short)gdata->max_trace_depth);

   727 

   728     } else if ((!gdata->cpu_timing) || (!gdata->old_timing_format)) {

   729         /* We don't want the prelude file for the old prof output format */

   730         time_t t;

   731         char prelude_file[FILENAME_MAX];

   732         int prelude_fd;

   733         int nbytes;

   734 

   735         t = time(0);

   736 

   737         md_get_prelude_path(prelude_file, sizeof(prelude_file), PRELUDE_FILE);

   738 

   739         prelude_fd = md_open(prelude_file);

   740         if (prelude_fd < 0) {

   741             char buf[FILENAME_MAX+80];

   742 

   743             (void)md_snprintf(buf, sizeof(buf), "Can't open %s", prelude_file);

   744             buf[sizeof(buf)-1] = 0;

   745             HPROF_ERROR(JNI_TRUE, buf);

   746         }

   747 

   748         write_printf("%s, created %s\n", gdata->header, ctime(&t));

   749 

   750         do {

   751             char buf[1024]; /* File is small, small buffer ok here */

   752 

   753             nbytes = md_read(prelude_fd, buf, sizeof(buf));

   754             if ( nbytes < 0 ) {

   755                 system_error("read", nbytes, errno);

   756                 break;

   757             }

   758             if (nbytes == 0) {

   759                 break;

   760             }

   761             write_raw(buf, nbytes);

   762         } while ( nbytes > 0 );

   763 

   764         md_close(prelude_fd);

   765 

   766         write_printf("\n--------\n\n");

   767 

   768         write_flush();

   769     }

   770 }

   771 

   772 void

   773 io_write_file_footer(void)

   774 {

   775     HPROF_ASSERT(gdata->header!=NULL);

   776 }

   777 

   778 void

   779 io_write_class_load(SerialNumber class_serial_num, ObjectIndex index,

   780                     SerialNumber trace_serial_num, char *sig)

   781 {

   782     CHECK_CLASS_SERIAL_NO(class_serial_num);

   783     CHECK_TRACE_SERIAL_NO(trace_serial_num);

   784     if (gdata->output_format == 'b') {

   785         IoNameIndex name_index;

   786         char *class_name;

   787 

   788         class_name = signature_to_name(sig);

   789         name_index = write_name_first(class_name);

   790         write_header(HPROF_LOAD_CLASS, (2 * (jint)sizeof(HprofId)) + (4 * 2));

   791         write_u4(class_serial_num);

   792         write_index_id(index);

   793         write_u4(trace_serial_num);

   794         write_index_id(name_index);

   795         HPROF_FREE(class_name);

   796     }

   797 }

   798 

   799 void

   800 io_write_class_unload(SerialNumber class_serial_num, ObjectIndex index)

   801 {

   802     CHECK_CLASS_SERIAL_NO(class_serial_num);

   803     if (gdata->output_format == 'b') {

   804         write_header(HPROF_UNLOAD_CLASS, 4);

   805         write_u4(class_serial_num);

   806     }

   807 }

   808 

   809 void

   810 io_write_sites_header(const char * comment_str, jint flags, double cutoff,

   811                     jint total_live_bytes, jint total_live_instances,

   812                     jlong total_alloced_bytes, jlong total_alloced_instances,

   813                     jint count)

   814 {

   815     if ( gdata->output_format == 'b') {

   816         write_header(HPROF_ALLOC_SITES, 2 + (8 * 4) + (count * (4 * 6 + 1)));

   817         write_u2((unsigned short)flags);

   818         write_u4(*(int *)(&cutoff));

   819         write_u4(total_live_bytes);

   820         write_u4(total_live_instances);

   821         write_u8(total_alloced_bytes);

   822         write_u8(total_alloced_instances);

   823         write_u4(count);

   824     } else {

   825         time_t t;

   826 

   827         t = time(0);

   828         write_printf("SITES BEGIN (ordered by %s) %s", comment_str, ctime(&t));

   829         write_printf(

   830             "          percent          live          alloc'ed  stack class\n");

   831         write_printf(

   832             " rank   self  accum     bytes objs     bytes  objs trace name\n");

   833     }

   834 }

   835 

   836 void

   837 io_write_sites_elem(jint index, double ratio, double accum_percent,

   838                 char *sig, SerialNumber class_serial_num,

   839                 SerialNumber trace_serial_num, jint n_live_bytes,

   840                 jint n_live_instances, jint n_alloced_bytes,

   841                 jint n_alloced_instances)

   842 {

   843     CHECK_CLASS_SERIAL_NO(class_serial_num);

   844     CHECK_TRACE_SERIAL_NO(trace_serial_num);

   845     if ( gdata->output_format == 'b') {

   846         HprofType kind;

   847         jint size;

   848 

   849         type_array(sig, &kind, &size);

   850         write_u1(kind);

   851         write_u4(class_serial_num);

   852         write_u4(trace_serial_num);

   853         write_u4(n_live_bytes);

   854         write_u4(n_live_instances);

   855         write_u4(n_alloced_bytes);

   856         write_u4(n_alloced_instances);

   857     } else {

   858         char *class_name;

   859 

   860         class_name = signature_to_name(sig);

   861         write_printf("%5u %5.2f%% %5.2f%% %9u %4u %9u %5u %5u %s\n",

   862                      index,

   863                      ratio * 100.0,

   864                      accum_percent * 100.0,

   865                      n_live_bytes,

   866                      n_live_instances,

   867                      n_alloced_bytes,

   868                      n_alloced_instances,

   869                      trace_serial_num,

   870                      class_name);

   871         HPROF_FREE(class_name);

   872     }

   873 }

   874 

   875 void

   876 io_write_sites_footer(void)

   877 {

   878     if (gdata->output_format == 'b') {

   879         not_implemented();

   880     } else {

   881         write_printf("SITES END\n");

   882     }

   883 }

   884 

   885 void

   886 io_write_thread_start(SerialNumber thread_serial_num,

   887                         ObjectIndex thread_obj_id,

   888                         SerialNumber trace_serial_num, char *thread_name,

   889                         char *thread_group_name, char *thread_parent_name)

   890 {

   891     CHECK_THREAD_SERIAL_NO(thread_serial_num);

   892     CHECK_TRACE_SERIAL_NO(trace_serial_num);

   893     if (gdata->output_format == 'b') {

   894         IoNameIndex tname_index;

   895         IoNameIndex gname_index;

   896         IoNameIndex pname_index;

   897 

   898         tname_index = write_name_first(thread_name);

   899         gname_index = write_name_first(thread_group_name);

   900         pname_index = write_name_first(thread_parent_name);

   901         write_header(HPROF_START_THREAD, ((jint)sizeof(HprofId) * 4) + (4 * 2));

   902         write_u4(thread_serial_num);

   903         write_index_id(thread_obj_id);

   904         write_u4(trace_serial_num);

   905         write_index_id(tname_index);

   906         write_index_id(gname_index);

   907         write_index_id(pname_index);

   908 

   909     } else if ( (!gdata->cpu_timing) || (!gdata->old_timing_format)) {

   910         /* We don't want thread info for the old prof output format */

   911         write_printf("THREAD START "

   912                      "(obj=%x, id = %d, name=\"%s\", group=\"%s\")\n",

   913                      thread_obj_id, thread_serial_num,

   914                      (thread_name==NULL?"":thread_name),

   915                      (thread_group_name==NULL?"":thread_group_name));

   916     }

   917 }

   918 

   919 void

   920 io_write_thread_end(SerialNumber thread_serial_num)

   921 {

   922     CHECK_THREAD_SERIAL_NO(thread_serial_num);

   923     if (gdata->output_format == 'b') {

   924         write_header(HPROF_END_THREAD, 4);

   925         write_u4(thread_serial_num);

   926 

   927     } else if ( (!gdata->cpu_timing) || (!gdata->old_timing_format)) {

   928         /* we don't want thread info for the old prof output format */

   929         write_printf("THREAD END (id = %d)\n", thread_serial_num);

   930     }

   931 }

   932 

   933 void

   934 io_write_frame(FrameIndex index, SerialNumber frame_serial_num,

   935                char *mname, char *msig, char *sname,

   936                SerialNumber class_serial_num, jint lineno)

   937 {

   938     CHECK_CLASS_SERIAL_NO(class_serial_num);

   939     if (gdata->output_format == 'b') {

   940         IoNameIndex mname_index;

   941         IoNameIndex msig_index;

   942         IoNameIndex sname_index;

   943 

   944         mname_index = write_name_first(mname);

   945         msig_index  = write_name_first(msig);

   946         sname_index = write_name_first(sname);

   947 

   948         write_header(HPROF_FRAME, ((jint)sizeof(HprofId) * 4) + (4 * 2));

   949         write_index_id(index);

   950         write_index_id(mname_index);

   951         write_index_id(msig_index);

   952         write_index_id(sname_index);

   953         write_u4(class_serial_num);

   954         write_u4(lineno);

   955     }

   956 }

   957 

   958 void

   959 io_write_trace_header(SerialNumber trace_serial_num,

   960                 SerialNumber thread_serial_num, jint n_frames, char *phase_str)

   961 {

   962     CHECK_TRACE_SERIAL_NO(trace_serial_num);

   963     if (gdata->output_format == 'b') {

   964         write_header(HPROF_TRACE, ((jint)sizeof(HprofId) * n_frames) + (4 * 3));

   965         write_u4(trace_serial_num);

   966         write_u4(thread_serial_num);

   967         write_u4(n_frames);

   968     } else {

   969         write_printf("TRACE %u:", trace_serial_num);

   970         if (thread_serial_num) {

   971             write_printf(" (thread=%d)", thread_serial_num);

   972         }

   973         if ( phase_str != NULL ) {

   974             write_printf(" (from %s phase of JVM)", phase_str);

   975         }

   976         write_printf("\n");

   977         if (n_frames == 0) {

   978             write_printf("\t<empty>\n");

   979         }

   980     }

   981 }

   982 

   983 void

   984 io_write_trace_elem(SerialNumber trace_serial_num, FrameIndex frame_index,

   985                     SerialNumber frame_serial_num,

   986                     char *csig, char *mname, char *sname, jint lineno)

   987 {

   988     if (gdata->output_format == 'b') {

   989         write_index_id(frame_index);

   990     } else {

   991         char *class_name;

   992         char linebuf[32];

   993 

   994         if (lineno == -2) {

   995             (void)md_snprintf(linebuf, sizeof(linebuf), "Compiled method");

   996         } else if (lineno == -3) {

   997             (void)md_snprintf(linebuf, sizeof(linebuf), "Native method");

   998         } else if (lineno == -1) {

   999             (void)md_snprintf(linebuf, sizeof(linebuf), "Unknown line");

  1000         } else {

  1001             (void)md_snprintf(linebuf, sizeof(linebuf), "%d", lineno);

  1002         }

  1003         linebuf[sizeof(linebuf)-1] = 0;

  1004         class_name = signature_to_name(csig);

  1005         if ( mname == NULL ) {

  1006             mname = "<Unknown Method>";

  1007         }

  1008         if ( sname == NULL ) {

  1009             sname = "<Unknown Source>";

  1010         }

  1011         write_printf("\t%s.%s(%s:%s)\n", class_name, mname, sname, linebuf);

  1012         HPROF_FREE(class_name);

  1013     }

  1014 }

  1015 

  1016 void

  1017 io_write_trace_footer(SerialNumber trace_serial_num,

  1018                 SerialNumber thread_serial_num, jint n_frames)

  1019 {

  1020 }

  1021 

  1022 #define CPU_SAMPLES_RECORD_NAME ("CPU SAMPLES")

  1023 #define CPU_TIMES_RECORD_NAME ("CPU TIME (ms)")

  1024 

  1025 void

  1026 io_write_cpu_samples_header(jlong total_cost, jint n_items)

  1027 {

  1028 

  1029     if (gdata->output_format == 'b') {

  1030         write_header(HPROF_CPU_SAMPLES, (n_items * (4 * 2)) + (4 * 2));

  1031         write_u4((jint)total_cost);

  1032         write_u4(n_items);

  1033     } else {

  1034         time_t t;

  1035         char *record_name;

  1036 

  1037         if ( gdata->cpu_sampling ) {

  1038             record_name = CPU_SAMPLES_RECORD_NAME;

  1039         } else {

  1040             record_name = CPU_TIMES_RECORD_NAME;

  1041         }

  1042         t = time(0);

  1043         write_printf("%s BEGIN (total = %d) %s", record_name,

  1044                      /*jlong*/(int)total_cost, ctime(&t));

  1045         if ( n_items > 0 ) {

  1046             write_printf("rank   self  accum   count trace method\n");

  1047         }

  1048     }

  1049 }

  1050 

  1051 void

  1052 io_write_cpu_samples_elem(jint index, double percent, double accum,

  1053                 jint num_hits, jlong cost, SerialNumber trace_serial_num,

  1054                 jint n_frames, char *csig, char *mname)

  1055 {

  1056     CHECK_TRACE_SERIAL_NO(trace_serial_num);

  1057     if (gdata->output_format == 'b') {

  1058         write_u4((jint)cost);

  1059         write_u4(trace_serial_num);

  1060     } else {

  1061         write_printf("%4u %5.2f%% %5.2f%% %7u %5u",

  1062                      index, percent, accum, num_hits,

  1063                      trace_serial_num);

  1064         if (n_frames > 0) {

  1065             char * class_name;

  1066 

  1067             class_name = signature_to_name(csig);

  1068             write_printf(" %s.%s\n", class_name, mname);

  1069             HPROF_FREE(class_name);

  1070         } else {

  1071             write_printf(" <empty trace>\n");

  1072         }

  1073     }

  1074 }

  1075 

  1076 void

  1077 io_write_cpu_samples_footer(void)

  1078 {

  1079     if (gdata->output_format == 'b') {

  1080         not_implemented();

  1081     } else {

  1082         char *record_name;

  1083 

  1084         if ( gdata->cpu_sampling ) {

  1085             record_name = CPU_SAMPLES_RECORD_NAME;

  1086         } else {

  1087             record_name = CPU_TIMES_RECORD_NAME;

  1088         }

  1089         write_printf("%s END\n", record_name);

  1090     }

  1091 }

  1092 

  1093 void

  1094 io_write_heap_summary(jlong total_live_bytes, jlong total_live_instances,

  1095                 jlong total_alloced_bytes, jlong total_alloced_instances)

  1096 {

  1097     if (gdata->output_format == 'b') {

  1098         write_header(HPROF_HEAP_SUMMARY, 4 * 6);

  1099         write_u4((jint)total_live_bytes);

  1100         write_u4((jint)total_live_instances);

  1101         write_u8(total_alloced_bytes);

  1102         write_u8(total_alloced_instances);

  1103     }

  1104 }

  1105 

  1106 void

  1107 io_write_oldprof_header(void)

  1108 {

  1109     if ( gdata->old_timing_format ) {

  1110         write_printf("count callee caller time\n");

  1111     }

  1112 }

  1113 

  1114 void

  1115 io_write_oldprof_elem(jint num_hits, jint num_frames, char *csig_callee,

  1116             char *mname_callee, char *msig_callee, char *csig_caller,

  1117             char *mname_caller, char *msig_caller, jlong cost)

  1118 {

  1119     if ( gdata->old_timing_format ) {

  1120         char * class_name_callee;

  1121         char * class_name_caller;

  1122 

  1123         class_name_callee = signature_to_name(csig_callee);

  1124         class_name_caller = signature_to_name(csig_caller);

  1125         write_printf("%d ", num_hits);

  1126         if (num_frames >= 1) {

  1127             write_printf("%s.%s%s ", class_name_callee,

  1128                  mname_callee,  msig_callee);

  1129         } else {

  1130             write_printf("%s ", "<unknown callee>");

  1131         }

  1132         if (num_frames > 1) {

  1133             write_printf("%s.%s%s ", class_name_caller,

  1134                  mname_caller,  msig_caller);