2 /* Important to get consistent size_t type */
3 #define _FILE_OFFSET_BITS 64
9 #include <ltt/marker.h>
20 We've got hell of a problem passing "unsigned int64" to java, as there is no equivalent type
21 The closer we can use is "long" which is signed, so only 32 (or 63?) bits are valid
22 Plus, even if we are within the "32 bits" capacity, java sometime screw itself trying to convert "unsigned 64 -> signed 64"
23 This happen especially often when RETURNING a jlong
24 So when returning a jlong, we should convert it like this : "unsigned 64"->"signed 64"->jlong
26 #define CONVERT_UINT64_TO_JLONG(n) (jlong)(gint64)(n)
27 #define CONVERT_INT64_TO_JLONG(n) (jlong)(gint64)(n)
29 /* To ease calcul involving nano */
30 #define BILLION 1000000000
34 #define CONVERT_JLONG_TO_PTR(p) (p)
35 #define CONVERT_PTR_TO_JLONG(p) (jlong)(p)
36 /* Define the "gint" type we should use for pointer. */
37 #define GINT_TYPE_FOR_PTR gint64
39 /* Conversion to int first to save warning */
40 #define CONVERT_JLONG_TO_PTR(p) (int)(p)
41 #define CONVERT_PTR_TO_JLONG(p) (jlong)(int)(p)
42 /* Define the "gint" type we should use for pointer. */
43 #define GINT_TYPE_FOR_PTR gint32
46 /* Structure to encapsulate java_data to pass as arguments */
47 struct java_calling_data
54 All these struct are used to call g_datalist_foreach()
55 Find a better way! This is ugly!
59 struct java_calling_data
*java_args
;
60 struct marker_data
*mdata
;
65 GArray
*saveTimeArray
;
68 struct saveTimeAndTracefile
71 LttTracefile
*tracefile
;
76 ### COMMON Methods ###
78 Empty method to turn off the debug (debug waste time while printing) */
79 void ignore_and_drop_message(const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
) {
83 /* JNI method to call printf from the java side */
84 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_Jni_1C_1Common_ltt_1printC(JNIEnv
*env
, jobject jobj
, jstring new_string
) {
85 const char *c_msg
= (*env
)->GetStringUTFChars(env
, new_string
, 0);
89 (*env
)->ReleaseStringUTFChars(env
, new_string
, c_msg
);
99 JNI mapping of < LttTrace *ltt_trace_open(const gchar *pathname) > (trace.h) */
100 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv
*env
, jobject jobj
, jstring pathname
, jboolean show_debug
) {
103 /* Make sure we don't use any debug (speed up the read) */
104 g_log_set_handler(NULL
, G_LOG_LEVEL_INFO
, ignore_and_drop_message
, NULL
);
105 g_log_set_handler(NULL
, G_LOG_LEVEL_DEBUG
, ignore_and_drop_message
, NULL
);
108 const char *c_pathname
= (*env
)->GetStringUTFChars(env
, pathname
, 0);
109 LttTrace
*newPtr
= ltt_trace_open( c_pathname
);
111 (*env
)->ReleaseStringUTFChars(env
, pathname
, c_pathname
);
113 return CONVERT_PTR_TO_JLONG(newPtr
);
116 /* JNI mapping of < void ltt_trace_close(LttTrace *t) > (trace.h) */
117 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1closeTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
){
119 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
121 ltt_trace_close(newPtr
);
124 /* Get the tracepath */
125 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getTracepath(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
126 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
128 return (*env
)->NewStringUTF(env
, g_quark_to_string( newPtr
->pathname
) );
133 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getCpuNumber(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
134 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
136 return (jint
)newPtr
->num_cpu
;
139 /* Get of arch_type */
140 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchType(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
141 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
143 return (jlong
)newPtr
->arch_type
;
146 /* Get of arch_variant */
147 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchVariant(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
148 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
150 return (jlong
)newPtr
->arch_variant
;
153 /* Get of arch_size */
154 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchSize(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
155 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
157 return (jshort
)newPtr
->arch_size
;
160 /* Get of ltt_major_version */
161 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMajorVersion(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
162 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
164 return (jshort
)newPtr
->ltt_major_version
;
167 /* Get of ltt_minor_version */
168 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMinorVersion(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
169 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
171 return (jshort
)newPtr
->ltt_minor_version
;
174 /* Get of flight_recorder */
175 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFlightRecorder(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
176 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
178 return (jshort
)newPtr
->flight_recorder
;
181 /* Get of freq_scale */
182 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFreqScale(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
183 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
185 return (jlong
)newPtr
->freq_scale
;
188 /* Get of start_freq */
189 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartFreq(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
190 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
192 return CONVERT_UINT64_TO_JLONG(newPtr
->start_freq
);
195 /* Get of start_tsc */
196 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartTimestampCurrentCounter(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
197 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
199 return CONVERT_UINT64_TO_JLONG(newPtr
->start_tsc
);
202 /* Get of start_monotonic */
203 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartMonotonic(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
204 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
206 return CONVERT_UINT64_TO_JLONG(newPtr
->start_monotonic
);
209 /* Access to start_time */
210 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
211 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTime(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
212 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
214 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
215 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
217 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_nsec
);
219 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
222 /* Access to start_time_from_tsc */
223 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
224 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTimeFromTimestampCurrentCounter(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
225 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
227 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
228 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
230 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
);
232 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
236 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getAllTracefiles */
237 void g_datalist_foreach_addTracefilesOfTrace(GQuark name
, gpointer data
, gpointer user_data
) {
238 struct java_calling_data
*args
= (struct java_calling_data
*)user_data
;
240 jclass accessClass
= (*args
->env
)->GetObjectClass(args
->env
, args
->jobj
);
241 jmethodID accessFunction
= (*args
->env
)->GetMethodID(args
->env
, accessClass
, "addTracefileFromC", "(Ljava/lang/String;J)V");
243 GArray
*tracefile_array
= (GArray
*)data
;
244 LttTracefile
*tracefile
;
248 for (i
=0; i
<tracefile_array
->len
; i
++) {
249 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
251 newPtr
= CONVERT_PTR_TO_JLONG(tracefile
);
253 (*args
->env
)->CallVoidMethod(args
->env
, args
->jobj
, accessFunction
, (*args
->env
)->NewStringUTF(args
->env
, g_quark_to_string(tracefile
->name
) ), newPtr
);
257 /* Function to fill up the java map with the event type found in tracefile (the name) */
258 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedAllTracefiles(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
259 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
261 struct java_calling_data args
= { env
, jobj
};
263 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_addTracefilesOfTrace
, &args
);
267 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange */
268 /* used to save the current timestamp for each tracefile */
269 void g_datalist_foreach_saveTracefilesTime(GQuark name
, gpointer data
, gpointer user_data
) {
270 struct saveTimeArgs
*args
= (struct saveTimeArgs
*)user_data
;
272 GArray
*tracefile_array
= (GArray
*)data
;
273 GArray
*save_array
= args
->saveTimeArray
;
275 LttTracefile
*tracefile
;
276 struct saveTimeAndTracefile
*savedData
;
279 for (i
=0; i
<tracefile_array
->len
; i
++) {
280 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
282 /* Allocate a new LttTime for each tracefile (so it won't change if the tracefile seek somewhere else) */
283 savedData
= (struct saveTimeAndTracefile
*)malloc( sizeof(struct saveTimeAndTracefile
) );
284 savedData
->time
.tv_sec
= tracefile
->event
.event_time
.tv_sec
;
285 savedData
->time
.tv_nsec
= tracefile
->event
.event_time
.tv_nsec
;
286 savedData
->tracefile
= tracefile
;
287 /* Append the saved data to the array */
288 g_array_append_val(save_array
, savedData
);
293 /* Obtain the range of the trace (i.e. "start time" and "end time") */
294 /* Note : This function, unlike ltt_trace_time_span_get, is assured to return all tracefiles to their correct position after operation */
295 /* NOTE : this method is quite heavy to use!!! */
296 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
) {
297 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
299 /* Allocate ourself a new array to save the data in */
300 GArray
*savedDataArray
= g_array_new(FALSE
, FALSE
, sizeof(struct saveTimeAndTracefile
*) );
301 struct saveTimeArgs args
= { savedDataArray
};
302 /* Call g_datalist_foreach_saveTracefilesTime for each element in the GData to save the time */
303 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_saveTracefilesTime
, &args
);
305 /* Call to ltt_trace_time_span_get to find the current start and end time */
306 /* NOTE : This WILL change the current block of the tracefile (i.e. its timestamp) */
307 LttTime tmpStartTime
= { 0, 0 };
308 LttTime tmpEndTime
= { 0, 0 };
309 ltt_trace_time_span_get(newPtr
, &tmpStartTime
, &tmpEndTime
);
311 /* Seek back to the correct time for each tracefile and free the allocated memory */
312 struct saveTimeAndTracefile
*savedData
;
314 for (i
=0; i
<savedDataArray
->len
; i
++) {
315 savedData
= g_array_index(savedDataArray
, struct saveTimeAndTracefile
*, i
);
316 /* Seek back to the correct time */
317 /* Some time will not be consistent here (i.e. unitialized data) */
318 /* but the seek should work just fine with that */
319 ltt_tracefile_seek_time(savedData
->tracefile
, savedData
->time
);
321 /* Free the memory allocated for this saveTimeAndTracefile entry */
324 /* Free the memory allocated for the GArray */
325 g_array_free(savedDataArray
, TRUE
);
327 /* Send the start and end time back to the java */
328 /* We do it last to make sure a problem won't leave us with unfred memory */
329 jclass startAccessClass
= (*env
)->GetObjectClass(env
, jstart_time
);
330 jmethodID startAccessFunction
= (*env
)->GetMethodID(env
, startAccessClass
, "setTimeFromC", "(J)V");
331 jlong startTime
= (CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_nsec
);
332 (*env
)->CallVoidMethod(env
, jstart_time
, startAccessFunction
, startTime
);
334 jclass endAccessClass
= (*env
)->GetObjectClass(env
, jend_time
);
335 jmethodID endAccessFunction
= (*env
)->GetMethodID(env
, endAccessClass
, "setTimeFromC", "(J)V");
336 jlong endTime
= (CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_nsec
);
337 (*env
)->CallVoidMethod(env
, jend_time
, endAccessFunction
, endTime
);
340 /* Function to print the content of a trace */
341 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1printTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
343 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
345 printf("pathname : %s\n" ,g_quark_to_string(newPtr
->pathname
) );
346 printf("num_cpu : %u\n" ,(unsigned int)(newPtr
->num_cpu
) );
347 printf("arch_type : %u\n" ,(unsigned int)(newPtr
->arch_type
) );
348 printf("arch_variant : %u\n" ,(unsigned int)(newPtr
->arch_variant
) );
349 printf("arch_size : %u\n" ,(unsigned short)(newPtr
->arch_size
) );
350 printf("ltt_major_version : %u\n" ,(unsigned short)(newPtr
->ltt_major_version
) );
351 printf("ltt_minor_version : %u\n" ,(unsigned short)(newPtr
->ltt_minor_version
) );
352 printf("flight_recorder : %u\n" ,(unsigned short)(newPtr
->flight_recorder
) );
353 printf("freq_scale : %u\n" ,(unsigned int)(newPtr
->freq_scale
) );
354 printf("start_freq : %lu\n" ,(long unsigned int)(newPtr
->start_freq
) );
355 printf("start_tsc : %lu\n" ,(long unsigned int)(newPtr
->start_tsc
) );
356 printf("start_monotonic : %lu\n" ,(long unsigned int)(newPtr
->start_monotonic
) );
357 printf("start_time ptr : %p\n" ,&newPtr
->start_time
);
358 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_sec
) );
359 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_nsec
) );
360 printf("start_time_from_tsc ptr : %p\n" ,&newPtr
->start_time_from_tsc
);
361 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_sec
) );
362 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_nsec
) );
363 printf("tracefiles ptr : %p\n" ,newPtr
->tracefiles
);
374 ### TRACEFILE methods ###
377 /* Get of cpu_online */
378 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsCpuOnline(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
379 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
381 return (jboolean
)newPtr
->cpu_online
;
384 /* Get of long_name */
385 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilepath(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
386 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
388 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->long_name
) );
392 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilename(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
393 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
395 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
) );
399 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCpuNumber(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
400 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
402 return (jlong
)newPtr
->cpu_num
;
406 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTid(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
407 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
409 return (jlong
)newPtr
->tid
;
413 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getPgid(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
414 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
416 return (jlong
)newPtr
->pgid
;
419 /* Get of creation */
420 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCreation(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
421 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
423 return CONVERT_UINT64_TO_JLONG(newPtr
->creation
);
427 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracePtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
428 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
430 return CONVERT_PTR_TO_JLONG(newPtr
->trace
);
434 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getMarkerDataPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
435 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
437 return CONVERT_PTR_TO_JLONG(newPtr
->mdata
);
441 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCFileDescriptor(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
442 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
444 return (jint
)newPtr
->fd
;
447 /* Get of file_size */
448 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getFileSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
449 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
451 return CONVERT_UINT64_TO_JLONG(newPtr
->file_size
);
454 /* Get of num_blocks */
455 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBlockNumber(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
456 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
458 return (jlong
)newPtr
->num_blocks
;
461 /* Get of reverse_bo */
462 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsBytesOrderReversed(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
463 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
465 return (jboolean
)newPtr
->reverse_bo
;
468 /* Get of float_word_order */
469 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsFloatWordOrdered(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
470 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
472 return (jboolean
)newPtr
->float_word_order
;
475 /* Get of alignment */
476 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAlignement(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
477 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
479 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
482 /* Get of buffer_header_size */
483 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferHeaderSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
484 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
486 return CONVERT_UINT64_TO_JLONG(newPtr
->buffer_header_size
);
490 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfCurrentTimestampCounter(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
491 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
493 return (jint
)newPtr
->tscbits
;
496 /* Get of eventbits */
497 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
498 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
500 return (jint
)newPtr
->eventbits
;
503 /* Get of tsc_mask */
504 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMask(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
505 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
507 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask
);
510 /* Get of tsc_mask_next_bit */
511 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMaskNextBit(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
512 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
514 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask_next_bit
);
517 /* Get of events_lost */
518 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventsLost(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
519 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
521 return (jlong
)newPtr
->events_lost
;
524 /* Get of subbuf_corrupt */
525 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getSubBufferCorrupt(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
526 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
528 return (jlong
)newPtr
->subbuf_corrupt
;
532 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
533 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
535 return CONVERT_PTR_TO_JLONG(&newPtr
->event
);
539 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
540 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
542 return CONVERT_PTR_TO_JLONG(&newPtr
->buffer
);
545 /* Get of buffer size */
546 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
547 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
549 return (jlong
)newPtr
->buffer
.size
;
553 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAllMarkers */
554 void g_hash_table_foreach_addMarkersOfTracefile(gpointer key
, gpointer data
, gpointer user_data
) {
555 struct addMarkersArgs
*args
= (struct addMarkersArgs
*)user_data
;
556 struct java_calling_data
*jargs
= (struct java_calling_data
*)args
->java_args
;
558 jclass accessClass
= (*jargs
->env
)->GetObjectClass(jargs
->env
, jargs
->jobj
);
559 jmethodID accessFunction
= (*jargs
->env
)->GetMethodID(jargs
->env
, accessClass
, "addMarkersFromC", "(IJ)V");
561 unsigned long marker_id
= (unsigned long)data
;
563 /* The hash table store an ID... we will use the ID to access the array. */
564 GArray
*marker
= args
->mdata
->markers
;
565 struct marker_info
*newPtr
= &g_array_index(marker
, struct marker_info
, marker_id
);
567 (*jargs
->env
)->CallVoidMethod(jargs
->env
, jargs
->jobj
, accessFunction
, marker_id
, CONVERT_PTR_TO_JLONG(newPtr
) );
570 /* Function to fill up the java map with the event type found in tracefile (the name) */
571 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1feedAllMarkers(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
572 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
575 Find a better way! This is ugly! */
576 struct java_calling_data java_args
= { env
, jobj
};
577 struct addMarkersArgs args
= { &java_args
, newPtr
->mdata
};
579 g_hash_table_foreach( newPtr
->mdata
->markers_hash
, &g_hash_table_foreach_addMarkersOfTracefile
, &args
);
583 /* Function to print the content of a tracefile */
584 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1printTracefile(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
586 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
587 printf("cpu_online : %i\n" ,(int)newPtr
->cpu_online
);
588 printf("long_name : %s\n" ,g_quark_to_string(newPtr
->long_name
));
589 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
));
590 printf("cpu_num : %u\n" ,(unsigned int)(newPtr
->cpu_num
));
591 printf("tid : %u\n" ,(unsigned int)(newPtr
->tid
));
592 printf("pgid : %u\n" ,(unsigned int)(newPtr
->pgid
));
593 printf("creation : %lu\n" ,(long unsigned int)(newPtr
->creation
));
594 printf("trace ptr : %p\n" ,newPtr
->trace
);
595 printf("marker ptr : %p\n" ,newPtr
->mdata
);
596 printf("fd : %i\n" ,(int)(newPtr
->fd
));
597 printf("file_size : %u\n" ,(unsigned int)(newPtr
->file_size
));
598 printf("num_blocks : %u\n" ,(unsigned int)(newPtr
->num_blocks
));
599 printf("reverse_bo : %i\n" ,(int)newPtr
->reverse_bo
);
600 printf("float_word_order : %i\n" ,(int)newPtr
->float_word_order
);
601 printf("alignment : %i\n" ,(int)newPtr
->alignment
);
602 printf("buffer_header_size : %i\n" ,(int)newPtr
->buffer_header_size
);
603 printf("tscbits : %u\n" ,(unsigned short)newPtr
->tscbits
);
604 printf("eventbits : %u\n" ,(unsigned short)newPtr
->eventbits
);
605 printf("tsc_mask : %lu\n" ,(long unsigned int)newPtr
->tsc_mask
);
606 printf("tsc_mask_next_bit : %lu\n" ,(long unsigned int)newPtr
->tsc_mask_next_bit
);
607 printf("events_lost : %u\n" ,(unsigned int)newPtr
->events_lost
);
608 printf("subbuf_corrupt : %u\n" ,(unsigned int)newPtr
->subbuf_corrupt
);
609 printf("event ptr : %p\n" ,&newPtr
->event
);
610 printf("buffer ptr : %p\n" ,&newPtr
->buffer
);
620 ### EVENT methods ###
623 /* Method to get the read status */
624 /* This method will read the next event and then seek back its initial position */
625 /* Lttv assume that every tracefile have at least 1 event, but we have not guarantee after this one. */
626 /* We will read the next event and return the status of that read */
627 /* We will then seek back to our initial position */
628 /* Note : this method is expensive and should not be used too often */
629 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1positionToFirstEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
630 LttTracefile
*tracefilePtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
632 /* Ask ltt to read the next events on the given tracefiles
633 Returned value can be :
634 0 if everything went fine (EOK)
635 ERANGE = 34 out of range, back to last event (might be system dependent?)
636 EPERM = 1 error while reading (might be system dependent?) */
639 /* Seek to the start time... this will also read the first event, as we want. */
640 int returnedValue
= ltt_tracefile_seek_time(tracefilePtr
, ((struct LttTrace
)*(tracefilePtr
->trace
)).start_time_from_tsc
);
642 return (jint
)returnedValue
;
645 /* Method to read next event */
646 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1readNextEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
647 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
649 /* Ask ltt to read the next events on the given tracefiles
650 Returned value can be :
651 0 if everything went fine (EOK)
652 ERANGE = 34 out of range, back to last event (might be system dependent?)
653 EPERM = 1 error while reading (might be system dependent?) */
657 This might fail on the FIRST event, as the timestamp before the first read is uninitialized
658 However, LTT make the assumption that all tracefile have AT LEAST one event, so we got to run with it */
660 /* Save "last time" before moving, to be able to get back if needed */
661 LttTime lastTime
= newPtr
->event
.event_time
;
663 int returnedValue
= ltt_tracefile_read(newPtr
);
665 /* We need to get back to previous after an error to keep a sane state */
666 if ( returnedValue
!= 0 ) {
667 ltt_tracefile_seek_time(newPtr
, lastTime
);
670 return (jint
)returnedValue
;
673 /* Method to seek to a certain event */
674 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1seekEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
, jobject time_jobj
) {
675 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
677 guint64 fullTime
= 0;
679 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
680 jmethodID getTimeFunction
= (*env
)->GetMethodID(env
, accessClass
, "getTime", "()J");
681 fullTime
= (*env
)->CallLongMethod(env
, time_jobj
, getTimeFunction
);
684 Conversion from jlong -> C long seems to be particularly sloppy
685 Depending how and where (inlined a function or as a single operation) we do this, we might end up with wrong number
686 The following asignation of guint64 seems to work well.
687 MAKE SURE TO PERFORM SEVERAL TESTS IF YOU CHANGE THIS. */
688 guint64 seconds
= fullTime
/BILLION
;
689 guint64 nanoSeconds
= fullTime
%BILLION
;
691 LttTime seekTime
= { (unsigned long)seconds
, (unsigned long)nanoSeconds
};
693 /* Ask ltt to read the next events on the given tracefiles
694 Returned value can be :
695 0 if everything went fine (EOK)
696 ERANGE = 34 out of range, back to last event (might be system dependent?)
697 EPERM = 1 error while reading (might be system dependent?) */
699 int returnedValue
= ltt_tracefile_seek_time(newPtr
, seekTime
);
700 return (jint
)returnedValue
;
703 /* Get of tracefile */
704 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTracefilePtr(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
705 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
707 return CONVERT_PTR_TO_JLONG(newPtr
->tracefile
);
711 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getBlock(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
712 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
714 return (jlong
)newPtr
->block
;
718 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOffset(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
719 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
721 return (jlong
)newPtr
->offset
;
725 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCurrentTimestampCounter(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
726 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
728 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc
);
731 /* Get of timestamp */
732 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTimestamp(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
733 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
735 return (jlong
)newPtr
->timestamp
;
738 /* Get of event_id */
739 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventMarkerId(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
740 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
742 return (jint
)newPtr
->event_id
;
745 /* Get time in nanoseconds */
746 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getNanosencondsTime(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
747 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
749 return (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
752 /* Fill event_time into an object */
753 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1feedEventTime(JNIEnv
*env
, jobject jobj
, jlong event_ptr
, jobject time_jobj
) {
754 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
756 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
757 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
759 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
761 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
764 /* Access method to the data */
765 /* The data are in "byte" form */
766 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getDataContent(JNIEnv
*env
, jobject jobj
, jlong event_ptr
, jlong data_size
, jbyteArray dataArray
) {
767 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
769 (*env
)->SetByteArrayRegion(env
, dataArray
, 0, (jsize
)data_size
, newPtr
->data
);
772 /* Get of data_size */
773 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventDataSize(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
774 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
776 return (jlong
)newPtr
->data_size
;
779 /* Get of event_size */
780 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventSize(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
781 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
783 return (jlong
)newPtr
->event_size
;
787 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCount(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
788 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
790 return (jint
)newPtr
->count
;
793 /* Get of overflow_nsec */
794 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOverflowNanoSeconds(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
795 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
797 return CONVERT_UINT64_TO_JLONG(newPtr
->overflow_nsec
);
801 /* Function to print the content of a event */
802 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1printEvent(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
803 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
805 printf("tracefile : %p\n" ,(void*)newPtr
->tracefile
);
806 printf("block : %u\n" ,(unsigned int)newPtr
->block
);
807 printf("offset : %u\n" ,(unsigned int)newPtr
->offset
);
808 printf("tsc : %lu\n" ,(long unsigned int)newPtr
->tsc
);
809 printf("timestamp : %u\n" ,(unsigned int)newPtr
->timestamp
);
810 printf("event_id : %u\n" ,(unsigned short)newPtr
->event_id
);
811 printf("event_time : %p\n" ,(void*) &newPtr
->event_time
);
812 printf(" sec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_sec
) );
813 printf(" nsec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_nsec
) );
814 printf("data : %p\n" ,(void*) newPtr
->data
);
815 printf("data_size : %u\n" ,(unsigned int)newPtr
->data_size
);
816 printf("event_size : %u\n" ,(unsigned int)newPtr
->event_size
);
817 printf("count : %d\n" ,(int)newPtr
->count
);
818 printf("overflow_nsec : %ld\n" ,(long)newPtr
->overflow_nsec
);
827 ### MARKER method ###
831 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getName(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
832 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
834 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
838 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getFormatOverview(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
839 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
841 return (*env
)->NewStringUTF(env
, newPtr
->format
);
845 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
846 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
848 return (jlong
)newPtr
->size
;
851 /* Method to get all markerField pointers */
852 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAllMarkerFields(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
853 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
855 jclass accessClass
= (*env
)->GetObjectClass(env
, jobj
);
856 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "addMarkerFieldFromC", "(Ljava/lang/String;J)V");
858 GArray
*field_array
= (GArray
*)newPtr
->fields
;
859 struct marker_field
*field
;
860 jlong marker_field_ptr
;
863 for (i
=0; i
<field_array
->len
; i
++) {
864 field
= &g_array_index(field_array
, struct marker_field
, i
);
866 marker_field_ptr
= CONVERT_PTR_TO_JLONG(field
);
868 (*env
)->CallVoidMethod(env
, jobj
, accessFunction
, (*env
)->NewStringUTF(env
, g_quark_to_string(field
->name
) ), marker_field_ptr
);
874 /* Get of largest_align */
875 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLargestAlign(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
876 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
878 return (jshort
)newPtr
->largest_align
;
881 /* Get of int_size */
882 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getIntSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
883 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
885 return (jshort
)newPtr
->int_size
;
888 /* Get of long_size */
889 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLongSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
890 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
892 return (jshort
)newPtr
->long_size
;
895 /* Get of pointer_size */
896 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getPointerSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
897 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
899 return (jshort
)newPtr
->pointer_size
;
902 /* Get of size_t_size */
903 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize_1tSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
904 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
906 return (jshort
)newPtr
->size_t_size
;
909 /* Get of alignment */
910 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAlignement(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
911 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
913 return (jshort
)newPtr
->alignment
;
917 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getNextMarkerPtr(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
918 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
920 return CONVERT_PTR_TO_JLONG(newPtr
->next
);
924 /* Function to print the content of a marker */
925 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1printMarker(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
926 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
928 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
929 printf("format : %s\n" ,newPtr
->format
);
930 printf("size : %li\n" ,(long int)newPtr
->size
);
931 printf("largest_align : %u\n" ,(unsigned short)newPtr
->largest_align
);
932 printf("fields : %p\n" ,newPtr
->fields
);
933 printf("int_size : %u\n" ,(unsigned short)newPtr
->int_size
);
934 printf("long_size : %u\n" ,(unsigned short)newPtr
->long_size
);
935 printf("pointer_size : %u\n" ,(unsigned short)newPtr
->pointer_size
);
936 printf("size_t_size : %u\n" ,(unsigned short)newPtr
->size_t_size
);
937 printf("alignment : %u\n" ,(unsigned short)newPtr
->alignment
);
938 printf("next : %p\n" ,newPtr
->next
);
948 ### MARKERFIELD Method
952 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getField(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
953 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
955 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
959 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getType(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
960 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
962 return (jint
)newPtr
->type
;
966 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getOffset(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
967 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
969 return CONVERT_UINT64_TO_JLONG(newPtr
->offset
);
973 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getSize(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
974 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
976 return CONVERT_UINT64_TO_JLONG(newPtr
->size
);
979 /* Get of alignment */
980 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAlignment(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
981 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
983 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
986 /* Get of attributes */
987 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAttributes(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
988 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
990 return CONVERT_UINT64_TO_JLONG(newPtr
->attributes
);
993 /* Get of static_offset */
994 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getStatic_1offset(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
995 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
997 return (jint
)newPtr
->static_offset
;
1001 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getFormat(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1002 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1004 return (*env
)->NewStringUTF(env
, newPtr
->fmt
->str
);
1007 /* Function to print the content of a marker_field */
1008 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1printMarkerField(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1009 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1011 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
1012 printf("type : %i\n" ,(int)newPtr
->type
);
1013 printf("offset : %lu\n" ,(long unsigned int)newPtr
->offset
);
1014 printf("size : %lu\n" ,(long unsigned int)newPtr
->size
);
1015 printf("alignment : %lu\n" ,(long unsigned int)newPtr
->alignment
);
1016 printf("attributes : %lu\n" ,(long unsigned int)newPtr
->attributes
);
1017 printf("static_offset : %i\n" ,(int)newPtr
->static_offset
);
1018 printf("fmt : %s\n" ,newPtr
->fmt
->str
);
1030 /* This function will do the actual parsing */
1031 /* It will then call java to assign the parsed data to the object "javaObj" */
1032 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
) {
1033 LttEvent newEventPtr
= *(LttEvent
*)(CONVERT_JLONG_TO_PTR(event_ptr
));
1034 struct marker_field
*newMarkerFieldPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1036 jmethodID accessFunction
= NULL
;
1040 There is a very limited number of type in LTT
1041 We will switch on the type for this field and act accordingly
1042 NOTE : We will save all integer into "long" type, as there is no signed/unsigned in java */
1045 It seems the marker_field->type is absolutely not consistent, especially about pointer!
1046 Sometime pointer are saved in String, sometime as Int, sometime as pointer...
1047 We will do an extra check on type "LTT_TYPE_UNSIGNED_INT" to check if the marker_field->format is hint of a pointer */
1048 switch ( newMarkerFieldPtr
->type
) {
1049 case LTT_TYPE_SIGNED_INT
:
1050 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1051 (*env
)->CallStaticVoidMethod( env
,
1055 ltt_event_get_long_int(&newEventPtr
, newMarkerFieldPtr
)
1060 case LTT_TYPE_UNSIGNED_INT
:
1061 /* If the format seems to be a pointer, add it as a pointer */
1062 if ( (strncmp(newMarkerFieldPtr
->fmt
->str
, "0x%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) || (strncmp(newMarkerFieldPtr
->fmt
->str
, "%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) ) {
1063 #if __WORDSIZE == 64
1064 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1066 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1068 (*env
)->CallStaticVoidMethod( env
,
1072 CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
) )
1075 /* Otherwise, add it as a number */
1077 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1078 (*env
)->CallStaticVoidMethod( env
,
1082 ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
)
1088 case LTT_TYPE_POINTER
:
1089 #if __WORDSIZE == 64
1090 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1092 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1094 (*env
)->CallStaticVoidMethod( env
,
1098 CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR
*)(newEventPtr
.data
+ newMarkerFieldPtr
->offset
))
1102 case LTT_TYPE_STRING
:
1103 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;)V");
1104 (*env
)->CallStaticVoidMethod( env
,
1108 (*env
)->NewStringUTF(env
, ltt_event_get_string(&newEventPtr
, newMarkerFieldPtr
) )
1112 case LTT_TYPE_COMPACT
:
1113 case LTT_TYPE_NONE
:
1115 printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData)");