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