/*

 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Oracle nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * This source code is provided to illustrate the usage of a given feature

 * or technique and has been deliberately simplified. Additional steps

 * required for a production-quality application, such as security checks,

 * input validation and proper error handling, might not be present in

 * this sample code.

 */

/* All I/O functionality for hprof. */

/*

 * The hprof agent has many forms of output:

 *

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

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

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

 *

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

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

 *

 * And many forms of dumps:

 *

 *    heap=dump

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

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

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

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

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

 *    heap=sites

 *        Dumps the sites in the order of most allocations.

 *    cpu=samples

 *        Dumps the traces in order of most hits

 *    cpu=times

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

 *    cpu=old   (format=a only)

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

 *    monitor=y (format=a only)

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

 *

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

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

 *

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

 *          however see:

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

 */

#include "hprof.h"

typedef TableIndex HprofId;

#include "hprof_ioname.h"

#include "hprof_b_spec.h"

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

static void dump_heap_segment_and_reset(jlong segment_size);

static void

not_implemented(void)

{

}

static IoNameIndex

get_name_index(char *name)

{

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

        return ioname_find_or_create(name, NULL);

    }

    return 0;

}

static char *

signature_to_name(char *sig)

{

    char *ptr;

    char *basename;

    char *name;

    int i;

    int len;

    int name_len;

    if ( sig != NULL ) {

        switch ( sig[0] ) {

            case JVM_SIGNATURE_CLASS:

                ptr = strchr(sig+1, JVM_SIGNATURE_ENDCLASS);

                if ( ptr == NULL ) {

                    basename = "Unknown_class";

                    break;

                }

                /*LINTED*/

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

                name = HPROF_MALLOC(name_len+1);

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

                name[name_len] = 0;

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

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

                }

                return name;

            case JVM_SIGNATURE_ARRAY:

                basename = signature_to_name(sig+1);

                len = (int)strlen(basename);

                name_len = len+2;

                name = HPROF_MALLOC(name_len+1);

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

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

                name[name_len] = 0;

                HPROF_FREE(basename);

                return name;

            case JVM_SIGNATURE_FUNC:

                ptr = strchr(sig+1, JVM_SIGNATURE_ENDFUNC);

                if ( ptr == NULL ) {

                    basename = "Unknown_method";

                    break;

                }

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

                break;

            case JVM_SIGNATURE_BYTE:

                basename = "byte";

                break;

            case JVM_SIGNATURE_CHAR:

                basename = "char";

                break;

            case JVM_SIGNATURE_ENUM:

                basename = "enum";

                break;

            case JVM_SIGNATURE_FLOAT:

                basename = "float";

                break;

            case JVM_SIGNATURE_DOUBLE:

                basename = "double";

                break;

            case JVM_SIGNATURE_INT:

                basename = "int";

                break;

            case JVM_SIGNATURE_LONG:

                basename = "long";

                break;

            case JVM_SIGNATURE_SHORT:

                basename = "short";

                break;

            case JVM_SIGNATURE_VOID:

                basename = "void";

                break;

            case JVM_SIGNATURE_BOOLEAN:

                basename = "boolean";

                break;

            default:

                basename = "Unknown_class";

                break;

        }

    } else {

        basename = "Unknown_class";

    }

    /* Simple basename */

    name_len = (int)strlen(basename);

    name = HPROF_MALLOC(name_len+1);

    (void)strcpy(name, basename);

    return name;

}

static int

size_from_field_info(int size)

{

    if ( size == 0 ) {

        size = (int)sizeof(HprofId);

    }

    return size;

}

static void

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

{

    *kind = HPROF_NORMAL_OBJECT;

    *size = 0;

    switch ( sig[0] ) {

        case JVM_SIGNATURE_ENUM:

        case JVM_SIGNATURE_CLASS:

        case JVM_SIGNATURE_ARRAY:

            *kind = HPROF_NORMAL_OBJECT;

            break;

        case JVM_SIGNATURE_BOOLEAN:

            *kind = HPROF_BOOLEAN;

            break;

        case JVM_SIGNATURE_CHAR:

            *kind = HPROF_CHAR;

            break;

        case JVM_SIGNATURE_FLOAT:

            *kind = HPROF_FLOAT;

            break;

        case JVM_SIGNATURE_DOUBLE:

            *kind = HPROF_DOUBLE;

            break;

        case JVM_SIGNATURE_BYTE:

            *kind = HPROF_BYTE;

            break;

        case JVM_SIGNATURE_SHORT:

            *kind = HPROF_SHORT;

            break;

        case JVM_SIGNATURE_INT:

            *kind = HPROF_INT;

            break;

        case JVM_SIGNATURE_LONG:

            *kind = HPROF_LONG;

            break;

        default:

            HPROF_ASSERT(0);

            break;

    }

    *size = type_size[*kind];

}

static void

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

{

    *kind = 0;

    *elem_size = 0;

    switch ( sig[0] ) {

        case JVM_SIGNATURE_ARRAY:

            type_from_signature(sig+1, kind, elem_size);

            break;

    }

}

static void

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

{

    char buf[256];

    char details[256];

    details[0] = 0;

    if ( errnum != 0 ) {

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

    } else if ( rc >= 0 ) {

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

    }

    if ( details[0] == 0 ) {

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

    }

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

                            system_call, details);

    HPROF_ERROR(JNI_TRUE, buf);

}

static void

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

{

    int res;

    HPROF_ASSERT(fd>=0);

    if (socket) {

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

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

            system_error("send", res, errno);

        }

    } else {

        res = md_write(fd, buf, len);

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

            system_error("write", res, errno);

        }

    }

}

static void

write_flush(void)

{

    HPROF_ASSERT(gdata->fd >= 0);

    if (gdata->write_buffer_index) {

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

                                gdata->socket);

        gdata->write_buffer_index = 0;

    }

}

static void

heap_flush(void)

{

    HPROF_ASSERT(gdata->heap_fd >= 0);

    if (gdata->heap_buffer_index) {

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

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

                                JNI_FALSE);

        gdata->heap_buffer_index = 0;

    }

}

static void

write_raw(void *buf, int len)

{

    HPROF_ASSERT(gdata->fd >= 0);

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

        write_flush();

        if (len > gdata->write_buffer_size) {

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

            return;

        }

    }

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

    gdata->write_buffer_index += len;

}

static void

write_u4(unsigned i)

{

    i = md_htonl(i);

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

}

static void

write_u8(jlong t)

{

    write_u4((jint)jlong_high(t));

    write_u4((jint)jlong_low(t));

}

static void

write_u2(unsigned short i)

{

    i = md_htons(i);

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

}

static void

write_u1(unsigned char i)

{

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

}

static void

write_id(HprofId i)

{

    write_u4(i);

}

static void

write_current_ticks(void)

{

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

}

static void

write_header(unsigned char type, jint length)

{

    write_u1(type);

    write_current_ticks();

    write_u4(length);

}

static void

write_index_id(HprofId index)

{

    write_id(index);

}

static IoNameIndex

write_name_first(char *name)

{

    if ( name == NULL ) {

        return 0;

    }

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

        IoNameIndex name_index;

        jboolean    new_one;

        new_one = JNI_FALSE;

        name_index = ioname_find_or_create(name, &new_one);

        if ( new_one ) {

            int      len;

            len = (int)strlen(name);

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

            write_index_id(name_index);

            write_raw(name, len);

        }

        return name_index;

    }

    return 0;

}

static void

write_printf(char *fmt, ...)

{

    char buf[1024];

    va_list args;

    va_start(args, fmt);

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

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

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

    va_end(args);

}

static void

write_thread_serial_number(SerialNumber thread_serial_num, int with_comma)

{

    if ( thread_serial_num != 0 ) {

        CHECK_THREAD_SERIAL_NO(thread_serial_num);

        if ( with_comma ) {

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

        } else {

            write_printf(" thread %d", thread_serial_num);

        }

    } else {

        if ( with_comma ) {

            write_printf(" <unknown thread>,");

        } else {

            write_printf(" <unknown thread>");

        }

    }

}

static void

heap_raw(void *buf, int len)

{

    HPROF_ASSERT(gdata->heap_fd >= 0);

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

        heap_flush();

        if (len > gdata->heap_buffer_size) {

            gdata->heap_write_count += (jlong)len;

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

            return;

        }

    }

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

    gdata->heap_buffer_index += len;

}

static void

heap_u4(unsigned i)

{

    i = md_htonl(i);

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

}

static void

heap_u8(jlong i)

{

    heap_u4((jint)jlong_high(i));

    heap_u4((jint)jlong_low(i));

}

static void

heap_u2(unsigned short i)

{

    i = md_htons(i);

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

}

static void

heap_u1(unsigned char i)

{

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

}

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

static void

heap_tag(unsigned char tag)

{

    jlong pos;

    /* Current position in virtual heap dump file */

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

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

        if ( pos >= gdata->maxHeapSegment ) {

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

            heap_flush();

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

            dump_heap_segment_and_reset(gdata->heap_last_tag_position);

            /* Get new current position */

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

        }

    }

    /* Save position of this tag */

    gdata->heap_last_tag_position = pos;

    /* Write out this tag */

    heap_u1(tag);

}

static void

heap_id(HprofId i)

{

    heap_u4(i);

}

static void

heap_index_id(HprofId index)

{

    heap_id(index);

}

static void

heap_name(char *name)

{