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