ltt/jni_interface.c

   1
   2 /* Important to get consistent size_t type */
   3 #define _FILE_OFFSET_BITS 64
   4
   5 #include <jni.h>
   6
   7 #include <ltt/trace.h>
   8 #include <ltt/time.h>
   9 #include <ltt/marker.h>
  10 #include <glib.h>
  11
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <stdint.h>
  16
  17 /*
  18 ***FIXME***
  19 ***HACK***
  20  We've got hell of a problem passing "unsigned int64" to java, as there is no equivalent type
  21    The closer we can use is "long" which is signed, so only 32 (or 63?) bits are valid
  22    Plus, even if we are within the "32 bits" capacity, java sometime screw itself trying to convert "unsigned 64 -> signed 64"
  23    This happen especially often when RETURNING a jlong
  24    So when returning a jlong, we should convert it like this : "unsigned 64"->"signed 64"->jlong
  25 */
  26 #define CONVERT_UINT64_TO_JLONG(n) (jlong)(gint64)(n)
  27 #define CONVERT_INT64_TO_JLONG(n) (jlong)(gint64)(n)
  28
  29 /* To ease calcul involving nano */
  30 #define BILLION 1000000000
  31
  32
  33 #if __WORDSIZE == 64
  34         #define CONVERT_JLONG_TO_PTR(p) (p)
  35         #define CONVERT_PTR_TO_JLONG(p) (jlong)(p)
  36         /* Define the "gint" type we should use for pointer. */
  37         #define GINT_TYPE_FOR_PTR gint64
  38 #else
  39         /* Conversion to int first to save warning */
  40         #define CONVERT_JLONG_TO_PTR(p) (int)(p)
  41         #define CONVERT_PTR_TO_JLONG(p) (jlong)(int)(p)
  42         /* Define the "gint" type we should use for pointer. */
  43         #define GINT_TYPE_FOR_PTR gint32
  44 #endif
  45
  46 /* Structure to encapsulate java_data to pass as arguments */
  47 struct java_calling_data
  48 {
  49     JNIEnv *env;
  50     jobject jobj;
  51 };
  52
  53 /*  ***TODO***
  54  All these struct are used to call g_datalist_foreach()
  55  Find a better way! This is ugly!
  56 */
  57 struct addMarkersArgs
  58 {
  59     struct java_calling_data *java_args;
  60     struct marker_data *mdata;
  61 };
  62
  63 struct saveTimeArgs
  64 {
  65         GArray *saveTimeArray;
  66 };
  67
  68 struct saveTimeAndTracefile
  69 {
  70         LttTime time;
  71         LttTracefile *tracefile;
  72 };
  73
  74
  75 /*
  76 ### COMMON Methods ###
  77 #
  78 Empty method to turn off the debug (debug waste time while printing) */
  79 void ignore_and_drop_message(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) {
  80 }
  81
  82
  83 /* JNI method to call printf from the java side */
  84 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_Jni_1C_1Common_ltt_1printC(JNIEnv *env, jobject jobj, jstring new_string) {
  85         const char *c_msg = (*env)->GetStringUTFChars(env, new_string, 0);
  86
  87         printf("%s", c_msg );
  88
  89         (*env)->ReleaseStringUTFChars(env, new_string, c_msg);
  90 }
  91 /*
  92 #
  93 #### */
  94
  95
  96 /*
  97 ### TRACE methods ###
  98 #
  99 JNI mapping of   < LttTrace *ltt_trace_open(const gchar *pathname)  > (trace.h) */
 100 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv *env, jobject jobj, jstring pathname, jboolean show_debug) {
 101
 102         if ( !show_debug) {
 103                 /* Make sure we don't use any debug (speed up the read) */
 104                 g_log_set_handler(NULL, G_LOG_LEVEL_INFO, ignore_and_drop_message, NULL);
 105                 g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, ignore_and_drop_message, NULL);
 106         }
 107
 108         const char *c_pathname = (*env)->GetStringUTFChars(env, pathname, 0);
 109         LttTrace *newPtr = ltt_trace_open( c_pathname );
 110
 111         (*env)->ReleaseStringUTFChars(env, pathname, c_pathname);
 112
 113         return CONVERT_PTR_TO_JLONG(newPtr);
 114 }
 115
 116 /* JNI mapping of  < void ltt_trace_close(LttTrace *t)  > (trace.h) */
 117 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1closeTrace(JNIEnv *env, jobject jobj, jlong trace_ptr){
 118
 119         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 120
 121         ltt_trace_close(newPtr);
 122 }
 123
 124 /* Get the tracepath */
 125 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getTracepath(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 126         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 127
 128         return (*env)->NewStringUTF(env, g_quark_to_string( newPtr->pathname) );
 129 }
 130
 131
 132 /* Get of num_cpu */
 133 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getCpuNumber(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 134         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 135
 136         return (jint)newPtr->num_cpu;
 137 }
 138
 139 /* Get of arch_type */
 140 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchType(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 141         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 142
 143         return (jlong)newPtr->arch_type;
 144 }
 145
 146 /* Get of arch_variant */
 147 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchVariant(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 148         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 149
 150         return (jlong)newPtr->arch_variant;
 151 }
 152
 153 /* Get of arch_size */
 154 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchSize(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 155         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 156
 157         return (jshort)newPtr->arch_size;
 158 }
 159
 160 /* Get of ltt_major_version */
 161 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMajorVersion(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 162         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 163
 164         return (jshort)newPtr->ltt_major_version;
 165 }
 166
 167 /* Get of ltt_minor_version */
 168 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMinorVersion(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 169         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 170
 171         return (jshort)newPtr->ltt_minor_version;
 172 }
 173
 174 /* Get of flight_recorder */
 175 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFlightRecorder(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 176         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 177
 178         return (jshort)newPtr->flight_recorder;
 179 }
 180
 181 /* Get of freq_scale */
 182 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFreqScale(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 183         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 184
 185         return (jlong)newPtr->freq_scale;
 186 }
 187
 188 /* Get of start_freq */
 189 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartFreq(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 190         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 191
 192         return CONVERT_UINT64_TO_JLONG(newPtr->start_freq);
 193 }
 194
 195 /* Get of start_tsc */
 196 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartTimestampCurrentCounter(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 197         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 198
 199         return CONVERT_UINT64_TO_JLONG(newPtr->start_tsc);
 200 }
 201
 202 /* Get of start_monotonic */
 203 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartMonotonic(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 204         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 205
 206         return CONVERT_UINT64_TO_JLONG(newPtr->start_monotonic);
 207 }
 208
 209 /* Access to start_time */
 210 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
 211 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTime(JNIEnv *env, jobject jobj, jlong trace_ptr, jobject time_jobj) {
 212         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 213
 214         jclass accessClass = (*env)->GetObjectClass(env, time_jobj);
 215         jmethodID accessFunction = (*env)->GetMethodID(env, accessClass, "setTimeFromC", "(J)V");
 216
 217         jlong fullTime = (CONVERT_UINT64_TO_JLONG(newPtr->start_time.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(newPtr->start_time.tv_nsec);
 218
 219         (*env)->CallVoidMethod(env, time_jobj, accessFunction, fullTime );
 220 }
 221
 222 /* Access to start_time_from_tsc */
 223 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
 224 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTimeFromTimestampCurrentCounter(JNIEnv *env, jobject jobj, jlong trace_ptr, jobject time_jobj) {
 225         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 226
 227         jclass accessClass = (*env)->GetObjectClass(env, time_jobj);
 228         jmethodID accessFunction = (*env)->GetMethodID(env, accessClass, "setTimeFromC", "(J)V");
 229
 230         jlong fullTime = (CONVERT_UINT64_TO_JLONG(newPtr->start_time_from_tsc.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(newPtr->start_time_from_tsc.tv_nsec);
 231
 232         (*env)->CallVoidMethod(env, time_jobj, accessFunction, fullTime);
 233 }
 234
 235
 236 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getAllTracefiles  */
 237 void g_datalist_foreach_addTracefilesOfTrace(GQuark name, gpointer data, gpointer user_data) {
 238         struct java_calling_data *args = (struct java_calling_data*)user_data;
 239
 240         jclass accessClass = (*args->env)->GetObjectClass(args->env, args->jobj);
 241         jmethodID accessFunction = (*args->env)->GetMethodID(args->env, accessClass, "addTracefileFromC", "(Ljava/lang/String;J)V");
 242
 243         GArray *tracefile_array = (GArray*)data;
 244         LttTracefile *tracefile;
 245         jlong newPtr;
 246
 247         unsigned int i;
 248         for (i=0; i<tracefile_array->len; i++) {
 249                 tracefile = &g_array_index(tracefile_array, LttTracefile, i);
 250
 251                 newPtr = CONVERT_PTR_TO_JLONG(tracefile);
 252
 253                 (*args->env)->CallVoidMethod(args->env, args->jobj, accessFunction, (*args->env)->NewStringUTF(args->env, g_quark_to_string(tracefile->name) ), newPtr );
 254         }
 255 }
 256
 257 /* Function to fill up the java map with the event type found in tracefile (the name) */
 258 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedAllTracefiles(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 259         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 260
 261         struct java_calling_data args = { env, jobj };
 262
 263         g_datalist_foreach(&newPtr->tracefiles, &g_datalist_foreach_addTracefilesOfTrace, &args);
 264 }
 265
 266
 267 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange */
 268 /*      used to save the current timestamp for each tracefile */
 269 void g_datalist_foreach_saveTracefilesTime(GQuark name, gpointer data, gpointer user_data) {
 270         struct saveTimeArgs *args = (struct saveTimeArgs*)user_data;
 271
 272         GArray *tracefile_array = (GArray*)data;
 273         GArray *save_array = args->saveTimeArray;
 274
 275         LttTracefile *tracefile;
 276         struct saveTimeAndTracefile *savedData;
 277
 278         unsigned int i;
 279         for (i=0; i<tracefile_array->len; i++) {
 280                 tracefile = &g_array_index(tracefile_array, LttTracefile, i);
 281
 282                 /* Allocate a new LttTime for each tracefile (so it won't change if the tracefile seek somewhere else) */
 283                 savedData = (struct saveTimeAndTracefile*)malloc( sizeof(struct saveTimeAndTracefile) );
 284                 savedData->time.tv_sec = tracefile->event.event_time.tv_sec;
 285                 savedData->time.tv_nsec = tracefile->event.event_time.tv_nsec;
 286                 savedData->tracefile = tracefile;
 287                 /* Append the saved data to the array */
 288                 g_array_append_val(save_array, savedData);
 289         }
 290 }
 291
 292
 293 /* Obtain the range of the trace (i.e. "start time" and "end time") */
 294 /* Note : This function, unlike ltt_trace_time_span_get, is assured to return all tracefiles to their correct position after operation */
 295 /* NOTE : this method is quite heavy to use!!! */
 296 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange(JNIEnv *env, jobject jobj, jlong trace_ptr, jobject jstart_time, jobject jend_time) {
 297         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 298
 299         /* Allocate ourself a new array to save the data in */
 300         GArray *savedDataArray = g_array_new(FALSE, FALSE, sizeof(struct saveTimeAndTracefile*) );
 301         struct saveTimeArgs args = { savedDataArray };
 302         /* Call g_datalist_foreach_saveTracefilesTime for each element in the GData to save the time */
 303         g_datalist_foreach(&newPtr->tracefiles, &g_datalist_foreach_saveTracefilesTime, &args);
 304
 305         /* Call to ltt_trace_time_span_get to find the current start and end time */
 306         /* NOTE : This WILL change the current block of the tracefile (i.e. its timestamp) */
 307         LttTime tmpStartTime = { 0, 0 };
 308         LttTime tmpEndTime = { 0, 0 };
 309         ltt_trace_time_span_get(newPtr, &tmpStartTime, &tmpEndTime);
 310
 311         /* Seek back to the correct time for each tracefile and free the allocated memory */
 312         struct saveTimeAndTracefile *savedData;
 313         unsigned int i;
 314         for (i=0; i<savedDataArray->len; i++) {
 315                 savedData = g_array_index(savedDataArray, struct saveTimeAndTracefile*, i);
 316                 /* Seek back to the correct time */
 317                 /* Some time will not be consistent here (i.e. unitialized data) */
 318                 /*      but the seek should work just fine with that */
 319                 ltt_tracefile_seek_time(savedData->tracefile, savedData->time);
 320
 321                 /* Free the memory allocated for this saveTimeAndTracefile entry */
 322                 free( savedData );
 323         }
 324         /* Free the memory allocated for the GArray */
 325         g_array_free(savedDataArray, TRUE);
 326
 327         /* Send the start and end time back to the java */
 328         /* We do it last to make sure a problem won't leave us with unfred memory */
 329         jclass startAccessClass = (*env)->GetObjectClass(env, jstart_time);
 330         jmethodID startAccessFunction = (*env)->GetMethodID(env, startAccessClass, "setTimeFromC", "(J)V");
 331         jlong startTime = (CONVERT_UINT64_TO_JLONG(tmpStartTime.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(tmpStartTime.tv_nsec);
 332         (*env)->CallVoidMethod(env, jstart_time, startAccessFunction, startTime);
 333
 334         jclass endAccessClass = (*env)->GetObjectClass(env, jend_time);
 335         jmethodID endAccessFunction = (*env)->GetMethodID(env, endAccessClass, "setTimeFromC", "(J)V");
 336         jlong endTime = (CONVERT_UINT64_TO_JLONG(tmpEndTime.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(tmpEndTime.tv_nsec);
 337         (*env)->CallVoidMethod(env, jend_time, endAccessFunction, endTime);
 338 }
 339
 340 /* Function to print the content of a trace */
 341 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1printTrace(JNIEnv *env, jobject jobj, jlong trace_ptr) {
 342
 343         LttTrace *newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
 344
 345         printf("pathname                : %s\n"     ,g_quark_to_string(newPtr->pathname) );
 346         printf("num_cpu                 : %u\n"     ,(unsigned int)(newPtr->num_cpu) );
 347         printf("arch_type               : %u\n"     ,(unsigned int)(newPtr->arch_type) );
 348         printf("arch_variant            : %u\n"     ,(unsigned int)(newPtr->arch_variant) );
 349         printf("arch_size               : %u\n"     ,(unsigned short)(newPtr->arch_size) );
 350         printf("ltt_major_version       : %u\n"     ,(unsigned short)(newPtr->ltt_major_version) );
 351         printf("ltt_minor_version       : %u\n"     ,(unsigned short)(newPtr->ltt_minor_version) );
 352         printf("flight_recorder         : %u\n"     ,(unsigned short)(newPtr->flight_recorder) );
 353         printf("freq_scale              : %u\n"     ,(unsigned int)(newPtr->freq_scale) );
 354         printf("start_freq              : %lu\n"    ,(long unsigned int)(newPtr->start_freq) );
 355         printf("start_tsc               : %lu\n"    ,(long unsigned int)(newPtr->start_tsc) );
 356         printf("start_monotonic         : %lu\n"    ,(long unsigned int)(newPtr->start_monotonic) );
 357         printf("start_time ptr          : %p\n"     ,&newPtr->start_time);
 358         printf("   tv_sec               : %lu\n"    ,(long unsigned int)(newPtr->start_time.tv_sec) );
 359         printf("   tv_nsec              : %lu\n"    ,(long unsigned int)(newPtr->start_time.tv_nsec) );
 360         printf("start_time_from_tsc ptr : %p\n"     ,&newPtr->start_time_from_tsc);
 361         printf("   tv_sec               : %lu\n"    ,(long unsigned int)(newPtr->start_time_from_tsc.tv_sec) );
 362         printf("   tv_nsec              : %lu\n"    ,(long unsigned int)(newPtr->start_time_from_tsc.tv_nsec) );
 363         printf("tracefiles ptr          : %p\n"     ,newPtr->tracefiles);
 364         printf("\n");
 365 }
 366 /*
 367 #
 368 ### */
 369
 370
 371
 372
 373 /*
 374 ### TRACEFILE methods ###
 375 # */
 376
 377 /* Get of cpu_online */
 378 JNIEXPORT jboolean JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsCpuOnline(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 379         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 380
 381         return (jboolean)newPtr->cpu_online;
 382 }
 383
 384 /* Get of long_name */
 385 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilepath(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 386         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 387
 388         return (*env)->NewStringUTF(env, g_quark_to_string(newPtr->long_name) );
 389 }
 390
 391 /* Get of name */
 392 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilename(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 393         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 394
 395         return (*env)->NewStringUTF(env, g_quark_to_string(newPtr->name) );
 396 }
 397
 398 /* Get of cpu_num */
 399 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCpuNumber(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 400         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 401
 402         return (jlong)newPtr->cpu_num;
 403 }
 404
 405 /* Get of tid */
 406 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTid(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 407         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 408
 409         return (jlong)newPtr->tid;
 410 }
 411
 412 /* Get of pgid */
 413 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getPgid(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 414         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 415
 416         return (jlong)newPtr->pgid;
 417 }
 418
 419 /* Get of creation */
 420 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCreation(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 421         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 422
 423         return CONVERT_UINT64_TO_JLONG(newPtr->creation);
 424 }
 425
 426 /* Get of trace */
 427 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracePtr(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 428         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 429
 430         return CONVERT_PTR_TO_JLONG(newPtr->trace);
 431 }
 432
 433 /* Get of mdata */
 434 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getMarkerDataPtr(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 435         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 436
 437         return CONVERT_PTR_TO_JLONG(newPtr->mdata);
 438 }
 439
 440 /* Get of fd */
 441 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCFileDescriptor(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 442         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 443
 444         return (jint)newPtr->fd;
 445 }
 446
 447 /* Get of file_size */
 448 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getFileSize(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 449         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 450
 451         return CONVERT_UINT64_TO_JLONG(newPtr->file_size);
 452 }
 453
 454 /* Get of num_blocks */
 455 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBlockNumber(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 456         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 457
 458         return (jlong)newPtr->num_blocks;
 459 }
 460
 461 /* Get of reverse_bo */
 462 JNIEXPORT jboolean JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsBytesOrderReversed(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 463         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 464
 465         return (jboolean)newPtr->reverse_bo;
 466 }
 467
 468 /* Get of float_word_order */
 469 JNIEXPORT jboolean JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsFloatWordOrdered(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 470         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 471
 472         return (jboolean)newPtr->float_word_order;
 473 }
 474
 475 /* Get of alignment */
 476 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAlignement(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 477         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 478
 479         return CONVERT_UINT64_TO_JLONG(newPtr->alignment);
 480 }
 481
 482 /* Get of buffer_header_size */
 483 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferHeaderSize(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 484         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 485
 486         return CONVERT_UINT64_TO_JLONG(newPtr->buffer_header_size);
 487 }
 488
 489 /* Get of tscbits */
 490 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfCurrentTimestampCounter(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 491         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 492
 493         return (jint)newPtr->tscbits;
 494 }
 495
 496 /* Get of eventbits */
 497 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfEvent(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 498         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 499
 500         return (jint)newPtr->eventbits;
 501 }
 502
 503 /* Get of tsc_mask */
 504 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMask(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 505         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 506
 507         return CONVERT_UINT64_TO_JLONG(newPtr->tsc_mask);
 508 }
 509
 510 /* Get of tsc_mask_next_bit */
 511 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMaskNextBit(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 512         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 513
 514         return CONVERT_UINT64_TO_JLONG(newPtr->tsc_mask_next_bit);
 515 }
 516
 517 /* Get of events_lost */
 518 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventsLost(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 519         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 520
 521         return (jlong)newPtr->events_lost;
 522 }
 523
 524 /* Get of subbuf_corrupt */
 525 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getSubBufferCorrupt(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 526         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 527
 528         return (jlong)newPtr->subbuf_corrupt;
 529 }
 530
 531 /* Get of event */
 532 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventPtr(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 533         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 534
 535         return CONVERT_PTR_TO_JLONG(&newPtr->event);
 536 }
 537
 538 /* Get of buffer */
 539 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferPtr(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 540         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 541
 542         return CONVERT_PTR_TO_JLONG(&newPtr->buffer);
 543 }
 544
 545 /* Get of buffer size */
 546 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferSize(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 547         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 548
 549         return (jlong)newPtr->buffer.size;
 550 }
 551
 552
 553 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAllMarkers */
 554 void g_hash_table_foreach_addMarkersOfTracefile(gpointer key, gpointer data, gpointer user_data) {
 555         struct addMarkersArgs *args = (struct addMarkersArgs*)user_data;
 556         struct java_calling_data *jargs = (struct java_calling_data*)args->java_args;
 557
 558         jclass accessClass = (*jargs->env)->GetObjectClass(jargs->env, jargs->jobj);
 559         jmethodID accessFunction = (*jargs->env)->GetMethodID(jargs->env, accessClass, "addMarkersFromC", "(IJ)V");
 560
 561         unsigned long marker_id = (unsigned long)data;
 562
 563         /* The hash table store an ID... we will use the ID to access the array. */
 564         GArray *marker = args->mdata->markers;
 565         struct marker_info *newPtr = &g_array_index(marker, struct marker_info, marker_id);
 566
 567         (*jargs->env)->CallVoidMethod(jargs->env, jargs->jobj, accessFunction, marker_id, CONVERT_PTR_TO_JLONG(newPtr) );
 568 }
 569
 570 /* Function to fill up the java map with the event type found in tracefile (the name) */
 571 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1feedAllMarkers(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 572         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 573
 574         /* ***TODO***
 575         Find a better way! This is ugly! */
 576         struct java_calling_data java_args = { env, jobj };
 577         struct addMarkersArgs args = { &java_args, newPtr->mdata };
 578
 579         g_hash_table_foreach( newPtr->mdata->markers_hash, &g_hash_table_foreach_addMarkersOfTracefile,  &args);
 580 }
 581
 582
 583 /* Function to print the content of a tracefile */
 584 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1printTracefile(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 585
 586         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 587         printf("cpu_online              : %i\n"     ,(int)newPtr->cpu_online);
 588         printf("long_name               : %s\n"     ,g_quark_to_string(newPtr->long_name));
 589         printf("name                    : %s\n"     ,g_quark_to_string(newPtr->name));
 590         printf("cpu_num                 : %u\n"     ,(unsigned int)(newPtr->cpu_num));
 591         printf("tid                     : %u\n"     ,(unsigned int)(newPtr->tid));
 592         printf("pgid                    : %u\n"     ,(unsigned int)(newPtr->pgid));
 593         printf("creation                : %lu\n"    ,(long unsigned int)(newPtr->creation));
 594         printf("trace ptr               : %p\n"     ,newPtr->trace);
 595         printf("marker ptr              : %p\n"     ,newPtr->mdata);
 596         printf("fd                      : %i\n"     ,(int)(newPtr->fd));
 597         printf("file_size               : %u\n"     ,(unsigned int)(newPtr->file_size));
 598         printf("num_blocks              : %u\n"     ,(unsigned int)(newPtr->num_blocks));
 599         printf("reverse_bo              : %i\n"     ,(int)newPtr->reverse_bo);
 600         printf("float_word_order        : %i\n"     ,(int)newPtr->float_word_order);
 601         printf("alignment               : %i\n"     ,(int)newPtr->alignment);
 602         printf("buffer_header_size      : %i\n"     ,(int)newPtr->buffer_header_size);
 603         printf("tscbits                 : %u\n"     ,(unsigned short)newPtr->tscbits);
 604         printf("eventbits               : %u\n"     ,(unsigned short)newPtr->eventbits);
 605         printf("tsc_mask                : %lu\n"    ,(long unsigned int)newPtr->tsc_mask);
 606         printf("tsc_mask_next_bit       : %lu\n"    ,(long unsigned int)newPtr->tsc_mask_next_bit);
 607         printf("events_lost             : %u\n"     ,(unsigned int)newPtr->events_lost);
 608         printf("subbuf_corrupt          : %u\n"     ,(unsigned int)newPtr->subbuf_corrupt);
 609         printf("event ptr               : %p\n"     ,&newPtr->event);
 610         printf("buffer ptr              : %p\n"     ,&newPtr->buffer);
 611         printf("\n");
 612 }
 613 /*
 614 #
 615 ### */
 616
 617
 618
 619 /*
 620 ### EVENT methods ###
 621 #  */
 622
 623 /* Method to get the read status */
 624 /*    This method will read the next event and then seek back its initial position */
 625 /*    Lttv assume that every tracefile have at least 1 event, but we have not guarantee after this one. */
 626 /*    We will read the next event and return the status of that read */
 627 /*    We will then seek back to our initial position */
 628 /*    Note : this method is expensive and should not be used too often */
 629 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1positionToFirstEvent(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 630         LttTracefile *tracefilePtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 631
 632         /* Ask ltt to read the next events on the given tracefiles
 633            Returned value can be :
 634             0               if everything went fine (EOK)
 635             ERANGE  = 34    out of range, back to last event (might be system dependent?)
 636             EPERM   = 1     error while reading              (might be system dependent?)  */
 637
 638
 639         /* Seek to the start time... this will also read the first event, as we want. */
 640         int returnedValue = ltt_tracefile_seek_time(tracefilePtr, ((struct LttTrace)*(tracefilePtr->trace)).start_time_from_tsc);
 641
 642         return (jint)returnedValue;
 643 }
 644
 645 /* Method to read next event */
 646 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1readNextEvent(JNIEnv *env, jobject jobj, jlong tracefile_ptr) {
 647         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 648
 649         /* Ask ltt to read the next events on the given tracefiles
 650            Returned value can be :
 651             0               if everything went fine (EOK)
 652             ERANGE  = 34    out of range, back to last event (might be system dependent?)
 653             EPERM   = 1     error while reading              (might be system dependent?)  */
 654
 655
 656         /* ***FIXME***
 657           This might fail on the FIRST event, as the timestamp before the first read is uninitialized
 658           However, LTT make the assumption that all tracefile have AT LEAST one event, so we got to run with it  */
 659
 660         /* Save "last time" before moving, to be able to get back if needed */
 661         LttTime lastTime = newPtr->event.event_time;
 662
 663         int returnedValue = ltt_tracefile_read(newPtr);
 664
 665         /* We need to get back to previous after an error to keep a sane state */
 666         if ( returnedValue != 0 ) {
 667                 ltt_tracefile_seek_time(newPtr, lastTime);
 668         }
 669
 670         return (jint)returnedValue;
 671 }
 672
 673 /* Method to seek to a certain event */
 674 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1seekEvent(JNIEnv *env, jobject jobj, jlong tracefile_ptr, jobject time_jobj) {
 675         LttTracefile *newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
 676
 677         guint64 fullTime = 0;
 678
 679         jclass accessClass = (*env)->GetObjectClass(env, time_jobj);
 680         jmethodID getTimeFunction = (*env)->GetMethodID(env, accessClass, "getTime", "()J");
 681         fullTime = (*env)->CallLongMethod(env, time_jobj, getTimeFunction);
 682
 683         /* ***HACK***
 684            Conversion from jlong -> C long seems to be particularly sloppy
 685            Depending how and where (inlined a function or as a single operation) we do this, we might end up with wrong number
 686            The following asignation of guint64 seems to work well.
 687            MAKE SURE TO PERFORM SEVERAL TESTS IF YOU CHANGE THIS.  */
 688         guint64 seconds = fullTime/BILLION;
 689         guint64 nanoSeconds = fullTime%BILLION;
 690
 691         LttTime seekTime = { (unsigned long)seconds, (unsigned long)nanoSeconds };
 692
 693         /* Ask ltt to read the next events on the given tracefiles
 694            Returned value can be :
 695             0               if everything went fine (EOK)
 696             ERANGE  = 34    out of range, back to last event (might be system dependent?)
 697             EPERM   = 1     error while reading              (might be system dependent?)  */
 698
 699         int returnedValue = ltt_tracefile_seek_time(newPtr, seekTime);
 700         return (jint)returnedValue;
 701 }
 702
 703 /* Get of tracefile */
 704 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTracefilePtr(JNIEnv *env, jobject jobj, jlong event_ptr) {
 705         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 706
 707         return CONVERT_PTR_TO_JLONG(newPtr->tracefile);
 708 }
 709
 710 /* Get of block */
 711 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getBlock(JNIEnv *env, jobject jobj, jlong event_ptr) {
 712         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 713
 714         return (jlong)newPtr->block;
 715 }
 716
 717 /* Get of offset */
 718 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOffset(JNIEnv *env, jobject jobj, jlong event_ptr) {
 719         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 720
 721         return (jlong)newPtr->offset;
 722 }
 723
 724 /* Get of tsc */
 725 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCurrentTimestampCounter(JNIEnv *env, jobject jobj, jlong event_ptr) {
 726         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 727
 728         return CONVERT_UINT64_TO_JLONG(newPtr->tsc);
 729 }
 730
 731 /* Get of timestamp */
 732 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTimestamp(JNIEnv *env, jobject jobj, jlong event_ptr) {
 733         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 734
 735         return (jlong)newPtr->timestamp;
 736 }
 737
 738 /* Get of event_id */
 739 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventMarkerId(JNIEnv *env, jobject jobj, jlong event_ptr) {
 740         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 741
 742         return (jint)newPtr->event_id;
 743 }
 744
 745 /* Get time in nanoseconds */
 746 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getNanosencondsTime(JNIEnv *env, jobject jobj, jlong event_ptr) {
 747         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 748
 749         return (CONVERT_UINT64_TO_JLONG(newPtr->event_time.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(newPtr->event_time.tv_nsec);
 750 }
 751
 752 /* Fill event_time into an object */
 753 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1feedEventTime(JNIEnv *env, jobject jobj, jlong event_ptr, jobject time_jobj) {
 754         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 755
 756         jclass accessClass = (*env)->GetObjectClass(env, time_jobj);
 757         jmethodID accessFunction = (*env)->GetMethodID(env, accessClass, "setTimeFromC", "(J)V");
 758
 759         jlong fullTime = (CONVERT_UINT64_TO_JLONG(newPtr->event_time.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(newPtr->event_time.tv_nsec);
 760
 761         (*env)->CallVoidMethod(env, time_jobj, accessFunction, fullTime);
 762 }
 763
 764 /* Access method to the data */
 765 /* The data are in "byte" form */
 766 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getDataContent(JNIEnv *env, jobject jobj, jlong event_ptr, jlong data_size, jbyteArray dataArray) {
 767         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 768
 769         (*env)->SetByteArrayRegion(env, dataArray, 0, (jsize)data_size, newPtr->data);
 770 }
 771
 772 /* Get of data_size */
 773 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventDataSize(JNIEnv *env, jobject jobj, jlong event_ptr) {
 774         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 775
 776         return (jlong)newPtr->data_size;
 777 }
 778
 779 /* Get of event_size */
 780 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventSize(JNIEnv *env, jobject jobj, jlong event_ptr) {
 781         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 782
 783         return (jlong)newPtr->event_size;
 784 }
 785
 786 /* Get of count */
 787 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCount(JNIEnv *env, jobject jobj, jlong event_ptr) {
 788         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 789
 790         return (jint)newPtr->count;
 791 }
 792
 793 /* Get of overflow_nsec */
 794 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOverflowNanoSeconds(JNIEnv *env, jobject jobj, jlong event_ptr) {
 795         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 796
 797         return CONVERT_UINT64_TO_JLONG(newPtr->overflow_nsec);
 798 }
 799
 800
 801 /* Function to print the content of a event */
 802 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1printEvent(JNIEnv *env, jobject jobj, jlong event_ptr) {
 803         LttEvent *newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
 804
 805         printf("tracefile               : %p\n"  ,(void*)newPtr->tracefile );
 806         printf("block                   : %u\n"  ,(unsigned int)newPtr->block );
 807         printf("offset                  : %u\n"  ,(unsigned int)newPtr->offset );
 808         printf("tsc                     : %lu\n" ,(long unsigned int)newPtr->tsc );
 809         printf("timestamp               : %u\n"  ,(unsigned int)newPtr->timestamp );
 810         printf("event_id                : %u\n"  ,(unsigned short)newPtr->event_id );
 811         printf("event_time              : %p\n"  ,(void*) &newPtr->event_time );
 812         printf("   sec                  : %lu\n" ,(long unsigned int)(newPtr->event_time.tv_sec) );
 813         printf("   nsec                 : %lu\n" ,(long unsigned int)(newPtr->event_time.tv_nsec) );
 814         printf("data                    : %p\n"  ,(void*) newPtr->data );
 815         printf("data_size               : %u\n"  ,(unsigned int)newPtr->data_size );
 816         printf("event_size              : %u\n"  ,(unsigned int)newPtr->event_size );
 817         printf("count                   : %d\n"  ,(int)newPtr->count );
 818         printf("overflow_nsec           : %ld\n" ,(long)newPtr->overflow_nsec );
 819         printf("\n");
 820 }
 821 /*
 822 #
 823 ### */
 824
 825
 826 /*
 827 ### MARKER method ###
 828 #  */
 829
 830 /* Get of name */
 831 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getName(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 832         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 833
 834         return (*env)->NewStringUTF(env, g_quark_to_string(newPtr->name));
 835 }
 836
 837 /* Get of format */
 838 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getFormatOverview(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 839         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 840
 841         return (*env)->NewStringUTF(env, newPtr->format);
 842 }
 843
 844 /* Get of size */
 845 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 846         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 847
 848         return (jlong)newPtr->size;
 849 }
 850
 851 /* Method to get all markerField pointers */
 852 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAllMarkerFields(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 853         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 854
 855         jclass accessClass = (*env)->GetObjectClass(env, jobj);
 856         jmethodID accessFunction = (*env)->GetMethodID(env, accessClass, "addMarkerFieldFromC", "(Ljava/lang/String;J)V");
 857
 858         GArray *field_array = (GArray*)newPtr->fields;
 859         struct marker_field *field;
 860         jlong marker_field_ptr;
 861
 862         unsigned int i;
 863         for (i=0; i<field_array->len; i++) {
 864                 field = &g_array_index(field_array, struct marker_field, i);
 865
 866                 marker_field_ptr = CONVERT_PTR_TO_JLONG(field);
 867
 868                 (*env)->CallVoidMethod(env, jobj, accessFunction, (*env)->NewStringUTF(env, g_quark_to_string(field->name) ), marker_field_ptr );
 869         }
 870 }
 871
 872
 873
 874 /* Get of largest_align */
 875 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLargestAlign(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 876         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 877
 878         return (jshort)newPtr->largest_align;
 879 }
 880
 881 /* Get of int_size */
 882 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getIntSize(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 883         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 884
 885         return (jshort)newPtr->int_size;
 886 }
 887
 888 /* Get of long_size */
 889 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLongSize(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 890         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 891
 892         return (jshort)newPtr->long_size;
 893 }
 894
 895 /* Get of pointer_size */
 896 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getPointerSize(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 897         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 898
 899         return (jshort)newPtr->pointer_size;
 900 }
 901
 902 /* Get of size_t_size */
 903 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize_1tSize(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 904         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 905
 906         return (jshort)newPtr->size_t_size;
 907 }
 908
 909 /* Get of alignment */
 910 JNIEXPORT jshort JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAlignement(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 911         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 912
 913         return (jshort)newPtr->alignment;
 914 }
 915
 916 /* Get of next */
 917 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getNextMarkerPtr(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 918         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 919
 920         return CONVERT_PTR_TO_JLONG(newPtr->next);
 921 }
 922
 923
 924 /* Function to print the content of a marker */
 925 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1printMarker(JNIEnv *env, jobject jobj, jlong marker_info_ptr) {
 926         struct marker_info *newPtr = (struct marker_info*)CONVERT_JLONG_TO_PTR(marker_info_ptr);
 927
 928         printf("name          : %s\n"  ,g_quark_to_string(newPtr->name) );
 929         printf("format        : %s\n"  ,newPtr->format );
 930         printf("size          : %li\n" ,(long int)newPtr->size );
 931         printf("largest_align : %u\n"  ,(unsigned short)newPtr->largest_align );
 932         printf("fields        : %p\n"  ,newPtr->fields );
 933         printf("int_size      : %u\n"  ,(unsigned short)newPtr->int_size );
 934         printf("long_size     : %u\n"  ,(unsigned short)newPtr->long_size );
 935         printf("pointer_size  : %u\n"  ,(unsigned short)newPtr->pointer_size );
 936         printf("size_t_size   : %u\n"  ,(unsigned short)newPtr->size_t_size );
 937         printf("alignment     : %u\n"  ,(unsigned short)newPtr->alignment );
 938         printf("next          : %p\n"  ,newPtr->next );
 939         printf("\n");
 940 }
 941 /*
 942 #
 943 ### */
 944
 945
 946
 947 /*
 948 ### MARKERFIELD Method
 949 #  */
 950
 951 /* Get of name */
 952 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getField(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 953         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 954
 955         return (*env)->NewStringUTF(env, g_quark_to_string(newPtr->name));
 956 }
 957
 958 /* Get of type */
 959 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getType(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 960         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 961
 962         return (jint)newPtr->type;
 963 }
 964
 965 /* Get of offset */
 966 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getOffset(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 967         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 968
 969         return CONVERT_UINT64_TO_JLONG(newPtr->offset);
 970 }
 971
 972 /* Get of size */
 973 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getSize(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 974         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 975
 976         return CONVERT_UINT64_TO_JLONG(newPtr->size);
 977 }
 978
 979 /* Get of alignment */
 980 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAlignment(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 981         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 982
 983         return CONVERT_UINT64_TO_JLONG(newPtr->alignment);
 984 }
 985
 986 /* Get of attributes */
 987 JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAttributes(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 988         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 989
 990         return CONVERT_UINT64_TO_JLONG(newPtr->attributes);
 991 }
 992
 993 /* Get of static_offset */
 994 JNIEXPORT jint JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getStatic_1offset(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
 995         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
 996
 997         return (jint)newPtr->static_offset;
 998 }
 999
1000 /* Get of fmt */
1001 JNIEXPORT jstring JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getFormat(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
1002         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
1003
1004         return (*env)->NewStringUTF(env, newPtr->fmt->str);
1005 }
1006
1007 /* Function to print the content of a marker_field */
1008 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1printMarkerField(JNIEnv *env, jobject jobj, jlong marker_field_ptr) {
1009         struct marker_field *newPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
1010
1011         printf("name          : %s\n"  ,g_quark_to_string(newPtr->name) );
1012         printf("type          : %i\n"  ,(int)newPtr->type );
1013         printf("offset        : %lu\n" ,(long unsigned int)newPtr->offset );
1014         printf("size          : %lu\n" ,(long unsigned int)newPtr->size );
1015         printf("alignment     : %lu\n" ,(long unsigned int)newPtr->alignment );
1016         printf("attributes    : %lu\n" ,(long unsigned int)newPtr->attributes );
1017         printf("static_offset : %i\n"  ,(int)newPtr->static_offset );
1018         printf("fmt           : %s\n"  ,newPtr->fmt->str );
1019         printf("\n");
1020 }
1021 /*
1022 #
1023 ### */
1024
1025
1026 /*
1027 ### PARSER Method
1028 # */
1029
1030 /* This function will do the actual parsing  */
1031 /*      It will then call java to assign the parsed data to the object "javaObj" */
1032 JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData(JNIEnv *env, jclass accessClass, jobject javaObj, jlong event_ptr, jlong marker_field_ptr) {
1033         LttEvent newEventPtr = *(LttEvent*)(CONVERT_JLONG_TO_PTR(event_ptr));
1034         struct marker_field *newMarkerFieldPtr = (struct marker_field*)CONVERT_JLONG_TO_PTR(marker_field_ptr);
1035
1036         jmethodID accessFunction = NULL;
1037
1038
1039         /*
1040           There is a very limited number of type in LTT
1041           We will switch on the type for this field and act accordingly
1042              NOTE : We will save all integer into "long" type, as there is no signed/unsigned in java */
1043
1044         /* ***HACK***
1045            It seems the marker_field->type is absolutely not consistent, especially about pointer!
1046               Sometime pointer are saved in String, sometime as Int, sometime as pointer...
1047            We will do an extra check on type "LTT_TYPE_UNSIGNED_INT" to check if the marker_field->format is hint of a pointer  */
1048         switch ( newMarkerFieldPtr->type ) {
1049                 case LTT_TYPE_SIGNED_INT :
1050                         accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1051                         (*env)->CallStaticVoidMethod(   env,
1052                                                         accessClass,
1053                                                         accessFunction,
1054                                                         javaObj,
1055                                                         ltt_event_get_long_int(&newEventPtr, newMarkerFieldPtr)
1056                                                      );
1057
1058                         break;
1059
1060                 case LTT_TYPE_UNSIGNED_INT :
1061                         /* If the format seems to be a pointer, add it as a pointer */
1062                         if ( (strncmp(newMarkerFieldPtr->fmt->str, "0x%llX", newMarkerFieldPtr->fmt->len) == 0 ) || (strncmp(newMarkerFieldPtr->fmt->str, "%llX", newMarkerFieldPtr->fmt->len) == 0 ) ) {
1063                                 #if __WORDSIZE == 64
1064                                         accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1065                                 #else
1066                                         accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1067                                 #endif
1068                                 (*env)->CallStaticVoidMethod(   env,
1069                                                                 accessClass,
1070                                                                 accessFunction,
1071                                                                 javaObj,
1072                                                                 CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr, newMarkerFieldPtr) )
1073                                                              );
1074                         }
1075                         /* Otherwise, add it as a number */
1076                         else {
1077                                 accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1078                                 (*env)->CallStaticVoidMethod(   env,
1079                                                                 accessClass,
1080                                                                 accessFunction,
1081                                                                 javaObj,
1082                                                                 ltt_event_get_long_unsigned(&newEventPtr, newMarkerFieldPtr)
1083                                                              );
1084                         }
1085
1086                         break;
1087
1088                 case LTT_TYPE_POINTER :
1089                         #if __WORDSIZE == 64
1090                                 accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1091                         #else
1092                                 accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1093                         #endif
1094                         (*env)->CallStaticVoidMethod(   env,
1095                                                         accessClass,
1096                                                         accessFunction,
1097                                                         javaObj,
1098                                                         CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR*)(newEventPtr.data + newMarkerFieldPtr->offset))
1099                                                      );
1100                         break;
1101
1102                 case LTT_TYPE_STRING :
1103                         accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;)V");
1104                         (*env)->CallStaticVoidMethod(   env,
1105                                                         accessClass,
1106                                                         accessFunction,
1107                                                         javaObj,
1108                                                         (*env)->NewStringUTF(env, ltt_event_get_string(&newEventPtr, newMarkerFieldPtr) )
1109                                                      );
1110                         break;
1111
1112                 case LTT_TYPE_COMPACT :
1113                 case LTT_TYPE_NONE :
1114                 default :
1115                         printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData)");
1116                         break;
1117         }
1118
1119 }
1120 /*
1121 #
1122 ###  */