1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2010 William Bourque
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License Version 2.1 as published by the Free Software Foundation.
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 02111-1307, USA.
19 /* Important to get consistent size_t type */
20 #define _FILE_OFFSET_BITS 64
24 #include <ltt/trace.h>
26 #include <ltt/marker.h>
37 We've got hell of a problem passing "unsigned int64" to java, as there is no equivalent type
38 The closer we can use is "long" which is signed, so only 32 (or 63?) bits are valid
39 Plus, even if we are within the "32 bits" capacity, java sometime screw itself trying to convert "unsigned 64 -> signed 64"
40 This happen especially often when RETURNING a jlong
41 So when returning a jlong, we should convert it like this : "unsigned 64"->"signed 64"->jlong
43 #define CONVERT_UINT64_TO_JLONG(n) (jlong)(gint64)(n)
44 #define CONVERT_INT64_TO_JLONG(n) (jlong)(gint64)(n)
46 /* To ease calcul involving nano */
47 #define BILLION 1000000000
51 #define CONVERT_JLONG_TO_PTR(p) (p)
52 #define CONVERT_PTR_TO_JLONG(p) (jlong)(p)
53 /* Define the "gint" type we should use for pointer. */
54 #define GINT_TYPE_FOR_PTR gint64
56 /* Conversion to int first to save warning */
57 #define CONVERT_JLONG_TO_PTR(p) (int)(p)
58 #define CONVERT_PTR_TO_JLONG(p) (jlong)(int)(p)
59 /* Define the "gint" type we should use for pointer. */
60 #define GINT_TYPE_FOR_PTR gint32
63 /* Structure to encapsulate java_data to pass as arguments */
64 struct java_calling_data
71 All these struct are used to call g_datalist_foreach()
72 Find a better way! This is ugly!
76 struct java_calling_data
*java_args
;
77 struct marker_data
*mdata
;
82 GArray
*saveTimeArray
;
85 struct saveTimeAndTracefile
88 LttTracefile
*tracefile
;
92 ### COMMON Methods ###
94 Empty method to turn off the debug (debug waste time while printing) */
95 void ignore_and_drop_message(const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
) {
99 /* JNI method to call printf from the java side */
100 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_Jni_1C_1Common_ltt_1printC(JNIEnv
*env
, jobject jobj
, jstring new_string
) {
101 const char *c_msg
= (*env
)->GetStringUTFChars(env
, new_string
, 0);
103 printf("%s", c_msg
);
105 (*env
)->ReleaseStringUTFChars(env
, new_string
, c_msg
);
113 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_factory_JniTraceVersion_ltt_1getTraceVersion(JNIEnv
*env
, jobject jobj
, jstring tracepath
) {
115 const gchar
*c_pathname
= (*env
)->GetStringUTFChars(env
, tracepath
, 0);
116 jint tmpMajorNumber
= 0;
117 jint tmpMinorNumber
= 0;
119 jclass accessClass
= (*env
)->GetObjectClass(env
, jobj
);
120 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTraceVersionFromC", "(II)V");
122 struct LttTraceVersion version_number
;
124 if ( ltt_get_trace_version(c_pathname
, &version_number
) >= 0) {
125 tmpMajorNumber
= version_number
.ltt_major_version
;
126 tmpMinorNumber
= version_number
.ltt_minor_version
;
129 (*env
)->CallVoidMethod(env
, jobj
, accessFunction
, tmpMajorNumber
, tmpMinorNumber
);
134 ### TRACE methods ###
136 JNI mapping of < LttTrace *ltt_trace_open(const gchar *pathname) > (trace.h) */
137 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv
*env
, jobject jobj
, jstring pathname
, jboolean show_debug
) {
140 /* Make sure we don't use any debug (speed up the read) */
141 g_log_set_handler(NULL
, G_LOG_LEVEL_INFO
, ignore_and_drop_message
, NULL
);
142 g_log_set_handler(NULL
, G_LOG_LEVEL_DEBUG
, ignore_and_drop_message
, NULL
);
145 const char *c_pathname
= (*env
)->GetStringUTFChars(env
, pathname
, 0);
146 LttTrace
*newPtr
= ltt_trace_open( c_pathname
);
148 (*env
)->ReleaseStringUTFChars(env
, pathname
, c_pathname
);
150 return CONVERT_PTR_TO_JLONG(newPtr
);
153 /* JNI mapping of < void ltt_trace_close(LttTrace *t) > (trace.h) */
154 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1closeTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
){
156 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
158 ltt_trace_close(newPtr
);
161 /* Get the tracepath */
162 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getTracepath(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
163 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
165 return (*env
)->NewStringUTF(env
, g_quark_to_string( newPtr
->pathname
) );
170 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getCpuNumber(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
171 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
173 return (jint
)newPtr
->num_cpu
;
176 /* Get of arch_type */
177 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchType(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
178 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
180 return (jlong
)newPtr
->arch_type
;
183 /* Get of arch_variant */
184 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchVariant(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
185 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
187 return (jlong
)newPtr
->arch_variant
;
190 /* Get of arch_size */
191 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchSize(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
192 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
194 return (jshort
)newPtr
->arch_size
;
197 /* Get of ltt_major_version */
198 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMajorVersion(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
199 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
201 return (jshort
)newPtr
->ltt_major_version
;
204 /* Get of ltt_minor_version */
205 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMinorVersion(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
206 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
208 return (jshort
)newPtr
->ltt_minor_version
;
211 /* Get of flight_recorder */
212 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFlightRecorder(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
213 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
215 return (jshort
)newPtr
->flight_recorder
;
218 /* Get of freq_scale */
219 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFreqScale(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
220 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
222 return (jlong
)newPtr
->freq_scale
;
225 /* Get of start_freq */
226 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartFreq(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
227 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
229 return CONVERT_UINT64_TO_JLONG(newPtr
->start_freq
);
232 /* Get of start_tsc */
233 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartTimestampCurrentCounter(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
234 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
236 return CONVERT_UINT64_TO_JLONG(newPtr
->start_tsc
);
239 /* Get of start_monotonic */
240 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartMonotonic(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
241 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
243 return CONVERT_UINT64_TO_JLONG(newPtr
->start_monotonic
);
246 /* Access to start_time */
247 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
248 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTime(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
249 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
251 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
252 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
254 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_nsec
);
256 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
259 /* Access to start_time_from_tsc */
260 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
261 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTimeFromTimestampCurrentCounter(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
262 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
264 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
265 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
267 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->start_time_from_tsc
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->start_time_from_tsc
.tv_nsec
);
269 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
273 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getAllTracefiles */
274 void g_datalist_foreach_addTracefilesOfTrace(GQuark name
, gpointer data
, gpointer user_data
) {
275 struct java_calling_data
*args
= (struct java_calling_data
*)user_data
;
277 jclass accessClass
= (*args
->env
)->GetObjectClass(args
->env
, args
->jobj
);
278 jmethodID accessFunction
= (*args
->env
)->GetMethodID(args
->env
, accessClass
, "addTracefileFromC", "(Ljava/lang/String;J)V");
280 GArray
*tracefile_array
= (GArray
*)data
;
281 LttTracefile
*tracefile
;
285 for (i
=0; i
<tracefile_array
->len
; i
++) {
286 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
288 newPtr
= CONVERT_PTR_TO_JLONG(tracefile
);
290 (*args
->env
)->CallVoidMethod(args
->env
, args
->jobj
, accessFunction
, (*args
->env
)->NewStringUTF(args
->env
, g_quark_to_string(tracefile
->name
) ), newPtr
);
294 /* Function to fill up the java map with the event type found in tracefile (the name) */
295 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedAllTracefiles(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
296 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
298 struct java_calling_data args
= { env
, jobj
};
300 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_addTracefilesOfTrace
, &args
);
304 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange */
305 /* used to save the current timestamp for each tracefile */
306 void g_datalist_foreach_saveTracefilesTime(GQuark name
, gpointer data
, gpointer user_data
) {
307 struct saveTimeArgs
*args
= (struct saveTimeArgs
*)user_data
;
309 GArray
*tracefile_array
= (GArray
*)data
;
310 GArray
*save_array
= args
->saveTimeArray
;
312 LttTracefile
*tracefile
;
313 struct saveTimeAndTracefile
*savedData
;
316 for (i
=0; i
<tracefile_array
->len
; i
++) {
317 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
319 /* Allocate a new LttTime for each tracefile (so it won't change if the tracefile seek somewhere else) */
320 savedData
= (struct saveTimeAndTracefile
*)malloc( sizeof(struct saveTimeAndTracefile
) );
321 savedData
->time
.tv_sec
= tracefile
->event
.event_time
.tv_sec
;
322 savedData
->time
.tv_nsec
= tracefile
->event
.event_time
.tv_nsec
;
323 savedData
->tracefile
= tracefile
;
324 /* Append the saved data to the array */
325 g_array_append_val(save_array
, savedData
);
330 /* Obtain the range of the trace (i.e. "start time" and "end time") */
331 /* Note : This function, unlike ltt_trace_time_span_get, is assured to return all tracefiles to their correct position after operation */
332 /* NOTE : this method is quite heavy to use!!! */
333 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject jstart_time
, jobject jend_time
) {
334 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
336 /* Allocate ourself a new array to save the data in */
337 GArray
*savedDataArray
= g_array_new(FALSE
, FALSE
, sizeof(struct saveTimeAndTracefile
*) );
338 struct saveTimeArgs args
= { savedDataArray
};
339 /* Call g_datalist_foreach_saveTracefilesTime for each element in the GData to save the time */
340 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_saveTracefilesTime
, &args
);
342 /* Call to ltt_trace_time_span_get to find the current start and end time */
343 /* NOTE : This WILL change the current block of the tracefile (i.e. its timestamp) */
344 LttTime tmpStartTime
= { 0, 0 };
345 LttTime tmpEndTime
= { 0, 0 };
346 ltt_trace_time_span_get(newPtr
, &tmpStartTime
, &tmpEndTime
);
348 /* Seek back to the correct time for each tracefile and free the allocated memory */
349 struct saveTimeAndTracefile
*savedData
;
351 for (i
=0; i
<savedDataArray
->len
; i
++) {
352 savedData
= g_array_index(savedDataArray
, struct saveTimeAndTracefile
*, i
);
353 /* Seek back to the correct time */
354 /* Some time will not be consistent here (i.e. unitialized data) */
355 /* but the seek should work just fine with that */
356 ltt_tracefile_seek_time(savedData
->tracefile
, savedData
->time
);
358 /* Free the memory allocated for this saveTimeAndTracefile entry */
361 /* Free the memory allocated for the GArray */
362 g_array_free(savedDataArray
, TRUE
);
364 /* Send the start and end time back to the java */
365 /* We do it last to make sure a problem won't leave us with unfred memory */
366 jclass startAccessClass
= (*env
)->GetObjectClass(env
, jstart_time
);
367 jmethodID startAccessFunction
= (*env
)->GetMethodID(env
, startAccessClass
, "setTimeFromC", "(J)V");
368 jlong startTime
= (CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_nsec
);
369 (*env
)->CallVoidMethod(env
, jstart_time
, startAccessFunction
, startTime
);
371 jclass endAccessClass
= (*env
)->GetObjectClass(env
, jend_time
);
372 jmethodID endAccessFunction
= (*env
)->GetMethodID(env
, endAccessClass
, "setTimeFromC", "(J)V");
373 jlong endTime
= (CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_nsec
);
374 (*env
)->CallVoidMethod(env
, jend_time
, endAccessFunction
, endTime
);
377 /* Function to print the content of a trace */
378 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1printTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
380 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
382 printf("pathname : %s\n" ,g_quark_to_string(newPtr
->pathname
) );
383 printf("num_cpu : %u\n" ,(unsigned int)(newPtr
->num_cpu
) );
384 printf("arch_type : %u\n" ,(unsigned int)(newPtr
->arch_type
) );
385 printf("arch_variant : %u\n" ,(unsigned int)(newPtr
->arch_variant
) );
386 printf("arch_size : %u\n" ,(unsigned short)(newPtr
->arch_size
) );
387 printf("ltt_major_version : %u\n" ,(unsigned short)(newPtr
->ltt_major_version
) );
388 printf("ltt_minor_version : %u\n" ,(unsigned short)(newPtr
->ltt_minor_version
) );
389 printf("flight_recorder : %u\n" ,(unsigned short)(newPtr
->flight_recorder
) );
390 printf("freq_scale : %u\n" ,(unsigned int)(newPtr
->freq_scale
) );
391 printf("start_freq : %lu\n" ,(long unsigned int)(newPtr
->start_freq
) );
392 printf("start_tsc : %lu\n" ,(long unsigned int)(newPtr
->start_tsc
) );
393 printf("start_monotonic : %lu\n" ,(long unsigned int)(newPtr
->start_monotonic
) );
394 printf("start_time ptr : %p\n" ,&newPtr
->start_time
);
395 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_sec
) );
396 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_nsec
) );
397 printf("start_time_from_tsc ptr : %p\n" ,&newPtr
->start_time_from_tsc
);
398 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_sec
) );
399 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_nsec
) );
400 printf("tracefiles ptr : %p\n" ,newPtr
->tracefiles
);
411 ### TRACEFILE methods ###
414 /* Get of cpu_online */
415 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsCpuOnline(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
416 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
418 return (jboolean
)newPtr
->cpu_online
;
421 /* Get of long_name */
422 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilepath(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
423 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
425 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->long_name
) );
429 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilename(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
430 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
432 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
) );
436 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCpuNumber(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
437 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
439 return (jlong
)newPtr
->cpu_num
;
443 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTid(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
444 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
446 return (jlong
)newPtr
->tid
;
450 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getPgid(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
451 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
453 return (jlong
)newPtr
->pgid
;
456 /* Get of creation */
457 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCreation(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
458 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
460 return CONVERT_UINT64_TO_JLONG(newPtr
->creation
);
464 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracePtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
465 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
467 return CONVERT_PTR_TO_JLONG(newPtr
->trace
);
471 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getMarkerDataPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
472 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
474 return CONVERT_PTR_TO_JLONG(newPtr
->mdata
);
478 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCFileDescriptor(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
479 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
481 return (jint
)newPtr
->fd
;
484 /* Get of file_size */
485 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getFileSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
486 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
488 return CONVERT_UINT64_TO_JLONG(newPtr
->file_size
);
491 /* Get of num_blocks */
492 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBlockNumber(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
493 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
495 return (jlong
)newPtr
->num_blocks
;
498 /* Get of reverse_bo */
499 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsBytesOrderReversed(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
500 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
502 return (jboolean
)newPtr
->reverse_bo
;
505 /* Get of float_word_order */
506 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsFloatWordOrdered(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
507 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
509 return (jboolean
)newPtr
->float_word_order
;
512 /* Get of alignment */
513 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAlignement(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
514 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
516 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
519 /* Get of buffer_header_size */
520 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferHeaderSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
521 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
523 return CONVERT_UINT64_TO_JLONG(newPtr
->buffer_header_size
);
527 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfCurrentTimestampCounter(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
528 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
530 return (jint
)newPtr
->tscbits
;
533 /* Get of eventbits */
534 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
535 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
537 return (jint
)newPtr
->eventbits
;
540 /* Get of tsc_mask */
541 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMask(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
542 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
544 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask
);
547 /* Get of tsc_mask_next_bit */
548 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMaskNextBit(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
549 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
551 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask_next_bit
);
554 /* Get of events_lost */
555 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventsLost(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
556 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
558 return (jlong
)newPtr
->events_lost
;
561 /* Get of subbuf_corrupt */
562 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getSubBufferCorrupt(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
563 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
565 return (jlong
)newPtr
->subbuf_corrupt
;
569 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
570 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
572 return CONVERT_PTR_TO_JLONG(&newPtr
->event
);
576 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
577 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
579 return CONVERT_PTR_TO_JLONG(&newPtr
->buffer
);
582 /* Get of buffer size */
583 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
584 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
586 return (jlong
)newPtr
->buffer
.size
;
590 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAllMarkers */
591 void g_hash_table_foreach_addMarkersOfTracefile(gpointer key
, gpointer data
, gpointer user_data
) {
592 struct addMarkersArgs
*args
= (struct addMarkersArgs
*)user_data
;
593 struct java_calling_data
*jargs
= (struct java_calling_data
*)args
->java_args
;
595 jclass accessClass
= (*jargs
->env
)->GetObjectClass(jargs
->env
, jargs
->jobj
);
596 jmethodID accessFunction
= (*jargs
->env
)->GetMethodID(jargs
->env
, accessClass
, "addMarkersFromC", "(IJ)V");
598 unsigned long marker_id
= (unsigned long)data
;
600 /* The hash table store an ID... we will use the ID to access the array. */
601 GArray
*marker
= args
->mdata
->markers
;
602 struct marker_info
*newPtr
= &g_array_index(marker
, struct marker_info
, marker_id
);
604 (*jargs
->env
)->CallVoidMethod(jargs
->env
, jargs
->jobj
, accessFunction
, marker_id
, CONVERT_PTR_TO_JLONG(newPtr
) );
607 /* Function to fill up the java map with the event type found in tracefile (the name) */
608 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1feedAllMarkers(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
609 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
612 Find a better way! This is ugly! */
613 struct java_calling_data java_args
= { env
, jobj
};
614 struct addMarkersArgs args
= { &java_args
, newPtr
->mdata
};
616 g_hash_table_foreach( newPtr
->mdata
->markers_hash
, &g_hash_table_foreach_addMarkersOfTracefile
, &args
);
620 /* Function to print the content of a tracefile */
621 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1printTracefile(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
623 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
624 printf("cpu_online : %i\n" ,(int)newPtr
->cpu_online
);
625 printf("long_name : %s\n" ,g_quark_to_string(newPtr
->long_name
));
626 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
));
627 printf("cpu_num : %u\n" ,(unsigned int)(newPtr
->cpu_num
));
628 printf("tid : %u\n" ,(unsigned int)(newPtr
->tid
));
629 printf("pgid : %u\n" ,(unsigned int)(newPtr
->pgid
));
630 printf("creation : %lu\n" ,(long unsigned int)(newPtr
->creation
));
631 printf("trace ptr : %p\n" ,newPtr
->trace
);
632 printf("marker ptr : %p\n" ,newPtr
->mdata
);
633 printf("fd : %i\n" ,(int)(newPtr
->fd
));
634 printf("file_size : %u\n" ,(unsigned int)(newPtr
->file_size
));
635 printf("num_blocks : %u\n" ,(unsigned int)(newPtr
->num_blocks
));
636 printf("reverse_bo : %i\n" ,(int)newPtr
->reverse_bo
);
637 printf("float_word_order : %i\n" ,(int)newPtr
->float_word_order
);
638 printf("alignment : %i\n" ,(int)newPtr
->alignment
);
639 printf("buffer_header_size : %i\n" ,(int)newPtr
->buffer_header_size
);
640 printf("tscbits : %u\n" ,(unsigned short)newPtr
->tscbits
);
641 printf("eventbits : %u\n" ,(unsigned short)newPtr
->eventbits
);
642 printf("tsc_mask : %lu\n" ,(long unsigned int)newPtr
->tsc_mask
);
643 printf("tsc_mask_next_bit : %lu\n" ,(long unsigned int)newPtr
->tsc_mask_next_bit
);
644 printf("events_lost : %u\n" ,(unsigned int)newPtr
->events_lost
);
645 printf("subbuf_corrupt : %u\n" ,(unsigned int)newPtr
->subbuf_corrupt
);
646 printf("event ptr : %p\n" ,&newPtr
->event
);
647 printf("buffer ptr : %p\n" ,&newPtr
->buffer
);
657 ### EVENT methods ###
660 /* Method to get the read status */
661 /* This method will read the next event and then seek back its initial position */
662 /* Lttv assume that every tracefile have at least 1 event, but we have not guarantee after this one. */
663 /* We will read the next event and return the status of that read */
664 /* We will then seek back to our initial position */
665 /* Note : this method is expensive and should not be used too often */
666 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1positionToFirstEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
667 LttTracefile
*tracefilePtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
669 /* Ask ltt to read the next events on the given tracefiles
670 Returned value can be :
671 0 if everything went fine (EOK)
672 ERANGE = 34 out of range, back to last event (might be system dependent?)
673 EPERM = 1 error while reading (might be system dependent?) */
676 /* Seek to the start time... this will also read the first event, as we want. */
677 int returnedValue
= ltt_tracefile_seek_time(tracefilePtr
, ((struct LttTrace
)*(tracefilePtr
->trace
)).start_time_from_tsc
);
679 return (jint
)returnedValue
;
682 /* Method to read next event */
683 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1readNextEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
684 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
686 /* Ask ltt to read the next events on the given tracefiles
687 Returned value can be :
688 0 if everything went fine (EOK)
689 ERANGE = 34 out of range, back to last event (might be system dependent?)
690 EPERM = 1 error while reading (might be system dependent?) */
694 This might fail on the FIRST event, as the timestamp before the first read is uninitialized
695 However, LTT make the assumption that all tracefile have AT LEAST one event, so we got to run with it */
697 /* Save "last time" before moving, to be able to get back if needed */
698 LttTime lastTime
= newPtr
->event
.event_time
;
700 int returnedValue
= ltt_tracefile_read(newPtr
);
702 /* We need to get back to previous after an error to keep a sane state */
703 if ( returnedValue
!= 0 ) {
704 ltt_tracefile_seek_time(newPtr
, lastTime
);
707 return (jint
)returnedValue
;
710 /* Method to seek to a certain event */
711 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1seekEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
, jobject time_jobj
) {
712 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
714 guint64 fullTime
= 0;
716 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
717 jmethodID getTimeFunction
= (*env
)->GetMethodID(env
, accessClass
, "getTime", "()J");
718 fullTime
= (*env
)->CallLongMethod(env
, time_jobj
, getTimeFunction
);
721 Conversion from jlong -> C long seems to be particularly sloppy
722 Depending how and where (inlined a function or as a single operation) we do this, we might end up with wrong number
723 The following asignation of guint64 seems to work well.
724 MAKE SURE TO PERFORM SEVERAL TESTS IF YOU CHANGE THIS. */
725 guint64 seconds
= fullTime
/BILLION
;
726 guint64 nanoSeconds
= fullTime
%BILLION
;
728 LttTime seekTime
= { (unsigned long)seconds
, (unsigned long)nanoSeconds
};
730 /* Ask ltt to read the next events on the given tracefiles
731 Returned value can be :
732 0 if everything went fine (EOK)
733 ERANGE = 34 out of range, back to last event (might be system dependent?)
734 EPERM = 1 error while reading (might be system dependent?) */
736 int returnedValue
= ltt_tracefile_seek_time(newPtr
, seekTime
);
737 return (jint
)returnedValue
;
740 /* Get of tracefile */
741 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTracefilePtr(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
742 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
744 return CONVERT_PTR_TO_JLONG(newPtr
->tracefile
);
748 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getBlock(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
749 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
751 return (jlong
)newPtr
->block
;
755 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOffset(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
756 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
758 return (jlong
)newPtr
->offset
;
762 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCurrentTimestampCounter(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
763 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
765 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc
);
768 /* Get of timestamp */
769 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTimestamp(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
770 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
772 return (jlong
)newPtr
->timestamp
;
775 /* Get of event_id */
776 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventMarkerId(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
777 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
779 return (jint
)newPtr
->event_id
;
782 /* Get time in nanoseconds */
783 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getNanosencondsTime(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
784 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
786 return (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
789 /* Fill event_time into an object */
790 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1feedEventTime(JNIEnv
*env
, jobject jobj
, jlong event_ptr
, jobject time_jobj
) {
791 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
793 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
794 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
796 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
798 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
801 /* Access method to the data */
802 /* The data are in "byte" form */
803 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getDataContent(JNIEnv
*env
, jobject jobj
, jlong event_ptr
, jlong data_size
, jbyteArray dataArray
) {
804 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
806 (*env
)->SetByteArrayRegion(env
, dataArray
, 0, (jsize
)data_size
, newPtr
->data
);
809 /* Get of data_size */
810 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventDataSize(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
811 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
813 return (jlong
)newPtr
->data_size
;
816 /* Get of event_size */
817 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventSize(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
818 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
820 return (jlong
)newPtr
->event_size
;
824 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCount(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
825 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
827 return (jint
)newPtr
->count
;
830 /* Get of overflow_nsec */
831 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOverflowNanoSeconds(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
832 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
834 return CONVERT_UINT64_TO_JLONG(newPtr
->overflow_nsec
);
838 /* Function to print the content of a event */
839 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1printEvent(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
840 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
842 printf("tracefile : %p\n" ,(void*)newPtr
->tracefile
);
843 printf("block : %u\n" ,(unsigned int)newPtr
->block
);
844 printf("offset : %u\n" ,(unsigned int)newPtr
->offset
);
845 printf("tsc : %lu\n" ,(long unsigned int)newPtr
->tsc
);
846 printf("timestamp : %u\n" ,(unsigned int)newPtr
->timestamp
);
847 printf("event_id : %u\n" ,(unsigned short)newPtr
->event_id
);
848 printf("event_time : %p\n" ,(void*) &newPtr
->event_time
);
849 printf(" sec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_sec
) );
850 printf(" nsec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_nsec
) );
851 printf("data : %p\n" ,(void*) newPtr
->data
);
852 printf("data_size : %u\n" ,(unsigned int)newPtr
->data_size
);
853 printf("event_size : %u\n" ,(unsigned int)newPtr
->event_size
);
854 printf("count : %d\n" ,(int)newPtr
->count
);
855 printf("overflow_nsec : %ld\n" ,(long)newPtr
->overflow_nsec
);
864 ### MARKER method ###
868 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getName(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
869 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
871 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
875 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getFormatOverview(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
876 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
878 return (*env
)->NewStringUTF(env
, newPtr
->format
);
882 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
883 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
885 return (jlong
)newPtr
->size
;
888 /* Method to get all markerField pointers */
889 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAllMarkerFields(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
890 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
892 jclass accessClass
= (*env
)->GetObjectClass(env
, jobj
);
893 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "addMarkerFieldFromC", "(Ljava/lang/String;J)V");
895 GArray
*field_array
= (GArray
*)newPtr
->fields
;
896 struct marker_field
*field
;
897 jlong marker_field_ptr
;
900 for (i
=0; i
<field_array
->len
; i
++) {
901 field
= &g_array_index(field_array
, struct marker_field
, i
);
903 marker_field_ptr
= CONVERT_PTR_TO_JLONG(field
);
905 (*env
)->CallVoidMethod(env
, jobj
, accessFunction
, (*env
)->NewStringUTF(env
, g_quark_to_string(field
->name
) ), marker_field_ptr
);
911 /* Get of largest_align */
912 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLargestAlign(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
913 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
915 return (jshort
)newPtr
->largest_align
;
918 /* Get of int_size */
919 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getIntSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
920 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
922 return (jshort
)newPtr
->int_size
;
925 /* Get of long_size */
926 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLongSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
927 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
929 return (jshort
)newPtr
->long_size
;
932 /* Get of pointer_size */
933 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getPointerSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
934 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
936 return (jshort
)newPtr
->pointer_size
;
939 /* Get of size_t_size */
940 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize_1tSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
941 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
943 return (jshort
)newPtr
->size_t_size
;
946 /* Get of alignment */
947 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAlignement(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
948 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
950 return (jshort
)newPtr
->alignment
;
954 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getNextMarkerPtr(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
955 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
957 return CONVERT_PTR_TO_JLONG(newPtr
->next
);
961 /* Function to print the content of a marker */
962 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1printMarker(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
963 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
965 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
966 printf("format : %s\n" ,newPtr
->format
);
967 printf("size : %li\n" ,(long int)newPtr
->size
);
968 printf("largest_align : %u\n" ,(unsigned short)newPtr
->largest_align
);
969 printf("fields : %p\n" ,newPtr
->fields
);
970 printf("int_size : %u\n" ,(unsigned short)newPtr
->int_size
);
971 printf("long_size : %u\n" ,(unsigned short)newPtr
->long_size
);
972 printf("pointer_size : %u\n" ,(unsigned short)newPtr
->pointer_size
);
973 printf("size_t_size : %u\n" ,(unsigned short)newPtr
->size_t_size
);
974 printf("alignment : %u\n" ,(unsigned short)newPtr
->alignment
);
975 printf("next : %p\n" ,newPtr
->next
);
985 ### MARKERFIELD Method
989 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getField(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
990 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
992 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
996 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getType(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
997 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
999 return (jint
)newPtr
->type
;
1003 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getOffset(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1004 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1006 return CONVERT_UINT64_TO_JLONG(newPtr
->offset
);
1010 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getSize(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1011 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1013 return CONVERT_UINT64_TO_JLONG(newPtr
->size
);
1016 /* Get of alignment */
1017 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAlignment(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1018 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1020 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
1023 /* Get of attributes */
1024 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAttributes(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1025 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1027 return CONVERT_UINT64_TO_JLONG(newPtr
->attributes
);
1030 /* Get of static_offset */
1031 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getStatic_1offset(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1032 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1034 return (jint
)newPtr
->static_offset
;
1038 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getFormat(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1039 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1041 return (*env
)->NewStringUTF(env
, newPtr
->fmt
->str
);
1044 /* Function to print the content of a marker_field */
1045 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1printMarkerField(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1046 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1048 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
1049 printf("type : %i\n" ,(int)newPtr
->type
);
1050 printf("offset : %lu\n" ,(long unsigned int)newPtr
->offset
);
1051 printf("size : %lu\n" ,(long unsigned int)newPtr
->size
);
1052 printf("alignment : %lu\n" ,(long unsigned int)newPtr
->alignment
);
1053 printf("attributes : %lu\n" ,(long unsigned int)newPtr
->attributes
);
1054 printf("static_offset : %i\n" ,(int)newPtr
->static_offset
);
1055 printf("fmt : %s\n" ,newPtr
->fmt
->str
);
1067 /* This function will do the actual parsing */
1068 /* It will then call java to assign the parsed data to the object "javaObj" */
1069 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData(JNIEnv
*env
, jclass accessClass
, jobject javaObj
, jlong event_ptr
, jlong marker_field_ptr
) {
1070 LttEvent newEventPtr
= *(LttEvent
*)(CONVERT_JLONG_TO_PTR(event_ptr
));
1071 struct marker_field
*newMarkerFieldPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1073 jmethodID accessFunction
= NULL
;
1077 There is a very limited number of type in LTT
1078 We will switch on the type for this field and act accordingly
1079 NOTE : We will save all integer into "long" type, as there is no signed/unsigned in java */
1082 It seems the marker_field->type is absolutely not consistent, especially about pointer!
1083 Sometime pointer are saved in String, sometime as Int, sometime as pointer...
1084 We will do an extra check on type "LTT_TYPE_UNSIGNED_INT" to check if the marker_field->format is hint of a pointer */
1085 switch ( newMarkerFieldPtr
->type
) {
1086 case LTT_TYPE_SIGNED_INT
:
1087 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1088 (*env
)->CallStaticVoidMethod( env
,
1092 ltt_event_get_long_int(&newEventPtr
, newMarkerFieldPtr
)
1097 case LTT_TYPE_UNSIGNED_INT
:
1098 /* If the format seems to be a pointer, add it as a pointer */
1099 if ( (strncmp(newMarkerFieldPtr
->fmt
->str
, "0x%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) || (strncmp(newMarkerFieldPtr
->fmt
->str
, "%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) ) {
1100 #if __WORDSIZE == 64
1101 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1103 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1105 (*env
)->CallStaticVoidMethod( env
,
1109 CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
) )
1112 /* Otherwise, add it as a number */
1114 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1115 (*env
)->CallStaticVoidMethod( env
,
1119 ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
)
1125 case LTT_TYPE_POINTER
:
1126 #if __WORDSIZE == 64
1127 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1129 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1131 (*env
)->CallStaticVoidMethod( env
,
1135 CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR
*)(newEventPtr
.data
+ newMarkerFieldPtr
->offset
))
1139 case LTT_TYPE_STRING
:
1140 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;)V");
1141 (*env
)->CallStaticVoidMethod( env
,
1145 (*env
)->NewStringUTF(env
, ltt_event_get_string(&newEventPtr
, newMarkerFieldPtr
) )
1149 case LTT_TYPE_COMPACT
:
1150 case LTT_TYPE_NONE
:
1152 printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData)");