ltt/jni_interface.c

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