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
);
108 /* Method to obtain a trace version number from its path */
109 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_factory_JniTraceVersion_ltt_1getTraceVersion(JNIEnv
*env
, jobject jobj
, jstring tracepath
) {
111 const gchar
*c_pathname
= (*env
)->GetStringUTFChars(env
, tracepath
, 0);
112 jint tmpMajorNumber
= 0;
113 jint tmpMinorNumber
= 0;
115 jclass accessClass
= (*env
)->GetObjectClass(env
, jobj
);
116 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTraceVersionFromC", "(II)V");
118 struct LttTraceVersion version_number
;
120 if ( ltt_get_trace_version(c_pathname
, &version_number
) >= 0) {
121 tmpMajorNumber
= version_number
.ltt_major_version
;
122 tmpMinorNumber
= version_number
.ltt_minor_version
;
125 (*env
)->CallVoidMethod(env
, jobj
, accessFunction
, tmpMajorNumber
, tmpMinorNumber
);
133 ### TRACE methods ###
135 JNI mapping of < LttTrace *ltt_trace_open(const gchar *pathname) > (trace.h) */
136 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTrace(JNIEnv
*env
, jobject jobj
, jstring pathname
, jboolean show_debug
) {
139 /* Make sure we don't use any debug (speed up the read) */
140 g_log_set_handler(NULL
, G_LOG_LEVEL_INFO
, ignore_and_drop_message
, NULL
);
141 g_log_set_handler(NULL
, G_LOG_LEVEL_DEBUG
, ignore_and_drop_message
, NULL
);
144 const char *c_pathname
= (*env
)->GetStringUTFChars(env
, pathname
, 0);
145 LttTrace
*newPtr
= ltt_trace_open(c_pathname
);
147 (*env
)->ReleaseStringUTFChars(env
, pathname
, c_pathname
);
149 return CONVERT_PTR_TO_JLONG(newPtr
);
152 /* JNI mapping of < LttTrace *ltt_trace_open_live(const gchar *pathname) > (trace.h) */
153 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1openTraceLive(JNIEnv
*env
, jobject jobj
, jstring pathname
, jboolean show_debug
) {
156 /* Make sure we don't use any debug (speed up the read) */
157 g_log_set_handler(NULL
, G_LOG_LEVEL_INFO
, ignore_and_drop_message
, NULL
);
158 g_log_set_handler(NULL
, G_LOG_LEVEL_DEBUG
, ignore_and_drop_message
, NULL
);
161 const char *c_pathname
= (*env
)->GetStringUTFChars(env
, pathname
, 0);
162 LttTrace
*newPtr
= ltt_trace_open_live(c_pathname
);
164 (*env
)->ReleaseStringUTFChars(env
, pathname
, c_pathname
);
166 return CONVERT_PTR_TO_JLONG(newPtr
);
169 /* JNI mapping of < void ltt_trace_close(LttTrace *t) > (trace.h) */
170 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1closeTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
){
172 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
174 ltt_trace_close(newPtr
);
177 /* Get the tracepath */
178 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getTracepath(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
179 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
181 return (*env
)->NewStringUTF(env
, g_quark_to_string( newPtr
->pathname
) );
186 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getCpuNumber(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
187 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
189 return (jint
)newPtr
->num_cpu
;
192 /* Get of arch_type */
193 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchType(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
194 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
196 return (jlong
)newPtr
->arch_type
;
199 /* Get of arch_variant */
200 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchVariant(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
201 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
203 return (jlong
)newPtr
->arch_variant
;
206 /* Get of arch_size */
207 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getArchSize(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
208 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
210 return (jshort
)newPtr
->arch_size
;
213 /* Get of ltt_major_version */
214 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMajorVersion(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
215 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
217 return (jshort
)newPtr
->ltt_major_version
;
220 /* Get of ltt_minor_version */
221 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getLttMinorVersion(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
222 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
224 return (jshort
)newPtr
->ltt_minor_version
;
227 /* Get of flight_recorder */
228 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFlightRecorder(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
229 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
231 return (jshort
)newPtr
->flight_recorder
;
234 /* Get of freq_scale */
235 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getFreqScale(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
236 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
238 return (jlong
)newPtr
->freq_scale
;
241 /* Get of start_freq */
242 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartFreq(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
243 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
245 return CONVERT_UINT64_TO_JLONG(newPtr
->start_freq
);
248 /* Get of start_tsc */
249 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartTimestampCurrentCounter(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
250 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
252 return CONVERT_UINT64_TO_JLONG(newPtr
->start_tsc
);
255 /* Get of start_monotonic */
256 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getStartMonotonic(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
257 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
259 return CONVERT_UINT64_TO_JLONG(newPtr
->start_monotonic
);
262 /* JNI mapping of < int ltt_trace_update(LttTrace *t) > (trace.h) */
263 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1updateTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
){
265 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
267 return (jint
)ltt_trace_update(newPtr
);
270 /* Access to start_time */
271 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
272 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTime(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
273 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
275 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
276 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
278 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->start_time
.tv_nsec
);
280 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
283 /* Access to start_time_from_tsc */
284 /* Note that we are calling the setTimeFromC function in Jaf_Time from here */
285 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedStartTimeFromTimestampCurrentCounter(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
, jobject time_jobj
) {
286 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
288 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
289 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
291 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
);
293 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
297 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1getAllTracefiles */
298 void g_datalist_foreach_addTracefilesOfTrace(GQuark name
, gpointer data
, gpointer user_data
) {
299 struct java_calling_data
*args
= (struct java_calling_data
*)user_data
;
301 jclass accessClass
= (*args
->env
)->GetObjectClass(args
->env
, args
->jobj
);
302 jmethodID accessFunction
= (*args
->env
)->GetMethodID(args
->env
, accessClass
, "addTracefileFromC", "(Ljava/lang/String;J)V");
304 GArray
*tracefile_array
= (GArray
*)data
;
305 LttTracefile
*tracefile
;
309 for (i
=0; i
<tracefile_array
->len
; i
++) {
310 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
312 newPtr
= CONVERT_PTR_TO_JLONG(tracefile
);
314 (*args
->env
)->CallVoidMethod(args
->env
, args
->jobj
, accessFunction
, (*args
->env
)->NewStringUTF(args
->env
, g_quark_to_string(tracefile
->name
) ), newPtr
);
318 /* Function to fill up the java map with the event type found in tracefile (the name) */
319 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedAllTracefiles(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
320 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
322 struct java_calling_data args
= { env
, jobj
};
324 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_addTracefilesOfTrace
, &args
);
328 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1feedTracefileTimeRange */
329 /* used to save the current timestamp for each tracefile */
330 void g_datalist_foreach_saveTracefilesTime(GQuark name
, gpointer data
, gpointer user_data
) {
331 struct saveTimeArgs
*args
= (struct saveTimeArgs
*)user_data
;
333 GArray
*tracefile_array
= (GArray
*)data
;
334 GArray
*save_array
= args
->saveTimeArray
;
336 LttTracefile
*tracefile
;
337 struct saveTimeAndTracefile
*savedData
;
340 for (i
=0; i
<tracefile_array
->len
; i
++) {
341 tracefile
= &g_array_index(tracefile_array
, LttTracefile
, i
);
343 /* Allocate a new LttTime for each tracefile (so it won't change if the tracefile seek somewhere else) */
344 savedData
= (struct saveTimeAndTracefile
*)malloc( sizeof(struct saveTimeAndTracefile
) );
345 savedData
->time
.tv_sec
= tracefile
->event
.event_time
.tv_sec
;
346 savedData
->time
.tv_nsec
= tracefile
->event
.event_time
.tv_nsec
;
347 savedData
->tracefile
= tracefile
;
348 /* Append the saved data to the array */
349 g_array_append_val(save_array
, savedData
);
354 /* Obtain the range of the trace (i.e. "start time" and "end time") */
355 /* Note : This function, unlike ltt_trace_time_span_get, is assured to return all tracefiles to their correct position after operation */
356 /* NOTE : this method is quite heavy to use!!! */
357 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
) {
358 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
360 /* Allocate ourself a new array to save the data in */
361 GArray
*savedDataArray
= g_array_new(FALSE
, FALSE
, sizeof(struct saveTimeAndTracefile
*) );
362 struct saveTimeArgs args
= { savedDataArray
};
363 /* Call g_datalist_foreach_saveTracefilesTime for each element in the GData to save the time */
364 g_datalist_foreach(&newPtr
->tracefiles
, &g_datalist_foreach_saveTracefilesTime
, &args
);
366 /* Call to ltt_trace_time_span_get to find the current start and end time */
367 /* NOTE : This WILL change the current block of the tracefile (i.e. its timestamp) */
368 LttTime tmpStartTime
= { 0, 0 };
369 LttTime tmpEndTime
= { 0, 0 };
370 ltt_trace_time_span_get(newPtr
, &tmpStartTime
, &tmpEndTime
);
372 /* Seek back to the correct time for each tracefile and free the allocated memory */
373 struct saveTimeAndTracefile
*savedData
;
375 for (i
=0; i
<savedDataArray
->len
; i
++) {
376 savedData
= g_array_index(savedDataArray
, struct saveTimeAndTracefile
*, i
);
377 /* Seek back to the correct time */
378 /* Some time will not be consistent here (i.e. unitialized data) */
379 /* but the seek should work just fine with that */
380 ltt_tracefile_seek_time(savedData
->tracefile
, savedData
->time
);
382 /* Free the memory allocated for this saveTimeAndTracefile entry */
385 /* Free the memory allocated for the GArray */
386 g_array_free(savedDataArray
, TRUE
);
388 /* Send the start and end time back to the java */
389 /* We do it last to make sure a problem won't leave us with unfred memory */
390 jclass startAccessClass
= (*env
)->GetObjectClass(env
, jstart_time
);
391 jmethodID startAccessFunction
= (*env
)->GetMethodID(env
, startAccessClass
, "setTimeFromC", "(J)V");
392 jlong startTime
= (CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpStartTime
.tv_nsec
);
393 (*env
)->CallVoidMethod(env
, jstart_time
, startAccessFunction
, startTime
);
395 jclass endAccessClass
= (*env
)->GetObjectClass(env
, jend_time
);
396 jmethodID endAccessFunction
= (*env
)->GetMethodID(env
, endAccessClass
, "setTimeFromC", "(J)V");
397 jlong endTime
= (CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(tmpEndTime
.tv_nsec
);
398 (*env
)->CallVoidMethod(env
, jend_time
, endAccessFunction
, endTime
);
401 /* Function to print the content of a trace */
402 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTrace_ltt_1printTrace(JNIEnv
*env
, jobject jobj
, jlong trace_ptr
) {
404 LttTrace
*newPtr
= (LttTrace
*)CONVERT_JLONG_TO_PTR(trace_ptr
);
406 printf("pathname : %s\n" ,g_quark_to_string(newPtr
->pathname
) );
407 printf("num_cpu : %u\n" ,(unsigned int)(newPtr
->num_cpu
) );
408 printf("arch_type : %u\n" ,(unsigned int)(newPtr
->arch_type
) );
409 printf("arch_variant : %u\n" ,(unsigned int)(newPtr
->arch_variant
) );
410 printf("arch_size : %u\n" ,(unsigned short)(newPtr
->arch_size
) );
411 printf("ltt_major_version : %u\n" ,(unsigned short)(newPtr
->ltt_major_version
) );
412 printf("ltt_minor_version : %u\n" ,(unsigned short)(newPtr
->ltt_minor_version
) );
413 printf("flight_recorder : %u\n" ,(unsigned short)(newPtr
->flight_recorder
) );
414 printf("freq_scale : %u\n" ,(unsigned int)(newPtr
->freq_scale
) );
415 printf("start_freq : %lu\n" ,(long unsigned int)(newPtr
->start_freq
) );
416 printf("start_tsc : %lu\n" ,(long unsigned int)(newPtr
->start_tsc
) );
417 printf("start_monotonic : %lu\n" ,(long unsigned int)(newPtr
->start_monotonic
) );
418 printf("start_time ptr : %p\n" ,&newPtr
->start_time
);
419 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_sec
) );
420 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time
.tv_nsec
) );
421 printf("start_time_from_tsc ptr : %p\n" ,&newPtr
->start_time_from_tsc
);
422 printf(" tv_sec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_sec
) );
423 printf(" tv_nsec : %lu\n" ,(long unsigned int)(newPtr
->start_time_from_tsc
.tv_nsec
) );
424 printf("tracefiles ptr : %p\n" ,newPtr
->tracefiles
);
435 ### TRACEFILE methods ###
438 /* Get of cpu_online */
439 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsCpuOnline(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
440 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
442 return (jboolean
)newPtr
->cpu_online
;
445 /* Get of long_name */
446 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilepath(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
447 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
449 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->long_name
) );
453 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracefilename(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
454 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
456 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
) );
460 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCpuNumber(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
461 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
463 return (jlong
)newPtr
->cpu_num
;
467 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTid(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
468 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
470 return (jlong
)newPtr
->tid
;
474 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getPgid(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
475 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
477 return (jlong
)newPtr
->pgid
;
480 /* Get of creation */
481 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCreation(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
482 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
484 return CONVERT_UINT64_TO_JLONG(newPtr
->creation
);
488 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getTracePtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
489 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
491 return CONVERT_PTR_TO_JLONG(newPtr
->trace
);
495 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getMarkerDataPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
496 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
498 return CONVERT_PTR_TO_JLONG(newPtr
->mdata
);
502 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCFileDescriptor(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
503 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
505 return (jint
)newPtr
->fd
;
508 /* Get of file_size */
509 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getFileSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
510 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
512 return CONVERT_UINT64_TO_JLONG(newPtr
->file_size
);
515 /* Get of num_blocks */
516 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBlockNumber(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
517 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
519 return (jlong
)newPtr
->num_blocks
;
522 /* Get of reverse_bo */
523 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsBytesOrderReversed(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
524 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
526 return (jboolean
)newPtr
->reverse_bo
;
529 /* Get of float_word_order */
530 JNIEXPORT jboolean JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getIsFloatWordOrdered(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
531 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
533 return (jboolean
)newPtr
->float_word_order
;
536 /* Get of alignment */
537 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAlignement(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
538 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
540 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
543 /* Get of buffer_header_size */
544 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferHeaderSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
545 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
547 return CONVERT_UINT64_TO_JLONG(newPtr
->buffer_header_size
);
551 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfCurrentTimestampCounter(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
552 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
554 return (jint
)newPtr
->tscbits
;
557 /* Get of eventbits */
558 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBitsOfEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
559 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
561 return (jint
)newPtr
->eventbits
;
564 /* Get of tsc_mask */
565 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMask(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
566 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
568 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask
);
571 /* Get of tsc_mask_next_bit */
572 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getCurrentTimestampCounterMaskNextBit(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
573 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
575 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc_mask_next_bit
);
578 /* Get of events_lost */
579 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventsLost(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
580 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
582 return (jlong
)newPtr
->events_lost
;
585 /* Get of subbuf_corrupt */
586 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getSubBufferCorrupt(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
587 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
589 return (jlong
)newPtr
->subbuf_corrupt
;
593 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getEventPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
594 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
596 return CONVERT_PTR_TO_JLONG(&newPtr
->event
);
600 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferPtr(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
601 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
603 return CONVERT_PTR_TO_JLONG(&newPtr
->buffer
);
606 /* Get of buffer size */
607 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getBufferSize(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
608 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
610 return (jlong
)newPtr
->buffer
.size
;
614 /* g_list_data function for the "for_each" call in Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1getAllMarkers */
615 void g_hash_table_foreach_addMarkersOfTracefile(gpointer key
, gpointer data
, gpointer user_data
) {
616 struct addMarkersArgs
*args
= (struct addMarkersArgs
*)user_data
;
617 struct java_calling_data
*jargs
= (struct java_calling_data
*)args
->java_args
;
619 jclass accessClass
= (*jargs
->env
)->GetObjectClass(jargs
->env
, jargs
->jobj
);
620 jmethodID accessFunction
= (*jargs
->env
)->GetMethodID(jargs
->env
, accessClass
, "addMarkersFromC", "(IJ)V");
622 unsigned long marker_id
= (unsigned long)data
;
624 /* The hash table store an ID... we will use the ID to access the array. */
625 GArray
*marker
= args
->mdata
->markers
;
626 struct marker_info
*newPtr
= &g_array_index(marker
, struct marker_info
, marker_id
);
628 (*jargs
->env
)->CallVoidMethod(jargs
->env
, jargs
->jobj
, accessFunction
, marker_id
, CONVERT_PTR_TO_JLONG(newPtr
) );
631 /* Function to fill up the java map with the event type found in tracefile (the name) */
632 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1feedAllMarkers(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
633 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
636 Find a better way! This is ugly! */
637 struct java_calling_data java_args
= { env
, jobj
};
638 struct addMarkersArgs args
= { &java_args
, newPtr
->mdata
};
640 g_hash_table_foreach( newPtr
->mdata
->markers_hash
, &g_hash_table_foreach_addMarkersOfTracefile
, &args
);
644 /* Function to print the content of a tracefile */
645 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniTracefile_ltt_1printTracefile(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
647 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
648 printf("cpu_online : %i\n" ,(int)newPtr
->cpu_online
);
649 printf("long_name : %s\n" ,g_quark_to_string(newPtr
->long_name
));
650 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
));
651 printf("cpu_num : %u\n" ,(unsigned int)(newPtr
->cpu_num
));
652 printf("tid : %u\n" ,(unsigned int)(newPtr
->tid
));
653 printf("pgid : %u\n" ,(unsigned int)(newPtr
->pgid
));
654 printf("creation : %lu\n" ,(long unsigned int)(newPtr
->creation
));
655 printf("trace ptr : %p\n" ,newPtr
->trace
);
656 printf("marker ptr : %p\n" ,newPtr
->mdata
);
657 printf("fd : %i\n" ,(int)(newPtr
->fd
));
658 printf("file_size : %u\n" ,(unsigned int)(newPtr
->file_size
));
659 printf("num_blocks : %u\n" ,(unsigned int)(newPtr
->num_blocks
));
660 printf("reverse_bo : %i\n" ,(int)newPtr
->reverse_bo
);
661 printf("float_word_order : %i\n" ,(int)newPtr
->float_word_order
);
662 printf("alignment : %i\n" ,(int)newPtr
->alignment
);
663 printf("buffer_header_size : %i\n" ,(int)newPtr
->buffer_header_size
);
664 printf("tscbits : %u\n" ,(unsigned short)newPtr
->tscbits
);
665 printf("eventbits : %u\n" ,(unsigned short)newPtr
->eventbits
);
666 printf("tsc_mask : %lu\n" ,(long unsigned int)newPtr
->tsc_mask
);
667 printf("tsc_mask_next_bit : %lu\n" ,(long unsigned int)newPtr
->tsc_mask_next_bit
);
668 printf("events_lost : %u\n" ,(unsigned int)newPtr
->events_lost
);
669 printf("subbuf_corrupt : %u\n" ,(unsigned int)newPtr
->subbuf_corrupt
);
670 printf("event ptr : %p\n" ,&newPtr
->event
);
671 printf("buffer ptr : %p\n" ,&newPtr
->buffer
);
681 ### EVENT methods ###
684 /* Method to get the read status */
685 /* This method will read the next event and then seek back its initial position */
686 /* Lttv assume that every tracefile have at least 1 event, but we have not guarantee after this one. */
687 /* We will read the next event and return the status of that read */
688 /* We will then seek back to our initial position */
689 /* Note : this method is expensive and should not be used too often */
690 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1positionToFirstEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
691 LttTracefile
*tracefilePtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
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 if (tracefilePtr
->trace
== NULL
) {
703 /* Seek to the start time... this will also read the first event, as we want. */
704 int returnedValue
= ltt_tracefile_seek_time(tracefilePtr
, ((struct LttTrace
)*(tracefilePtr
->trace
)).start_time_from_tsc
);
706 return (jint
)returnedValue
;
709 /* Method to read next event */
710 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1readNextEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
) {
711 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
713 /* Ask ltt to read the next events on the given tracefiles
714 Returned value can be :
715 0 if everything went fine (EOK)
716 ERANGE = 34 out of range, back to last event (might be system dependent?)
717 EPERM = 1 error while reading (might be system dependent?) */
721 This might fail on the FIRST event, as the timestamp before the first read is uninitialized
722 However, LTT make the assumption that all tracefile have AT LEAST one event, so we got to run with it */
724 /* Save "last time" before moving, to be able to get back if needed */
725 LttTime lastTime
= newPtr
->event
.event_time
;
727 int returnedValue
= ltt_tracefile_read(newPtr
);
729 /* We need to get back to previous after an error to keep a sane state */
730 if ( returnedValue
!= 0 ) {
731 ltt_tracefile_seek_time(newPtr
, lastTime
);
734 return (jint
)returnedValue
;
737 /* Method to seek to a certain event */
738 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1seekEvent(JNIEnv
*env
, jobject jobj
, jlong tracefile_ptr
, jobject time_jobj
) {
739 LttTracefile
*newPtr
= (LttTracefile
*)CONVERT_JLONG_TO_PTR(tracefile_ptr
);
741 guint64 fullTime
= 0;
743 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
744 jmethodID getTimeFunction
= (*env
)->GetMethodID(env
, accessClass
, "getTime", "()J");
745 fullTime
= (*env
)->CallLongMethod(env
, time_jobj
, getTimeFunction
);
748 Conversion from jlong -> C long seems to be particularly sloppy
749 Depending how and where (inlined a function or as a single operation) we do this, we might end up with wrong number
750 The following asignation of guint64 seems to work well.
751 MAKE SURE TO PERFORM SEVERAL TESTS IF YOU CHANGE THIS. */
752 guint64 seconds
= fullTime
/BILLION
;
753 guint64 nanoSeconds
= fullTime
%BILLION
;
755 LttTime seekTime
= { (unsigned long)seconds
, (unsigned long)nanoSeconds
};
757 /* Ask ltt to read the next events on the given tracefiles
758 Returned value can be :
759 0 if everything went fine (EOK)
760 ERANGE = 34 out of range, back to last event (might be system dependent?)
761 EPERM = 1 error while reading (might be system dependent?) */
763 int returnedValue
= ltt_tracefile_seek_time(newPtr
, seekTime
);
764 return (jint
)returnedValue
;
767 /* Get of tracefile */
768 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTracefilePtr(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
769 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
771 return CONVERT_PTR_TO_JLONG(newPtr
->tracefile
);
775 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getBlock(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
776 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
778 return (jlong
)newPtr
->block
;
782 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOffset(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
783 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
785 return (jlong
)newPtr
->offset
;
789 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCurrentTimestampCounter(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
790 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
792 return CONVERT_UINT64_TO_JLONG(newPtr
->tsc
);
795 /* Get of timestamp */
796 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getTimestamp(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
797 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
799 return (jlong
)newPtr
->timestamp
;
802 /* Get of event_id */
803 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventMarkerId(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
804 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
806 return (jint
)newPtr
->event_id
;
809 /* Get time in nanoseconds */
810 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getNanosencondsTime(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
811 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
813 return (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
816 /* Fill event_time into an object */
817 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1feedEventTime(JNIEnv
*env
, jobject jobj
, jlong event_ptr
, jobject time_jobj
) {
818 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
820 jclass accessClass
= (*env
)->GetObjectClass(env
, time_jobj
);
821 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "setTimeFromC", "(J)V");
823 jlong fullTime
= (CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_sec
)*BILLION
) + CONVERT_UINT64_TO_JLONG(newPtr
->event_time
.tv_nsec
);
825 (*env
)->CallVoidMethod(env
, time_jobj
, accessFunction
, fullTime
);
828 /* Access method to the data */
829 /* The data are in "byte" form */
830 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getDataContent(JNIEnv
*env
, jobject jobj
, jlong event_ptr
, jlong data_size
, jbyteArray dataArray
) {
831 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
833 (*env
)->SetByteArrayRegion(env
, dataArray
, 0, (jsize
)data_size
, newPtr
->data
);
836 /* Get of data_size */
837 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventDataSize(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
838 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
840 return (jlong
)newPtr
->data_size
;
843 /* Get of event_size */
844 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getEventSize(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
845 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
847 return (jlong
)newPtr
->event_size
;
851 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getCount(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
852 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
854 return (jint
)newPtr
->count
;
857 /* Get of overflow_nsec */
858 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1getOverflowNanoSeconds(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
859 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
861 return CONVERT_UINT64_TO_JLONG(newPtr
->overflow_nsec
);
865 /* Function to print the content of a event */
866 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniEvent_ltt_1printEvent(JNIEnv
*env
, jobject jobj
, jlong event_ptr
) {
867 LttEvent
*newPtr
= (LttEvent
*)CONVERT_JLONG_TO_PTR(event_ptr
);
869 printf("tracefile : %p\n" ,(void*)newPtr
->tracefile
);
870 printf("block : %u\n" ,(unsigned int)newPtr
->block
);
871 printf("offset : %u\n" ,(unsigned int)newPtr
->offset
);
872 printf("tsc : %lu\n" ,(long unsigned int)newPtr
->tsc
);
873 printf("timestamp : %u\n" ,(unsigned int)newPtr
->timestamp
);
874 printf("event_id : %u\n" ,(unsigned short)newPtr
->event_id
);
875 printf("event_time : %p\n" ,(void*) &newPtr
->event_time
);
876 printf(" sec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_sec
) );
877 printf(" nsec : %lu\n" ,(long unsigned int)(newPtr
->event_time
.tv_nsec
) );
878 printf("data : %p\n" ,(void*) newPtr
->data
);
879 printf("data_size : %u\n" ,(unsigned int)newPtr
->data_size
);
880 printf("event_size : %u\n" ,(unsigned int)newPtr
->event_size
);
881 printf("count : %d\n" ,(int)newPtr
->count
);
882 printf("overflow_nsec : %ld\n" ,(long)newPtr
->overflow_nsec
);
891 ### MARKER method ###
895 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getName(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
896 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
898 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
902 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getFormatOverview(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
903 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
905 return (*env
)->NewStringUTF(env
, newPtr
->format
);
909 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
910 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
912 return (jlong
)newPtr
->size
;
915 /* Method to get all markerField pointers */
916 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAllMarkerFields(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
917 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
919 jclass accessClass
= (*env
)->GetObjectClass(env
, jobj
);
920 jmethodID accessFunction
= (*env
)->GetMethodID(env
, accessClass
, "addMarkerFieldFromC", "(Ljava/lang/String;J)V");
922 GArray
*field_array
= (GArray
*)newPtr
->fields
;
923 struct marker_field
*field
;
924 jlong marker_field_ptr
;
927 for (i
=0; i
<field_array
->len
; i
++) {
928 field
= &g_array_index(field_array
, struct marker_field
, i
);
930 marker_field_ptr
= CONVERT_PTR_TO_JLONG(field
);
932 (*env
)->CallVoidMethod(env
, jobj
, accessFunction
, (*env
)->NewStringUTF(env
, g_quark_to_string(field
->name
) ), marker_field_ptr
);
938 /* Get of largest_align */
939 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLargestAlign(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
940 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
942 return (jshort
)newPtr
->largest_align
;
945 /* Get of int_size */
946 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getIntSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
947 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
949 return (jshort
)newPtr
->int_size
;
952 /* Get of long_size */
953 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getLongSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
954 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
956 return (jshort
)newPtr
->long_size
;
959 /* Get of pointer_size */
960 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getPointerSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
961 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
963 return (jshort
)newPtr
->pointer_size
;
966 /* Get of size_t_size */
967 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getSize_1tSize(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
968 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
970 return (jshort
)newPtr
->size_t_size
;
973 /* Get of alignment */
974 JNIEXPORT jshort JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getAlignement(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
975 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
977 return (jshort
)newPtr
->alignment
;
981 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1getNextMarkerPtr(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
982 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
984 return CONVERT_PTR_TO_JLONG(newPtr
->next
);
988 /* Function to print the content of a marker */
989 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarker_ltt_1printMarker(JNIEnv
*env
, jobject jobj
, jlong marker_info_ptr
) {
990 struct marker_info
*newPtr
= (struct marker_info
*)CONVERT_JLONG_TO_PTR(marker_info_ptr
);
992 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
993 printf("format : %s\n" ,newPtr
->format
);
994 printf("size : %li\n" ,(long int)newPtr
->size
);
995 printf("largest_align : %u\n" ,(unsigned short)newPtr
->largest_align
);
996 printf("fields : %p\n" ,newPtr
->fields
);
997 printf("int_size : %u\n" ,(unsigned short)newPtr
->int_size
);
998 printf("long_size : %u\n" ,(unsigned short)newPtr
->long_size
);
999 printf("pointer_size : %u\n" ,(unsigned short)newPtr
->pointer_size
);
1000 printf("size_t_size : %u\n" ,(unsigned short)newPtr
->size_t_size
);
1001 printf("alignment : %u\n" ,(unsigned short)newPtr
->alignment
);
1002 printf("next : %p\n" ,newPtr
->next
);
1012 ### MARKERFIELD Method
1016 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getField(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1017 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1019 return (*env
)->NewStringUTF(env
, g_quark_to_string(newPtr
->name
));
1023 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getType(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1024 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1026 return (jint
)newPtr
->type
;
1029 /* Get of alignment */
1030 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAlignment(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1031 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1033 return CONVERT_UINT64_TO_JLONG(newPtr
->alignment
);
1036 /* Get of attributes */
1037 JNIEXPORT jlong JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getAttributes(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1038 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1040 return CONVERT_UINT64_TO_JLONG(newPtr
->attributes
);
1043 /* Get of static_offset */
1044 JNIEXPORT jint JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getStatic_1offset(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1045 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1047 return (jint
)newPtr
->static_offset
;
1051 JNIEXPORT jstring JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1getFormat(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1052 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1054 return (*env
)->NewStringUTF(env
, newPtr
->fmt
->str
);
1057 /* Function to print the content of a marker_field */
1058 JNIEXPORT
void JNICALL
Java_org_eclipse_linuxtools_lttng_jni_JniMarkerField_ltt_1printMarkerField(JNIEnv
*env
, jobject jobj
, jlong marker_field_ptr
) {
1059 struct marker_field
*newPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1061 printf("name : %s\n" ,g_quark_to_string(newPtr
->name
) );
1062 printf("type : %i\n" ,(int)newPtr
->type
);
1063 printf("alignment : %lu\n" ,(long unsigned int)newPtr
->alignment
);
1064 printf("attributes : %lu\n" ,(long unsigned int)newPtr
->attributes
);
1065 printf("static_offset : %i\n" ,(int)newPtr
->static_offset
);
1066 printf("fmt : %s\n" ,newPtr
->fmt
->str
);
1078 /* This function will do the actual parsing */
1079 /* It will then call java to assign the parsed data to the object "javaObj" */
1080 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
) {
1081 LttEvent newEventPtr
= *(LttEvent
*)(CONVERT_JLONG_TO_PTR(event_ptr
));
1082 struct marker_field
*newMarkerFieldPtr
= (struct marker_field
*)CONVERT_JLONG_TO_PTR(marker_field_ptr
);
1083 struct LttField
*newLttFieldPtr
= ltt_event_field(&newEventPtr
, marker_field_get_index(newMarkerFieldPtr
));
1085 jmethodID accessFunction
= NULL
;
1089 There is a very limited number of type in LTT
1090 We will switch on the type for this field and act accordingly
1091 NOTE : We will save all integer into "long" type, as there is no signed/unsigned in java */
1094 It seems the marker_field->type is absolutely not consistent, especially about pointer!
1095 Sometime pointer are saved in String, sometime as Int, sometime as pointer...
1096 We will do an extra check on type "LTT_TYPE_UNSIGNED_INT" to check if the marker_field->format is hint of a pointer */
1097 switch ( newMarkerFieldPtr
->type
) {
1098 case LTT_TYPE_SIGNED_INT
:
1099 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1100 (*env
)->CallStaticVoidMethod( env
,
1104 ltt_event_get_long_int(&newEventPtr
, newMarkerFieldPtr
)
1109 case LTT_TYPE_UNSIGNED_INT
:
1110 /* If the format seems to be a pointer, add it as a pointer */
1111 if ( (strncmp(newMarkerFieldPtr
->fmt
->str
, "0x%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) || (strncmp(newMarkerFieldPtr
->fmt
->str
, "%llX", newMarkerFieldPtr
->fmt
->len
) == 0 ) ) {
1112 #if __WORDSIZE == 64
1113 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1115 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1117 (*env
)->CallStaticVoidMethod( env
,
1121 CONVERT_PTR_TO_JLONG(ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
) )
1124 /* Otherwise, add it as a number */
1126 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongToParsingFromC", "(Ljava/lang/Object;J)V");
1127 (*env
)->CallStaticVoidMethod( env
,
1131 ltt_event_get_long_unsigned(&newEventPtr
, newMarkerFieldPtr
)
1137 case LTT_TYPE_POINTER
:
1138 #if __WORDSIZE == 64
1139 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addLongPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1141 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addIntPointerToParsingFromC", "(Ljava/lang/Object;J)V");
1143 (*env
)->CallStaticVoidMethod( env
,
1147 CONVERT_PTR_TO_JLONG(*(GINT_TYPE_FOR_PTR
*)(newEventPtr
.data
+ newLttFieldPtr
->offset
))
1151 case LTT_TYPE_STRING
:
1152 accessFunction
= (*env
)->GetStaticMethodID(env
, accessClass
, "addStringToParsingFromC", "(Ljava/lang/Object;Ljava/lang/String;)V");
1153 (*env
)->CallStaticVoidMethod( env
,
1157 (*env
)->NewStringUTF(env
, ltt_event_get_string(&newEventPtr
, newMarkerFieldPtr
) )
1161 case LTT_TYPE_COMPACT
:
1162 case LTT_TYPE_NONE
:
1164 printf("Warning : Unrecognized format type! Skipping! (Java_org_eclipse_linuxtools_lttng_jni_JniParser_ltt_1getParsedData)");