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