#!/usr/sbin/dtrace -s

/* #pragma D option quiet */

dvm$1:::vm-init
{
    printf("  vm-init");
}

dvm$1:::vm-death
{
    printf("  vm-death");
}

dvm$1:::thread-start
{
    printf("  tid=%d, thread-start: %s  ", tid, copyinstr(arg0));
}

dvm$1:::thread-end
{
    printf("  tid=%d, thread-end  ", tid);
}

dvm$1:::class-load
{
    printf("  tid=%d, class-load: %s  ", tid, copyinstr(arg0));
}

dvm$1:::class-unload
{
    printf("  tid=%d, class-unload: %s  ", tid, copyinstr(arg0));
}
dvm$1:::gc-start
{
    printf("  tid=%d, gc-start  ", tid);
}

dvm$1:::gc-finish
{
    printf("  tid=%d, gc-finish  ", tid);
}

dvm$1:::gc-stats
{
    printf("  tid=%d, gc-stats: used objects: %ld, used object space: %ld  ",
            tid, arg0, arg1);
}

dvm$1:::object-alloc
{
    printf("  tid=%d, object-alloc: class name: %s, size: %ld  ",
              tid, copyinstr(arg0), arg1);
}

dvm$1:::object-free
{
    printf("  tid=%d, object-free:  class name: %s  ",
              tid, copyinstr(arg0));
}

dvm$1:::monitor-contended-enter
{
    printf("  tid=%d, monitor-contended-enter:    thread name: %s  ",
              tid, copyinstr(arg0));
}

dvm$1:::monitor-contended-entered
{
     printf("  tid=%d, monitor-contended-entered: thread name: %s  ",
               tid, copyinstr(arg0));
}

dvm$1:::monitor-wait
{
    printf("  tid=%d, monitor-wait:    thread name: %s, time-out: %ld  ",
              tid, copyinstr(arg0), arg1);
}

dvm$1:::monitor-waited
{
     printf("  tid=%d, monitor-waited: thread name: %s, time-out: %ld  ",
               tid, copyinstr(arg0), arg1);
}

dvm$1:::method-entry
{
     printf("  tid=%d, method-entry:  %s:%s %s  ",
               tid, copyinstr(arg0), copyinstr(arg1), copyinstr(arg2));
}

dvm$1:::method-return
{
     printf("  tid=%d, method-return: %s:%s %s  ",
               tid, copyinstr(arg0), copyinstr(arg1), copyinstr(arg2));
}
pid$1::exit:entry
/execname == "java"/
{
    printf("  tid=%d, D-script exited: pid=%d  
", tid, pid);
    exit(0);
}

provider dvm {
  probe vm__init();
  probe vm__death();
  probe thread__start(char *thread_name);
  probe thread__end();
  probe class__load(char *class_name);
  probe class__unload(char *class_name);
  probe gc__start();
  probe gc__finish();
  probe gc__stats(long used_objects, long used_object_space);
  probe object__alloc(char *class_name, long size);
  probe object__free(char *class_name);
  probe monitor__contended__enter(char *thread_name);
  probe monitor__contended__entered(char *thread_name);
  probe monitor__wait(char *thread_name, long timeout);
  probe monitor__waited(char *thread_name, long timeout);
  probe method__entry(char *class_name, char *method_name, char *method_signature);
  probe method__return(char *class_name, char *method_name, char *method_signature);
};