2 // !! Important to get consistent size_t type
3 #define _FILE_OFFSET_BITS 64
9 #include <ltt/marker.h>
19 // We've got hell of a problem passing "unsigned int64" to java, as there is no equivalent type
20 // The closer we can use is "long" which is signed, so only 32 (or 63?) bits are valid
21 // Plus, even if we are within the "32 bits" capacity, java sometime screw itself trying to convert "unsigned 64 -> signed 64"
22 // This happen especially often when RETURNING a jlong
23 // So when returning a jlong, we should convert it like this : "unsigned 64"->"signed 64"->jlong
24 #define CONVERT_UINT64_TO_JLONG(n) (jlong)(gint64)(n)
25 #define CONVERT_INT64_TO_JLONG(n) (jlong)(gint64)(n)
27 // To ease calcul involving nano
28 #define BILLION 1000000000
32 #define CONVERT_JLONG_TO_PTR(p) (p)
33 #define CONVERT_PTR_TO_JLONG(p) (jlong)(p)
34 // Define the "gint" type we should use for pointer.
35 #define GINT_TYPE_FOR_PTR gint64
37 // Conversion to int first to save warning
38 #define CONVERT_JLONG_TO_PTR(p) (int)(p)
39 #define CONVERT_PTR_TO_JLONG(p) (jlong)(int)(p)
40 // Define the "gint" type we should use for pointer.
41 #define GINT_TYPE_FOR_PTR gint32
44 // Structure to encapsulate java_data to pass as arguments
45 struct java_calling_data
52 // All these struct are used to call g_datalist_foreach()
53 // Find a better way! This is ugly!
56 struct java_calling_data
* java_args
;
57 struct marker_data
* mdata
;
62 GArray
* saveTimeArray
;
65 struct saveTimeAndTracefile
68 LttTracefile
* tracefile
;
72 // ### COMMON Methods ###
74 // Empty method to turn off the debug (debug waste time while printing)
75 void ignore_and_drop_message(const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
80 // JNI method to call printf from the java side
81 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_Jni_1C_1Common_ltt_1printC(JNIEnv
* env
, jobject jobj
, jstring new_string
)
83 const char* c_msg
= (*env
)->GetStringUTFChars(env
, new_string
, 0);
87 (*env
)->ReleaseStringUTFChars(env
, new_string
, c_msg
);
94 // ### TRACE methods ###
96 // JNI mapping of < LttTrace *ltt_trace_open(const gchar *pathname) > (trace.h)
97 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv
* env
, jobject jobj
, jstring pathname
, jboolean show_debug
) {
100 // Make sure we don't use any debug (speed up the read)
101 g_log_set_handler(NULL
, G_LOG_LEVEL_INFO
, ignore_and_drop_message
, NULL
);
102 g_log_set_handler(NULL
, G_LOG_LEVEL_DEBUG
, ignore_and_drop_message
, NULL
);
105 const char* c_pathname
= (*env
)->GetStringUTFChars(env
, pathname
, 0);
106 LttTrace
* newPtr
= ltt_trace_open( c_pathname
);
108 (*env
)->ReleaseStringUTFChars(env
, pathname
, c_pathname
);
110 return CONVERT_PTR_TO_JLONG(newPtr
);
113 // JNI mapping of < void ltt_trace_close(LttTrace *t) > (trace.h)
114 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1closeTrace(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
){
116 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
118 ltt_trace_close(newPtr
);
122 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getTracepath(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
123 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
125 return (*env
)->NewStringUTF(env
, g_quark_to_string( newPtr
->pathname
) );
130 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getCpuNumber(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
131 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
133 return (jint
)newPtr
->num_cpu
;
137 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchType(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
138 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
140 return (jlong
)newPtr
->arch_type
;
143 // Get of arch_variant
144 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchVariant(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
145 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
147 return (jlong
)newPtr
->arch_variant
;
151 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchSize(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
152 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
154 return (jshort
)newPtr
->arch_size
;
157 // Get of ltt_major_version
158 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMajorVersion(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
159 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
161 return (jshort
)newPtr
->ltt_major_version
;
164 // Get of ltt_minor_version
165 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMinorVersion(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
166 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
168 return (jshort
)newPtr
->ltt_minor_version
;
171 // Get of flight_recorder
172 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFlightRecorder(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
173 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
175 return (jshort
)newPtr
->flight_recorder
;
179 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFreqScale(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
180 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
182 return (jlong
)newPtr
->freq_scale
;
186 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartFreq(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
187 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
189 return CONVERT_UINT64_TO_JLONG(newPtr
->start_freq
);
193 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartTimestampCurrentCounter(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
194 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
196 return CONVERT_UINT64_TO_JLONG(newPtr
->start_tsc
);
199 // Get of start_monotonic
200 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartMonotonic(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
201 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
203 return CONVERT_UINT64_TO_JLONG(newPtr
->start_monotonic
);
206 // Access to start_time
207 // Note that we are calling the setTimeFromC function in Jaf_Time from here
208 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTime(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
209 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
211 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
212 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
214 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_nsec
);
216 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
219 // Access to start_time_from_tsc
220 // Note that we are calling the setTimeFromC function in Jaf_Time from here
221 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTimeFromTimestampCurrentCounter(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
222 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
224 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
225 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
227 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
);
229 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
233 // g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getAllTracefiles
234 void g_datalist_foreach_addTracefilesOfTrace(GQuark name
, gpointer data
, gpointer user_data
) {
235 struct java_calling_data
* args
= (struct java_calling_data
*)user_data
;
237 jclass accessClass
= (*args
->env
)->GetObjectClass(args
->env
, args
->jobj
);
238 jmethodID accessFunction
= (*args
->env
)->GetMethodID(args
->env
, accessClass
, "addTracefileFromC", "(Ljava/lang/String;J)V");
240 GArray
* tracefile_array
= (GArray
*)data
;
241 LttTracefile
* tracefile
;
245 for (i
=0; i
<tracefile_array
->len
; i
++) {
246 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
248 newPtr
= CONVERT_PTR_TO_JLONG(tracefile
);
250 (*args
->env
)->CallVoidMethod(args
->env
, args
->jobj
, accessFunction
, (*args
->env
)->NewStringUTF(args
->env
, g_quark_to_string(tracefile
->name
) ), newPtr
);
254 // Function to fill up the java map with the event type found in tracefile (the name)
255 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedAllTracefiles(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
256 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
258 struct java_calling_data args
= { env
, jobj
};
260 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_addTracefilesOfTrace
, &args
);
264 // g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange
265 // used to save the current timestamp for each tracefile
266 void g_datalist_foreach_saveTracefilesTime(GQuark name
, gpointer data
, gpointer user_data
) {
267 struct saveTimeArgs
* args
= (struct saveTimeArgs
*)user_data
;
269 GArray
* tracefile_array
= (GArray
*)data
;
270 GArray
* save_array
= args
->saveTimeArray
;
272 LttTracefile
* tracefile
;
273 struct saveTimeAndTracefile
* savedData
;
276 for (i
=0; i
<tracefile_array
->len
; i
++) {
277 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
279 // Allocate a new LttTime for each tracefile (so it won't change if the tracefile seek somewhere else)
280 savedData
= (struct saveTimeAndTracefile
*)malloc( sizeof(struct saveTimeAndTracefile
) );
281 savedData
->time
.tv_sec
= tracefile
->event
.event_time
.tv_sec
;
282 savedData
->time
.tv_nsec
= tracefile
->event
.event_time
.tv_nsec
;
283 savedData
->tracefile
= tracefile
;
284 // Append the saved data to the array
285 g_array_append_val(save_array
, savedData
);
290 // Obtain the range of the trace (i.e. "start time" and "end time")
292 // Note : This function, unlike ltt_trace_time_span_get, is assured to return all tracefiles to their correct position after operation
293 // NOTE : this method is quite heavy to use!!!
294 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
) {
295 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
297 // Allocate ourself a new array to save the data in
298 GArray
* savedDataArray
= g_array_new(FALSE
, FALSE
, sizeof(struct saveTimeAndTracefile
*) );
299 struct saveTimeArgs args
= { savedDataArray
};
300 // Call g_datalist_foreach_saveTracefilesTime for each element in the GData to save the time
301 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_saveTracefilesTime
, &args
);
303 // Call to ltt_trace_time_span_get to find the current start and end time
304 // NOTE : This WILL change the current block of the tracefile (i.e. its timestamp)
305 LttTime tmpStartTime
= { 0, 0 };
306 LttTime tmpEndTime
= { 0, 0 };
307 ltt_trace_time_span_get(newPtr
, &tmpStartTime
, &tmpEndTime
);
309 // Seek back to the correct time for each tracefile and free the allocated memory
310 struct saveTimeAndTracefile
* savedData
;
312 for (i
=0; i
<savedDataArray
->len
; i
++) {
313 savedData
= g_array_index(savedDataArray
, struct saveTimeAndTracefile
*, i
);
314 // Seek back to the correct time
315 // Some time will not be consistent here (i.e. unitialized data)
316 // but the seek should work just fine with that
317 ltt_tracefile_seek_time(savedData
->tracefile
, savedData
->time
);
319 // Free the memory allocated for this saveTimeAndTracefile entry
322 // Free the memory allocated for the GArray
323 g_array_free(savedDataArray
, TRUE
);
325 // Send the start and end time back to the java
326 // We do it last to make sure a problem won't leave us with unfred memory
327 jclass startAccessClass
= (*env
)->GetObjectClass(env
, jstart_time
);
328 jmethodID startAccessFunction
= (*env
)->GetMethodID(env
, startAccessClass
, "setTimeFromC", "(J)V");
329 jlong startTime
= (CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_nsec
);
330 (*env
)->CallVoidMethod(env
, jstart_time
, startAccessFunction
, startTime
);
332 jclass endAccessClass
= (*env
)->GetObjectClass(env
, jend_time
);
333 jmethodID endAccessFunction
= (*env
)->GetMethodID(env
, endAccessClass
, "setTimeFromC", "(J)V");
334 jlong endTime
= (CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_nsec
);
335 (*env
)->CallVoidMethod(env
, jend_time
, endAccessFunction
, endTime
);
338 // Function to print the content of a trace
339 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1printTrace(JNIEnv
* env
, jobject jobj
, jlong trace_ptr
) {
341 LttTrace
* newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
343 printf("pathname : %s\n" ,g_quark_to_string(newPtr
->pathname
) );
344 printf("num_cpu : %u\n" ,(unsigned int)(newPtr
->num_cpu
) );
345 printf("arch_type : %u\n" ,(unsigned int)(newPtr
->arch_type
) );
346 printf("arch_variant : %u\n" ,(unsigned int)(newPtr
->arch_variant
) );
347 printf("arch_size : %u\n" ,(unsigned short)(newPtr
->arch_size
) );
348 printf("ltt_major_version : %u\n" ,(unsigned short)(newPtr
->ltt_major_version
) );
349 printf("ltt_minor_version : %u\n" ,(unsigned short)(newPtr
->ltt_minor_version
) );
350 printf("flight_recorder : %u\n" ,(unsigned short)(newPtr
->flight_recorder
) );
351 printf("freq_scale : %u\n" ,(unsigned int)(newPtr
->freq_scale
) );
352 printf("start_freq : %lu\n" ,(long unsigned int)(newPtr
->start_freq
) );
353 printf("start_tsc : %lu\n" ,(long unsigned int)(newPtr
->start_tsc
) );
354 printf("start_monotonic : %lu\n" ,(long unsigned int)(newPtr
->start_monotonic
) );
355 printf("start_time ptr : %p\n" ,&newPtr
->start_time
);
356 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_sec
) );
357 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_nsec
) );
358 printf("start_time_from_tsc ptr : %p\n" ,&newPtr
->start_time_from_tsc
);
359 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_sec
) );
360 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_nsec
) );
361 printf("tracefiles ptr : %p\n" ,newPtr
->tracefiles
);
370 // ### TRACEFILE methods ###
374 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsCpuOnline(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
375 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
377 return (jboolean
)newPtr
->cpu_online
;
381 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilepath(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
382 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
384 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->long_name
) );
388 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilename(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
389 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
391 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
) );
395 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCpuNumber(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
396 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
398 return (jlong
)newPtr
->cpu_num
;
402 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTid(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
403 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
405 return (jlong
)newPtr
->tid
;
409 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getPgid(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
410 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
412 return (jlong
)newPtr
->pgid
;
416 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCreation(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
417 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
419 return CONVERT_UINT64_TO_JLONG(newPtr
->creation
);
423 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracePtr(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
424 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
426 return CONVERT_PTR_TO_JLONG(newPtr
->trace
);
430 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getMarkerDataPtr(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
431 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
433 return CONVERT_PTR_TO_JLONG(newPtr
->mdata
);
437 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCFileDescriptor(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
438 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
440 return (jint
)newPtr
->fd
;
444 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getFileSize(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
445 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
447 return CONVERT_UINT64_TO_JLONG(newPtr
->file_size
);
451 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBlockNumber(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
452 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
454 return (jlong
)newPtr
->num_blocks
;
458 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsBytesOrderReversed(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
459 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
461 return (jboolean
)newPtr
->reverse_bo
;
464 // Get of float_word_order
465 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsFloatWordOrdered(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
466 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
468 return (jboolean
)newPtr
->float_word_order
;
472 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAlignement(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
473 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
475 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
478 // Get of buffer_header_size
479 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferHeaderSize(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
480 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
482 return CONVERT_UINT64_TO_JLONG(newPtr
->buffer_header_size
);
486 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfCurrentTimestampCounter(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
487 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
489 return (jint
)newPtr
->tscbits
;
493 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfEvent(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
494 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
496 return (jint
)newPtr
->eventbits
;
500 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMask(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
501 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
503 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask
);
506 // Get of tsc_mask_next_bit
507 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMaskNextBit(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
508 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
510 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask_next_bit
);
513 // Get of events_lost
514 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventsLost(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
515 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
517 return (jlong
)newPtr
->events_lost
;
520 // Get of subbuf_corrupt
521 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getSubBufferCorrupt(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
522 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
524 return (jlong
)newPtr
->subbuf_corrupt
;
528 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventPtr(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
529 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
531 return CONVERT_PTR_TO_JLONG(&newPtr
->event
);
535 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferPtr(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
536 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
538 return CONVERT_PTR_TO_JLONG(&newPtr
->buffer
);
541 // Get of buffer size
542 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferSize(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
543 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
545 return (jlong
)newPtr
->buffer
.size
;
549 // g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAllMarkers
550 void g_hash_table_foreach_addMarkersOfTracefile(gpointer key
, gpointer data
, gpointer user_data
) {
551 struct addMarkersArgs
* args
= (struct addMarkersArgs
*)user_data
;
552 struct java_calling_data
* jargs
= (struct java_calling_data
*)args
->java_args
;
554 jclass accessClass
= (*jargs
->env
)->GetObjectClass(jargs
->env
, jargs
->jobj
);
555 jmethodID accessFunction
= (*jargs
->env
)->GetMethodID(jargs
->env
, accessClass
, "addMarkersFromC", "(IJ)V");
557 unsigned long marker_id
= (unsigned long)data
;
559 // The hash table store an ID... we will use the ID to access the array.
560 GArray
* marker
= args
->mdata
->markers
;
561 struct marker_info
* newPtr
= &g_array_index(marker
, struct marker_info
, marker_id
);
563 (*jargs
->env
)->CallVoidMethod(jargs
->env
, jargs
->jobj
, accessFunction
, marker_id
, CONVERT_PTR_TO_JLONG(newPtr
) );
566 // Function to fill up the java map with the event type found in tracefile (the name)
567 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1feedAllMarkers(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
568 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
571 // Find a better way! This is ugly!
572 struct java_calling_data java_args
= { env
, jobj
};
573 struct addMarkersArgs args
= { &java_args
, newPtr
->mdata
};
575 g_hash_table_foreach( newPtr
->mdata
->markers_hash
, &g_hash_table_foreach_addMarkersOfTracefile
, &args
);
579 // Function to print the content of a tracefile
580 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1printTracefile(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
582 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
583 printf("cpu_online : %i\n" ,(int)newPtr
->cpu_online
);
584 printf("long_name : %s\n" ,g_quark_to_string(newPtr
->long_name
));
585 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
));
586 printf("cpu_num : %u\n" ,(unsigned int)(newPtr
->cpu_num
));
587 printf("tid : %u\n" ,(unsigned int)(newPtr
->tid
));
588 printf("pgid : %u\n" ,(unsigned int)(newPtr
->pgid
));
589 printf("creation : %lu\n" ,(long unsigned int)(newPtr
->creation
));
590 printf("trace ptr : %p\n" ,newPtr
->trace
);
591 printf("marker ptr : %p\n" ,newPtr
->mdata
);
592 printf("fd : %i\n" ,(int)(newPtr
->fd
));
593 printf("file_size : %u\n" ,(unsigned int)(newPtr
->file_size
));
594 printf("num_blocks : %u\n" ,(unsigned int)(newPtr
->num_blocks
));
595 printf("reverse_bo : %i\n" ,(int)newPtr
->reverse_bo
);
596 printf("float_word_order : %i\n" ,(int)newPtr
->float_word_order
);
597 printf("alignment : %i\n" ,(int)newPtr
->alignment
);
598 printf("buffer_header_size : %i\n" ,(int)newPtr
->buffer_header_size
);
599 printf("tscbits : %u\n" ,(unsigned short)newPtr
->tscbits
);
600 printf("eventbits : %u\n" ,(unsigned short)newPtr
->eventbits
);
601 printf("tsc_mask : %lu\n" ,(long unsigned int)newPtr
->tsc_mask
);
602 printf("tsc_mask_next_bit : %lu\n" ,(long unsigned int)newPtr
->tsc_mask_next_bit
);
603 printf("events_lost : %u\n" ,(unsigned int)newPtr
->events_lost
);
604 printf("subbuf_corrupt : %u\n" ,(unsigned int)newPtr
->subbuf_corrupt
);
605 printf("event ptr : %p\n" ,&newPtr
->event
);
606 printf("buffer ptr : %p\n" ,&newPtr
->buffer
);
614 // ### EVENT methods ###
617 // Method to get the read status
618 // This method will read the next event and then seek back its initial position
619 // Lttv assume that every tracefile have at least 1 event, but we have not guarantee after this one.
620 // We will read the next event and return the status of that read
621 // We will then seek back to our initial position
622 // Note : this method is expensive and should not be used too often
623 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1positionToFirstEvent(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
624 LttTracefile
* tracefilePtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
626 // Ask ltt to read the next events on the given tracefiles
627 // Returned value can be :
628 // 0 if everything went fine (EOK)
629 // ERANGE = 34 out of range, back to last event (might be system dependent?)
630 // EPERM = 1 error while reading (might be system dependent?)
633 // Seek to the start time... this will also read the first event, as we want.
634 int returnedValue
= ltt_tracefile_seek_time(tracefilePtr
, ((struct LttTrace
)*(tracefilePtr
->trace
)).start_time_from_tsc
);
636 return (jint
)returnedValue
;
639 // Method to read next event
640 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1readNextEvent(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
) {
641 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
643 // Ask ltt to read the next events on the given tracefiles
644 // Returned value can be :
645 // 0 if everything went fine (EOK)
646 // ERANGE = 34 out of range, back to last event (might be system dependent?)
647 // EPERM = 1 error while reading (might be system dependent?)
651 // This might fail on the FIRST event, as the timestamp before the first read is uninitialized
652 // However, LTT make the assumption that all tracefile have AT LEAST one event, so we got to run with it
654 // Save "last time" before moving, to be able to get back if needed
655 LttTime lastTime
= newPtr
->event
.event_time
;
657 int returnedValue
= ltt_tracefile_read(newPtr
);
659 // We need to get back to previous after an error to keep a sane state
660 if ( returnedValue
!= 0 ) {
661 ltt_tracefile_seek_time(newPtr
, lastTime
);
664 return (jint
)returnedValue
;
667 // Method to seek to a certain event
668 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1seekEvent(JNIEnv
* env
, jobject jobj
, jlong tracefile_ptr
, jobject time_jobj
) {
669 LttTracefile
* newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
671 guint64 fullTime
= 0;
673 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
674 jmethodID getTimeFunction
= (*env
)->GetMethodID(env
, accessClass
, "getTime", "()J");
675 fullTime
= (*env
)->CallLongMethod(env
, time_jobj
, getTimeFunction
);
678 // Conversion from jlong -> C long seems to be particularly sloppy
679 // Depending how and where (inlined a function or as a single operation) we do this, we might end up with wrong number
680 // The following asignation of guint64 seems to work well.
681 // MAKE SURE TO PERFORM SEVERAL TESTS IF YOU CHANGE THIS.
682 guint64 seconds
= fullTime
/BILLION
;
683 guint64 nanoSeconds
= fullTime
%BILLION
;
685 LttTime seekTime
= { (unsigned long)seconds
, (unsigned long)nanoSeconds
};
687 // Ask ltt to read the next events on the given tracefiles
688 // Returned value can be :
689 // 0 if everything went fine (EOK)
690 // ERANGE = 34 out of range, back to last event (might be system dependent?)
691 // EPERM = 1 error while reading (might be system dependent?)
693 int returnedValue
= ltt_tracefile_seek_time(newPtr
, seekTime
);
694 return (jint
)returnedValue
;
698 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTracefilePtr(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
699 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
701 return CONVERT_PTR_TO_JLONG(newPtr
->tracefile
);
705 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getBlock(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
706 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
708 return (jlong
)newPtr
->block
;
712 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOffset(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
713 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
715 return (jlong
)newPtr
->offset
;
719 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCurrentTimestampCounter(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
720 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
722 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc
);
726 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTimestamp(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
727 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
729 return (jlong
)newPtr
->timestamp
;
733 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventMarkerId(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
734 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
736 return (jint
)newPtr
->event_id
;
739 // Get time in nanoseconds
740 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getNanosencondsTime(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
741 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
743 return (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
746 // Fill event_time into an object
747 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1feedEventTime(JNIEnv
* env
, jobject jobj
, jlong event_ptr
, jobject time_jobj
) {
748 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
750 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
751 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
753 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
755 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
758 // Access method to the data
759 // The data are in "byte" form
760 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getDataContent(JNIEnv
* env
, jobject jobj
, jlong event_ptr
, jlong data_size
, jbyteArray dataArray
) {
761 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
763 (*env
)->SetByteArrayRegion(env
, dataArray
, 0, (jsize
)data_size
, newPtr
->data
);
767 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventDataSize(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
768 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
770 return (jlong
)newPtr
->data_size
;
774 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventSize(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
775 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
777 return (jlong
)newPtr
->event_size
;
781 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCount(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
782 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
784 return (jint
)newPtr
->count
;
787 // Get of overflow_nsec
788 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOverflowNanoSeconds(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
789 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
791 return CONVERT_UINT64_TO_JLONG(newPtr
->overflow_nsec
);
795 // Function to print the content of a event
796 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1printEvent(JNIEnv
* env
, jobject jobj
, jlong event_ptr
) {
797 LttEvent
* newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
799 printf("tracefile : %p\n" ,(void*)newPtr
->tracefile
);
800 printf("block : %u\n" ,(unsigned int)newPtr
->block
);
801 printf("offset : %u\n" ,(unsigned int)newPtr
->offset
);
802 printf("tsc : %lu\n" ,(long unsigned int)newPtr
->tsc
);
803 printf("timestamp : %u\n" ,(unsigned int)newPtr
->timestamp
);
804 printf("event_id : %u\n" ,(unsigned short)newPtr
->event_id
);
805 printf("event_time : %p\n" ,(void*) &newPtr
->event_time
);
806 printf(" sec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_sec
) );
807 printf(" nsec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_nsec
) );
808 printf("data : %p\n" ,(void*) newPtr
->data
);
809 printf("data_size : %u\n" ,(unsigned int)newPtr
->data_size
);
810 printf("event_size : %u\n" ,(unsigned int)newPtr
->event_size
);
811 printf("count : %d\n" ,(int)newPtr
->count
);
812 printf("overflow_nsec : %ld\n" ,(long)newPtr
->overflow_nsec
);
819 // ### MARKER method ###
823 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getName(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
824 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
826 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
830 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getFormatOverview(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
831 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
833 return (*env
)->NewStringUTF(env
, newPtr
->format
);
837 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
838 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
840 return (jlong
)newPtr
->size
;
843 // Method to get all markerField pointers
844 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAllMarkerFields(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
845 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
847 jclass accessClass
= (*env
)->GetObjectClass(env
, jobj
);
848 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "addMarkerFieldFromC", "(Ljava/lang/String;J)V");
850 GArray
* field_array
= (GArray
*)newPtr
->fields
;
851 struct marker_field
* field
;
852 jlong marker_field_ptr
;
855 for (i
=0; i
<field_array
->len
; i
++) {
856 field
= &g_array_index(field_array
, struct marker_field
, i
);
858 marker_field_ptr
= CONVERT_PTR_TO_JLONG(field
);
860 (*env
)->CallVoidMethod(env
, jobj
, accessFunction
, (*env
)->NewStringUTF(env
, g_quark_to_string(field
->name
) ), marker_field_ptr
);
866 // Get of largest_align
867 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLargestAlign(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
868 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
870 return (jshort
)newPtr
->largest_align
;
874 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getIntSize(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
875 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
877 return (jshort
)newPtr
->int_size
;
881 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLongSize(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
882 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
884 return (jshort
)newPtr
->long_size
;
887 // Get of pointer_size
888 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getPointerSize(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
889 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
891 return (jshort
)newPtr
->pointer_size
;
894 // Get of size_t_size
895 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize_1tSize(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
896 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
898 return (jshort
)newPtr
->size_t_size
;
902 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAlignement(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
903 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
905 return (jshort
)newPtr
->alignment
;
909 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getNextMarkerPtr(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
910 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
912 return CONVERT_PTR_TO_JLONG(newPtr
->next
);
916 // Function to print the content of a marker
917 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1printMarker(JNIEnv
* env
, jobject jobj
, jlong marker_info_ptr
) {
918 struct marker_info
* newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
920 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
921 printf("format : %s\n" ,newPtr
->format
);
922 printf("size : %li\n" ,(long int)newPtr
->size
);
923 printf("largest_align : %u\n" ,(unsigned short)newPtr
->largest_align
);
924 printf("fields : %p\n" ,newPtr
->fields
);
925 printf("int_size : %u\n" ,(unsigned short)newPtr
->int_size
);
926 printf("long_size : %u\n" ,(unsigned short)newPtr
->long_size
);
927 printf("pointer_size : %u\n" ,(unsigned short)newPtr
->pointer_size
);
928 printf("size_t_size : %u\n" ,(unsigned short)newPtr
->size_t_size
);
929 printf("alignment : %u\n" ,(unsigned short)newPtr
->alignment
);
930 printf("next : %p\n" ,newPtr
->next
);
939 // ### MARKERFIELD Method
943 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getField(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
944 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
946 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
950 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getType(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
951 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
953 return (jint
)newPtr
->type
;
957 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getOffset(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
958 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
960 return CONVERT_UINT64_TO_JLONG(newPtr
->offset
);
964 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getSize(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
965 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
967 return CONVERT_UINT64_TO_JLONG(newPtr
->size
);
971 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAlignment(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
972 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
974 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
978 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAttributes(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
979 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
981 return CONVERT_UINT64_TO_JLONG(newPtr
->attributes
);
984 // Get of static_offset
985 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getStatic_1offset(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
986 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
988 return (jint
)newPtr
->static_offset
;
992 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getFormat(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
993 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
995 return (*env
)->NewStringUTF(env
, newPtr
->fmt
->str
);
998 // Function to print the content of a marker_field
999 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1printMarkerField(JNIEnv
* env
, jobject jobj
, jlong marker_field_ptr
) {
1000 struct marker_field
* newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1002 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
1003 printf("type : %i\n" ,(int)newPtr
->type
);
1004 printf("offset : %lu\n" ,(long unsigned int)newPtr
->offset
);
1005 printf("size : %lu\n" ,(long unsigned int)newPtr
->size
);
1006 printf("alignment : %lu\n" ,(long unsigned int)newPtr
->alignment
);
1007 printf("attributes : %lu\n" ,(long unsigned int)newPtr
->attributes
);
1008 printf("static_offset : %i\n" ,(int)newPtr
->static_offset
);
1009 printf("fmt : %s\n" ,newPtr
->fmt
->str
);
1017 // ### PARSER Method
1020 // This function will do the actual parsing
1021 // It will then call java to assign the parsed data to the object "javaObj"
1022 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
) {
1023 LttEvent newEventPtr
= *(LttEvent
*)(CONVERT_JLONG_TO_PTR(event_ptr
));
1024 struct marker_field
* newMarkerFieldPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1026 jmethodID accessFunction
= NULL
;
1029 // There is a very limited number of type in LTT
1030 // We will switch on the type for this field and act accordingly
1031 // NOTE : We will save all integer into "long" type, as there is no signed/unsigned in java
1034 // It seems the marker_field->type is absolutely not consistent, especially about pointer!
1035 // Sometime pointer are saved in String, sometime as Int, sometime as pointer...
1036 // We will do an extra check on type "LTT_TYPE_UNSIGNED_INT" to check if the marker_field->format is hint of a pointer
1037 switch ( newMarkerFieldPtr
->type
) {
1038 case LTT_TYPE_SIGNED_INT
:
1039 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1040 (*env
)->CallStaticVoidMethod( env
,
1044 ltt_event_get_long_int(&newEventPtr
, newMarkerFieldPtr
)
1049 case LTT_TYPE_UNSIGNED_INT
:
1050 // If the format seems to be a pointer, add it as a pointer
1051 if ( (strncmp(newMarkerFieldPtr
->fmt
->str
, "0x%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) || (strncmp(newMarkerFieldPtr
->fmt
->str
, "%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) ) {
1052 #if __WORDSIZE == 64
1053 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1055 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1057 (*env
)->CallStaticVoidMethod( env
,
1061 CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
) )
1064 // Otherwise, add it as a number
1066 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1067 (*env
)->CallStaticVoidMethod( env
,
1071 ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
)
1077 case LTT_TYPE_POINTER
:
1078 #if __WORDSIZE == 64
1079 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1081 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1083 (*env
)->CallStaticVoidMethod( env
,
1087 CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR
*)(newEventPtr
.data
+ newMarkerFieldPtr
->offset
))
1091 case LTT_TYPE_STRING
:
1092 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;)V");
1093 (*env
)->CallStaticVoidMethod( env
,
1097 (*env
)->NewStringUTF(env
, ltt_event_get_string(&newEventPtr
, newMarkerFieldPtr
) )
1101 case LTT_TYPE_COMPACT
:
1102 case LTT_TYPE_NONE
:
1104 printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData)");