libjvmti_oprofile.c

Go to the documentation of this file.

#include <stdio.h>
#include <jvmti.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <errno.h>

#include "opagent.h"

static int debug = 0;
static int can_get_line_numbers = 1;
static op_agent_t agent_hdl;

static int handle_error(jvmtiError err, char const * msg, int severe)
{
    if (err != JVMTI_ERROR_NONE) {
        fprintf(stderr, "%s: %s, err code %i\n",
            severe ? "Error" : "Warning", msg, err);
    }
    return err != JVMTI_ERROR_NONE;
}


static struct debug_line_info * 
create_debug_line_info(jint map_length, jvmtiAddrLocationMap const * map,
               jint entry_count, jvmtiLineNumberEntry* table_ptr,
               char const * source_filename)
{
    struct debug_line_info * debug_line;
    int i, j;
    if (!debug) {
        fprintf(stderr, "Source %s l: %d\n", source_filename, map_length);
        for (i = 0; i < map_length; ++i) {
            fprintf(stderr, "%p %lld\t",
                    map[i].start_address,
                    (long long)map[i].location);
        }
        fprintf(stderr, "\n");
        for (i = 0; i < entry_count; ++i) {
            fprintf(stderr, "%lld %d\t",
                (long long)table_ptr[i].start_location,
                table_ptr[i].line_number);
        }
        fprintf(stderr, "\n");
    }

    debug_line = calloc(map_length, sizeof(struct debug_line_info));
    if (!debug_line)
        return 0;

    for (i = 0; i < map_length; ++i) {
        /* FIXME: likely to need a lower_bound on the array, but
         * documentation is a bit obscure about the contents of these
         * arrray
         **/
        for (j = 0; j < entry_count - 1; ++j) {
            if (table_ptr[j].start_location > map[i].location)
                break;
        }
        debug_line[i].vma = (unsigned long)map[i].start_address;
        debug_line[i].lineno = table_ptr[j].line_number;
        debug_line[i].filename = source_filename;
    }

    if (debug) {
        for (i = 0; i < map_length; ++i) {
            fprintf(stderr, "%d\t-> %lx %s:%d\t\n", i, debug_line[i].vma,
                debug_line[i].filename,debug_line[i].lineno);
        }
        fprintf(stderr, "\n");
        fflush(stderr);
    }
    
    return debug_line;
}


static void JNICALL cb_compiled_method_load(jvmtiEnv * jvmti,
    jmethodID method, jint code_size, void const * code_addr,
    jint map_length, jvmtiAddrLocationMap const * map,
    void const * compile_info)
{
    jclass declaring_class;
    char * class_signature = NULL;
    char * method_name = NULL;
    char * method_signature = NULL;
    jvmtiLineNumberEntry* table_ptr = NULL;
    char * source_filename = NULL;
    struct debug_line_info * debug_line = NULL;
    jvmtiError err;

    /* shut up compiler warning */
    compile_info = compile_info;

    err = (*jvmti)->GetMethodDeclaringClass(jvmti, method,
                        &declaring_class);
    if (handle_error(err, "GetMethodDeclaringClass()", 1))
        goto cleanup2;

    if (can_get_line_numbers && map_length && map) {
        jint entry_count;

        err = (*jvmti)->GetLineNumberTable(jvmti, method,
                           &entry_count, &table_ptr);
        if (err == JVMTI_ERROR_NONE) {
            err = (*jvmti)->GetSourceFileName(jvmti,
                declaring_class, &source_filename);
            if (err ==  JVMTI_ERROR_NONE) {
                debug_line =
                    create_debug_line_info(map_length, map,
                        entry_count, table_ptr,
                        source_filename);
            } else if (err != JVMTI_ERROR_ABSENT_INFORMATION) {
                handle_error(err, "GetSourceFileName()", 1);
            }
        } else if (err != JVMTI_ERROR_NATIVE_METHOD &&
               err != JVMTI_ERROR_ABSENT_INFORMATION) {
            handle_error(err, "GetLineNumberTable()", 1);
        }
    }

    err = (*jvmti)->GetClassSignature(jvmti, declaring_class,
                      &class_signature, NULL);
    if (handle_error(err, "GetClassSignature()", 1))
        goto cleanup1;

    err = (*jvmti)->GetMethodName(jvmti, method, &method_name,
                      &method_signature, NULL);
    if (handle_error(err, "GetMethodName()", 1))
        goto cleanup;

    if (debug) {
        fprintf(stderr, "load: declaring_class=%p, class=%s, "
            "method=%s, signature=%s, addr=%p, size=%i \n",
            declaring_class, class_signature, method_name,
            method_signature, code_addr, code_size);
    }

    {
    int cnt = strlen(method_name) + strlen(class_signature) +
        strlen(method_signature) + 2;
    char buf[cnt];
    strncpy(buf, class_signature, cnt - 1);
    strncat(buf, method_name, cnt - strlen(buf) - 1);
    strncat(buf, method_signature, cnt - strlen(buf) - 1);
    if (op_write_native_code(agent_hdl, buf,
                 (uint64_t)(uintptr_t) code_addr,
                 code_addr, code_size)) {
        perror("Error: op_write_native_code()");
        goto cleanup;
    }
    }

    if (debug_line)
        if (op_write_debug_line_info(agent_hdl, code_addr, map_length,
                         debug_line))
            perror("Error: op_write_debug_line_info()");

cleanup:
    (*jvmti)->Deallocate(jvmti, (unsigned char *)method_name);
    (*jvmti)->Deallocate(jvmti, (unsigned char *)method_signature);
cleanup1:
    (*jvmti)->Deallocate(jvmti, (unsigned char *)class_signature);
    (*jvmti)->Deallocate(jvmti, (unsigned char *)table_ptr);
    (*jvmti)->Deallocate(jvmti, (unsigned char *)source_filename);
cleanup2:
    free(debug_line);
}


static void JNICALL cb_compiled_method_unload(jvmtiEnv * jvmti_env,
    jmethodID method, void const * code_addr)
{
    /* shut up compiler warning */
    jvmti_env = jvmti_env;
    method = method;

    if (debug)
        fprintf(stderr, "unload: addr=%p\n", code_addr);
    if (op_unload_native_code(agent_hdl, (uint64_t)(uintptr_t) code_addr))
        perror("Error: op_unload_native_code()");
}


static void JNICALL cb_dynamic_code_generated(jvmtiEnv * jvmti_env,
    char const * name, void const * code_addr, jint code_size)
{
    /* shut up compiler warning */
    jvmti_env = jvmti_env;
    if (debug) {
    /*  fprintf(stderr, "dyncode: name=%s, addr=%p, size=%i \n",
            name, code_addr, code_size); */
    }
    if (op_write_native_code(agent_hdl, name,
                 (uint64_t)(uintptr_t) code_addr,
                 code_addr, code_size))
        perror("Error: op_write_native_code()");
}


JNIEXPORT jint JNICALL
Agent_OnLoad(JavaVM * jvm, char * options, void * reserved)
{
    jint rc;
    jvmtiEnv * jvmti = NULL;
    jvmtiEventCallbacks callbacks;
    jvmtiCapabilities caps;
    jvmtiJlocationFormat format;
    jvmtiError error;

    /* shut up compiler warning */
    reserved = reserved;

    if (options && !strcmp("version", options)) {
        fprintf(stderr, "jvmti_oprofile: current libopagent version %i.%i.\n",
                op_major_version(), op_minor_version());
        return -1;
    }

    if (options && !strcmp("debug", options))
        debug = 1;

    if (debug)
        fprintf(stderr, "jvmti_oprofile: agent activated\n");

    agent_hdl = op_open_agent();
    if (!agent_hdl) {
        perror("Error: op_open_agent()");
        return -1;
    }

    rc = (*jvm)->GetEnv(jvm, (void *)&jvmti, JVMTI_VERSION_1);
    if (rc != JNI_OK) {
        fprintf(stderr, "Error: GetEnv(), rc=%i\n", rc);
        return -1;
    }

    memset(&caps, '\0', sizeof(caps));
    caps.can_generate_compiled_method_load_events = 1;
    error = (*jvmti)->AddCapabilities(jvmti, &caps);
    if (handle_error(error, "AddCapabilities()", 1))
        return -1;

    /* FIXME: settable through command line, default on/off? */
    error = (*jvmti)->GetJLocationFormat(jvmti, &format);
    if (!handle_error(error, "GetJLocationFormat", 1) &&
        format == JVMTI_JLOCATION_JVMBCI) {
        memset(&caps, '\0', sizeof(caps));
        caps.can_get_line_numbers = 1;
        caps.can_get_source_file_name = 1;
        error = (*jvmti)->AddCapabilities(jvmti, &caps);
        if (!handle_error(error, "AddCapabilities()", 1))
            can_get_line_numbers = 1;
    }

    memset(&callbacks, 0, sizeof(callbacks));
    callbacks.CompiledMethodLoad = cb_compiled_method_load;
    callbacks.CompiledMethodUnload = cb_compiled_method_unload;
    callbacks.DynamicCodeGenerated = cb_dynamic_code_generated;
    error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks,
                        sizeof(callbacks));
    if (handle_error(error, "SetEventCallbacks()", 1))
        return -1;

    error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
            JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
    if (handle_error(error, "SetEventNotificationMode() "
             "JVMTI_EVENT_COMPILED_METHOD_LOAD", 1))
        return -1;
    error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
            JVMTI_EVENT_COMPILED_METHOD_UNLOAD, NULL);
    if (handle_error(error, "SetEventNotificationMode() "
             "JVMTI_EVENT_COMPILED_METHOD_UNLOAD", 1))
        return -1;
    error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE,
            JVMTI_EVENT_DYNAMIC_CODE_GENERATED, NULL);
    if (handle_error(error, "SetEventNotificationMode() "
             "JVMTI_EVENT_DYNAMIC_CODE_GENERATED", 1))
        return -1;
    return 0;
}


JNIEXPORT void JNICALL Agent_OnUnload(JavaVM * jvm)
{
    /* shut up compiler warning */
    jvm = jvm;
    if (op_close_agent(agent_hdl))
        perror("Error: op_close_agent()");
}