ltt/jni_interface.c

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