#if __WORDSIZE == 64
#define CONVERT_JLONG_TO_PTR(p) (p)
+ #define CONVERT_PTR_TO_JLONG(p) (jlong)(p)
// Define the "gint" type we should use for pointer.
- #define GINT_TYPE_FOR_PTR gint32
+ #define GINT_TYPE_FOR_PTR gint64
#else
// Conversion to int first to save warning
#define CONVERT_JLONG_TO_PTR(p) (int)(p)
#define CONVERT_PTR_TO_JLONG(p) (jlong)(int)(p)
// Define the "gint" type we should use for pointer.
- #define GINT_TYPE_FOR_PTR gint64
+ #define GINT_TYPE_FOR_PTR gint32
#endif
// Structure to encapsulate java_data to pass as arguments
};
// *** TODO **
+// All these struct are used to call g_datalist_foreach()
// Find a better way! This is ugly!
struct addMarkersArgs
{
struct marker_data* mdata;
};
+struct saveTimeArgs
+{
+ GArray* saveTimeArray;
+};
+
+struct saveTimeAndTracefile
+{
+ LttTime time;
+ LttTracefile* tracefile;
+};
+
// ### COMMON Methods ###
// #
+// Empty method to turn off the debug (debug waste time while printing)
+void ignore_and_drop_message(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
+{
+}
+
+
// JNI method to call printf from the java side
JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_Jni_1C_1Common_ltt_1printC(JNIEnv* env, jobject jobj, jstring new_string)
{
- printf( (*env)->GetStringUTFChars(env, new_string, 0) );
+ const char* c_msg = (*env)->GetStringUTFChars(env, new_string, 0);
+
+ printf("%s", c_msg );
+
+ (*env)->ReleaseStringUTFChars(env, new_string, c_msg);
}
-
// #
// ####
// ### TRACE methods ###
// #
// JNI mapping of < LttTrace *ltt_trace_open(const gchar *pathname) > (trace.h)
-JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv* env, jobject jobj, jstring pathname) {
+JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv* env, jobject jobj, jstring pathname, jboolean show_debug) {
+
+ if ( !show_debug) {
+ // Make sure we don't use any debug (speed up the read)
+ g_log_set_handler(NULL, G_LOG_LEVEL_INFO, ignore_and_drop_message, NULL);
+ g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, ignore_and_drop_message, NULL);
+ }
+
const char* c_pathname = (*env)->GetStringUTFChars(env, pathname, 0);
LttTrace* newPtr = ltt_trace_open( c_pathname );
jclass accessClass = (*args->env)->GetObjectClass(args->env, args->jobj);
jmethodID accessFunction = (*args->env)->GetMethodID(args->env, accessClass, "addTracefileFromC", "(Ljava/lang/String;J)V");
- GArray* group = (GArray*)data;
+ GArray* tracefile_array = (GArray*)data;
LttTracefile* tracefile;
jlong newPtr;
unsigned int i;
- for (i=0; i<group->len; i++) {
- tracefile = &g_array_index(group, LttTracefile, i);
+ for (i=0; i<tracefile_array->len; i++) {
+ tracefile = &g_array_index(tracefile_array, LttTracefile, i);
newPtr = CONVERT_PTR_TO_JLONG(tracefile);
}
// Function to fill up the java map with the event type found in tracefile (the name)
-JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getAllTracefiles(JNIEnv* env, jobject jobj, jlong trace_ptr) {
+JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedAllTracefiles(JNIEnv* env, jobject jobj, jlong trace_ptr) {
LttTrace* newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
struct java_calling_data args = { env, jobj };
}
-// Function to print the content of a tracefile
+// g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange
+// used to save the current timestamp for each tracefile
+void g_datalist_foreach_saveTracefilesTime(GQuark name, gpointer data, gpointer user_data) {
+ struct saveTimeArgs* args = (struct saveTimeArgs*)user_data;
+
+ GArray* tracefile_array = (GArray*)data;
+ GArray* save_array = args->saveTimeArray;
+
+ LttTracefile* tracefile;
+ struct saveTimeAndTracefile* savedData;
+
+ unsigned int i;
+ for (i=0; i<tracefile_array->len; i++) {
+ tracefile = &g_array_index(tracefile_array, LttTracefile, i);
+
+ // Allocate a new LttTime for each tracefile (so it won't change if the tracefile seek somewhere else)
+ savedData = (struct saveTimeAndTracefile*)malloc( sizeof(struct saveTimeAndTracefile) );
+ savedData->time.tv_sec = tracefile->event.event_time.tv_sec;
+ savedData->time.tv_nsec = tracefile->event.event_time.tv_nsec;
+ savedData->tracefile = tracefile;
+ // Append the saved data to the array
+ g_array_append_val(save_array, savedData);
+ }
+}
+
+
+// Obtain the range of the trace (i.e. "start time" and "end time")
+//
+// Note : This function, unlike ltt_trace_time_span_get, is assured to return all tracefiles to their correct position after operation
+// NOTE : this method is quite heavy to use!!!
+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) {
+ LttTrace* newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
+
+ // Allocate ourself a new array to save the data in
+ GArray* savedDataArray = g_array_new(FALSE, FALSE, sizeof(struct saveTimeAndTracefile*) );
+ struct saveTimeArgs args = { savedDataArray };
+ // Call g_datalist_foreach_saveTracefilesTime for each element in the GData to save the time
+ g_datalist_foreach(&newPtr->tracefiles, &g_datalist_foreach_saveTracefilesTime, &args);
+
+ // Call to ltt_trace_time_span_get to find the current start and end time
+ // NOTE : This WILL change the current block of the tracefile (i.e. its timestamp)
+ LttTime tmpStartTime = { 0, 0 };
+ LttTime tmpEndTime = { 0, 0 };
+ ltt_trace_time_span_get(newPtr, &tmpStartTime, &tmpEndTime);
+
+ // Seek back to the correct time for each tracefile and free the allocated memory
+ struct saveTimeAndTracefile* savedData;
+ unsigned int i;
+ for (i=0; i<savedDataArray->len; i++) {
+ savedData = g_array_index(savedDataArray, struct saveTimeAndTracefile*, i);
+ // Seek back to the correct time
+ // Some time will not be consistent here (i.e. unitialized data)
+ // but the seek should work just fine with that
+ ltt_tracefile_seek_time(savedData->tracefile, savedData->time);
+
+ // Free the memory allocated for this saveTimeAndTracefile entry
+ free( savedData );
+ }
+ // Free the memory allocated for the GArray
+ g_array_free(savedDataArray, TRUE);
+
+ // Send the start and end time back to the java
+ // We do it last to make sure a problem won't leave us with unfred memory
+ jclass startAccessClass = (*env)->GetObjectClass(env, jstart_time);
+ jmethodID startAccessFunction = (*env)->GetMethodID(env, startAccessClass, "setTimeFromC", "(J)V");
+ jlong startTime = (CONVERT_UINT64_TO_JLONG(tmpStartTime.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(tmpStartTime.tv_nsec);
+ (*env)->CallVoidMethod(env, jstart_time, startAccessFunction, startTime);
+
+ jclass endAccessClass = (*env)->GetObjectClass(env, jend_time);
+ jmethodID endAccessFunction = (*env)->GetMethodID(env, endAccessClass, "setTimeFromC", "(J)V");
+ jlong endTime = (CONVERT_UINT64_TO_JLONG(tmpEndTime.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(tmpEndTime.tv_nsec);
+ (*env)->CallVoidMethod(env, jend_time, endAccessFunction, endTime);
+}
+
+// Function to print the content of a trace
JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1printTrace(JNIEnv* env, jobject jobj, jlong trace_ptr) {
LttTrace* newPtr = (LttTrace*)CONVERT_JLONG_TO_PTR(trace_ptr);
printf("start_freq : %lu\n" ,(long unsigned int)(newPtr->start_freq) );
printf("start_tsc : %lu\n" ,(long unsigned int)(newPtr->start_tsc) );
printf("start_monotonic : %lu\n" ,(long unsigned int)(newPtr->start_monotonic) );
- printf("start_time ptr : 0x%p\n" ,&newPtr->start_time);
+ printf("start_time ptr : %p\n" ,&newPtr->start_time);
printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr->start_time.tv_sec) );
printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr->start_time.tv_nsec) );
- printf("start_time_from_tsc ptr : 0x%p\n" ,&newPtr->start_time_from_tsc);
+ printf("start_time_from_tsc ptr : %p\n" ,&newPtr->start_time_from_tsc);
printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr->start_time_from_tsc.tv_sec) );
printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr->start_time_from_tsc.tv_nsec) );
- printf("tracefiles ptr : 0x%p\n" ,newPtr->tracefiles);
+ printf("tracefiles ptr : %p\n" ,newPtr->tracefiles);
printf("\n");
}
// #
// ### TRACEFILE methods ###
// #
+
// Get of cpu_online
JNIEXPORT jboolean JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsCpuOnline(JNIEnv* env, jobject jobj, jlong tracefile_ptr) {
LttTracefile* newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
return CONVERT_PTR_TO_JLONG(&newPtr->buffer);
}
-// Get of buf_size
+// Get of buffer size
JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferSize(JNIEnv* env, jobject jobj, jlong tracefile_ptr) {
LttTracefile* newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
- return (jlong)newPtr->buf_size;
+ return (jlong)newPtr->buffer.size;
}
}
// Function to fill up the java map with the event type found in tracefile (the name)
-JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAllMarkers(JNIEnv* env, jobject jobj, jlong tracefile_ptr) {
+JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1feedAllMarkers(JNIEnv* env, jobject jobj, jlong tracefile_ptr) {
LttTracefile* newPtr = (LttTracefile*)CONVERT_JLONG_TO_PTR(tracefile_ptr);
// *** TODO ***
printf("tid : %u\n" ,(unsigned int)(newPtr->tid));
printf("pgid : %u\n" ,(unsigned int)(newPtr->pgid));
printf("creation : %lu\n" ,(long unsigned int)(newPtr->creation));
- printf("trace ptr : 0x%p\n" ,newPtr->trace);
- printf("marker ptr : 0x%p\n" ,newPtr->mdata);
+ printf("trace ptr : %p\n" ,newPtr->trace);
+ printf("marker ptr : %p\n" ,newPtr->mdata);
printf("fd : %i\n" ,(int)(newPtr->fd));
printf("file_size : %u\n" ,(unsigned int)(newPtr->file_size));
printf("num_blocks : %u\n" ,(unsigned int)(newPtr->num_blocks));
printf("tsc_mask_next_bit : %lu\n" ,(long unsigned int)newPtr->tsc_mask_next_bit);
printf("events_lost : %u\n" ,(unsigned int)newPtr->events_lost);
printf("subbuf_corrupt : %u\n" ,(unsigned int)newPtr->subbuf_corrupt);
- printf("event ptr : 0x%p\n" ,&newPtr->event);
- printf("buffer ptr : 0x%p\n" ,&newPtr->buffer);
- printf("buf_size : %i\n" ,(unsigned int)newPtr->buf_size);
+ printf("event ptr : %p\n" ,&newPtr->event);
+ printf("buffer ptr : %p\n" ,&newPtr->buffer);
printf("\n");
}
// #
int returnedValue = ltt_tracefile_read(newPtr);
- // According to Ltt documentation, we need to get back to beginning after an error
+ // We need to get back to previous after an error to keep a sane state
if ( returnedValue != 0 ) {
ltt_tracefile_seek_time(newPtr, lastTime);
}
return (jint)newPtr->event_id;
}
-// Get of event_time
+// Get time in nanoseconds
+JNIEXPORT jlong JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getNanosencondsTime(JNIEnv* env, jobject jobj, jlong event_ptr) {
+ LttEvent* newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
+
+ return (CONVERT_UINT64_TO_JLONG(newPtr->event_time.tv_sec)*BILLION) + CONVERT_UINT64_TO_JLONG(newPtr->event_time.tv_nsec);
+}
+
+// Fill event_time into an object
JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1feedEventTime(JNIEnv* env, jobject jobj, jlong event_ptr, jobject time_jobj) {
LttEvent* newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
JNIEXPORT void JNICALL Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1printEvent(JNIEnv* env, jobject jobj, jlong event_ptr) {
LttEvent* newPtr = (LttEvent*)CONVERT_JLONG_TO_PTR(event_ptr);
- printf("tracefile : 0x%p\n",(void*)newPtr->tracefile );
+ printf("tracefile : %p\n" ,(void*)newPtr->tracefile );
printf("block : %u\n" ,(unsigned int)newPtr->block );
printf("offset : %u\n" ,(unsigned int)newPtr->offset );
printf("tsc : %lu\n" ,(long unsigned int)newPtr->tsc );
printf("timestamp : %u\n" ,(unsigned int)newPtr->timestamp );
printf("event_id : %u\n" ,(unsigned short)newPtr->event_id );
- printf("event_time : 0x%p\n",(void*) &newPtr->event_time );
+ printf("event_time : %p\n" ,(void*) &newPtr->event_time );
printf(" sec : %lu\n" ,(long unsigned int)(newPtr->event_time.tv_sec) );
printf(" nsec : %lu\n" ,(long unsigned int)(newPtr->event_time.tv_nsec) );
- printf("data : 0x%p\n",(void*) newPtr->data );
+ printf("data : %p\n" ,(void*) newPtr->data );
printf("data_size : %u\n" ,(unsigned int)newPtr->data_size );
printf("event_size : %u\n" ,(unsigned int)newPtr->event_size );
printf("count : %d\n" ,(int)newPtr->count );
printf("format : %s\n" ,newPtr->format );
printf("size : %li\n" ,(long int)newPtr->size );
printf("largest_align : %u\n" ,(unsigned short)newPtr->largest_align );
- printf("fields : 0x%p\n",newPtr->fields );
+ printf("fields : %p\n" ,newPtr->fields );
printf("int_size : %u\n" ,(unsigned short)newPtr->int_size );
printf("long_size : %u\n" ,(unsigned short)newPtr->long_size );
printf("pointer_size : %u\n" ,(unsigned short)newPtr->pointer_size );
printf("size_t_size : %u\n" ,(unsigned short)newPtr->size_t_size );
printf("alignment : %u\n" ,(unsigned short)newPtr->alignment );
- printf("next : 0x%p\n",newPtr->next );
+ printf("next : %p\n" ,newPtr->next );
printf("\n");
}
// We will do an extra check on type "LTT_TYPE_UNSIGNED_INT" to check if the marker_field->format is hint of a pointer
switch ( newMarkerFieldPtr->type ) {
case LTT_TYPE_SIGNED_INT :
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;J)V");
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
(*env)->CallStaticVoidMethod( env,
accessClass,
accessFunction,
javaObj,
- (*env)->NewStringUTF(env, g_quark_to_string(newMarkerFieldPtr->name) ),
- ltt_event_get_long_int(&newEventPtr, newMarkerFieldPtr),
- (*env)->NewStringUTF(env, newMarkerFieldPtr->fmt->str )
+ ltt_event_get_long_int(&newEventPtr, newMarkerFieldPtr)
);
break;
case LTT_TYPE_UNSIGNED_INT :
-
// If the format seems to be a pointer, add it as a pointer
if ( (strncmp(newMarkerFieldPtr->fmt->str, "0x%llX", newMarkerFieldPtr->fmt->len) == 0 ) || (strncmp(newMarkerFieldPtr->fmt->str, "%llX", newMarkerFieldPtr->fmt->len) == 0 ) ) {
- #if ARCHITECTURE_IS_64BITS == 0
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addIntPointerToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;J)V");
+ #if __WORDSIZE == 64
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
#else
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongPointerToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;J)V");
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
#endif
(*env)->CallStaticVoidMethod( env,
accessClass,
accessFunction,
javaObj,
- (*env)->NewStringUTF(env, g_quark_to_string(newMarkerFieldPtr->name) ),
- CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr, newMarkerFieldPtr) ),
- (*env)->NewStringUTF(env, newMarkerFieldPtr->fmt->str )
+ CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr, newMarkerFieldPtr) )
);
}
// Otherwise, add it as a number
else {
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;J)V");
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
(*env)->CallStaticVoidMethod( env,
accessClass,
accessFunction,
javaObj,
- (*env)->NewStringUTF(env, g_quark_to_string(newMarkerFieldPtr->name) ),
- ltt_event_get_long_unsigned(&newEventPtr, newMarkerFieldPtr),
- (*env)->NewStringUTF(env, newMarkerFieldPtr->fmt->str )
+ ltt_event_get_long_unsigned(&newEventPtr, newMarkerFieldPtr)
);
}
break;
case LTT_TYPE_POINTER :
- #if ARCHITECTURE_IS_64BITS == 0
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addIntPointerToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;J)V");
+ #if __WORDSIZE == 64
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
#else
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addLongPointerToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;J)V");
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
#endif
(*env)->CallStaticVoidMethod( env,
accessClass,
accessFunction,
javaObj,
- (*env)->NewStringUTF(env, g_quark_to_string(newMarkerFieldPtr->name) ),
- CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR*)(newEventPtr.data + newMarkerFieldPtr->offset)),
- (*env)->NewStringUTF(env, newMarkerFieldPtr->fmt->str )
+ CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR*)(newEventPtr.data + newMarkerFieldPtr->offset))
);
break;
case LTT_TYPE_STRING :
- accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V");
+ accessFunction = (*env)->GetStaticMethodID(env, accessClass, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;)V");
(*env)->CallStaticVoidMethod( env,
accessClass,
accessFunction,
javaObj,
- (*env)->NewStringUTF(env, g_quark_to_string(newMarkerFieldPtr->name) ),
- (*env)->NewStringUTF(env, ltt_event_get_string(&newEventPtr, newMarkerFieldPtr) ),
- (*env)->NewStringUTF(env, newMarkerFieldPtr->fmt->str )
+ (*env)->NewStringUTF(env, ltt_event_get_string(&newEventPtr, newMarkerFieldPtr) )
);
break;
case LTT_TYPE_COMPACT :
case LTT_TYPE_NONE :
default :
- printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1fillParseArray)");
+ printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData)");
break;
}