Previously to the handler themselves data variables were passed.
It was not scalable and difficult to maintain. Now these
variables replaced with structure that contains this data. This
makes passing data more flexible and reduces stack usage on some
platforms.
Also it separates original address (address where probe has
fired) and exec address (pointer to function that should be
executed). It was done because of a great difference between
GOT patcher-based handling and Preload-based: in the second
case we have no avaliable information in user-space about
caller, call_type and original address and exec address
is the result of a dlsym() search while in the first case
we know everything in userspace.
Change-Id: Ib47fa1e655c5f820fdefacea7bd8e85765e62b8c
Signed-off-by: Alexander Aksenov <a.aksenov@samsung.com>
INTERNAL_CALL
};
+struct probe_data_t {
+ uint64_t caller;
+ ElfW(Addr) orig;
+ uint32_t call_type;
+ void *func;
+};
+
static inline uint64_t voidp_to_uint64(const void *p)
{
return (uint64_t)(uintptr_t)p;
#define CALLER_PTR caller_p
#define CALL_TYPE_PTR call_type_p
+#define PROBE_GET_CALLER(pd_p) (pd_p)->caller
+#define PROBE_GET_CALL_TYPE(pd_p) (pd_p)->call_type
+#define PROBE_GET_ORIG(pd_p) (pd_p)->orig
+#define PROBE_GET_FUNC(pd_p) (pd_p)->func
+
#define PACK_INT32(val) \
BUF_PTR = pack_int32(BUF_PTR, val);
#define PACK_INT64(val) \
#define DEF_H(_ret, _name, ...) \
-static _ret CONCAT(_name, _handler)(ElfW(Addr) orig, uint32_t call_type,\
- unsigned long caller \
+static _ret CONCAT(_name, _handler)(struct probe_data_t *probe_data \
FUNC_DECL_H(__VA_ARGS__))
#define DEF_W(_ret, _name, ...) \
#define DEF_WA(_ret, _name, ...) \
_ret CONCAT(PROBE_NAME(_name), _always)(FUNC_DECL(__VA_ARGS__))
+/* Wrapper for kernel call. Takes ret type, func name */
+#define DEF_WKC(_ret, _name, ...) \
+_ret CONCAT(PROBE_NAME(_name), _kernel_call)(FUNC_DECL(__VA_ARGS__))
+
#define DEF_WV(_ret, _name, ...) \
_ret PROBE_NAME(_name)(FUNC_DECL_V(__VA_ARGS__))
#define DEF_WAV(_ret, _name, ...) \
_ret CONCAT(PROBE_NAME(_name), _always)(FUNC_DECL_V(__VA_ARGS__))
-
-#define HANDLER_WRAPPERS(_feat, _ret, _name, ...) \
-DEF_H(_ret, _name, __VA_ARGS__); \
- \
-DEF_W(_ret, _name, __VA_ARGS__) \
-{ \
- unsigned long caller; \
- ElfW(Addr) orig; \
- \
- caller = (unsigned long) \
- (__builtin_extract_return_addr(__builtin_return_address(0)));\
- orig = GET_ORIG_FUNC(_feat, _name); \
- return CONCAT(_name, _handler)(orig, INTERNAL_CALL, (uint64_t)caller \
- FUNC_CALL(__VA_ARGS__)); \
-} \
- \
-DEF_WA(_ret, _name, __VA_ARGS__) \
-{ \
- unsigned long caller; \
- ElfW(Addr) orig; \
- \
- caller = (unsigned long) \
- (__builtin_extract_return_addr(__builtin_return_address(0)));\
- orig = GET_ORIG_FUNC(_feat ## _always, _name); \
- return CONCAT(_name, _handler)(orig, EXTERNAL_CALL, \
- (uint64_t)caller \
- FUNC_CALL(__VA_ARGS__)); \
-} \
+/* Wrapper for kernel call with variable arguments. Takes ret type, func name */
+#define DEF_WKCV(_ret, _name, ...) \
+_ret CONCAT(PROBE_NAME(_name), _kernel_call)(FUNC_DECL_V(__VA_ARGS__))
+
+
+#define HANDLER_WRAPPERS(_feat, _ret, _name, ...) \
+DEF_H(_ret, _name, __VA_ARGS__); \
+ \
+DEF_W(_ret, _name, __VA_ARGS__) \
+{ \
+ unsigned long caller; \
+ ElfW(Addr) orig; \
+ struct probe_data_t pd; \
+ \
+ caller = (unsigned long) \
+ (__builtin_extract_return_addr(__builtin_return_address(0))); \
+ orig = GET_ORIG_FUNC(_feat, _name); \
+ \
+ pd.caller = (uint64_t)caller; \
+ pd.call_type = INTERNAL_CALL; \
+ pd.orig = orig; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ return CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
+DEF_WA(_ret, _name, __VA_ARGS__) \
+{ \
+ unsigned long caller; \
+ ElfW(Addr) orig; \
+ struct probe_data_t pd; \
+ \
+ caller = (unsigned long) \
+ (__builtin_extract_return_addr(__builtin_return_address(0))); \
+ orig = GET_ORIG_FUNC(_feat ## _always, _name); \
+ \
+ pd.caller = (uint64_t)caller; \
+ pd.call_type = EXTERNAL_CALL; \
+ pd.orig = orig; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ return CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
+/* Wrapper to be called from kernel. Takes ret type, func name and args */ \
+DEF_WKC(_ret, _name, __VA_ARGS__) \
+{ \
+ struct probe_data_t pd; \
+ void *func; \
+ \
+ func = dlsym(RTLD_NEXT, #_name); \
+ if (func == NULL || dlerror() != NULL) { \
+ PRINTERR("Cannot find function <%s>, terminate!", #_name); \
+ exit(1); \
+ } \
+ \
+ pd.caller = 0; \
+ pd.call_type = 0; \
+ pd.orig = 0; \
+ pd.func = func; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ return CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
DEF_H(_ret, _name, __VA_ARGS__)
-#define HANDLER_WRAPPERS_VOID(_feat, _ret, _name, ...) \
-DEF_H(_ret, _name, __VA_ARGS__); \
- \
-DEF_W(_ret, _name, __VA_ARGS__) \
-{ \
- unsigned long caller; \
- ElfW(Addr) orig; \
- \
- caller = (unsigned long) \
- (__builtin_extract_return_addr(__builtin_return_address(0)));\
- orig = GET_ORIG_FUNC(_feat, _name); \
- CONCAT(_name, _handler)(orig, INTERNAL_CALL, (uint64_t)caller \
- FUNC_CALL(__VA_ARGS__)); \
-} \
- \
-DEF_WA(_ret, _name, __VA_ARGS__) \
-{ \
- unsigned long caller; \
- ElfW(Addr) orig; \
- \
- caller = (unsigned long) \
- (__builtin_extract_return_addr(__builtin_return_address(0)));\
- orig = GET_ORIG_FUNC(_feat ## _always, _name); \
- CONCAT(_name, _handler)(orig, EXTERNAL_CALL, \
- (uint64_t)caller FUNC_CALL(__VA_ARGS__)); \
-} \
+#define HANDLER_WRAPPERS_VOID(_feat, _ret, _name, ...) \
+DEF_H(_ret, _name, __VA_ARGS__); \
+ \
+DEF_W(_ret, _name, __VA_ARGS__) \
+{ \
+ unsigned long caller; \
+ ElfW(Addr) orig; \
+ struct probe_data_t pd; \
+ \
+ caller = (unsigned long) \
+ (__builtin_extract_return_addr(__builtin_return_address(0))); \
+ orig = GET_ORIG_FUNC(_feat, _name); \
+ \
+ pd.caller = (uint64_t)caller; \
+ pd.call_type = INTERNAL_CALL; \
+ pd.orig = orig; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
+DEF_WA(_ret, _name, __VA_ARGS__) \
+{ \
+ unsigned long caller; \
+ ElfW(Addr) orig; \
+ struct probe_data_t pd; \
+ \
+ caller = (unsigned long) \
+ (__builtin_extract_return_addr(__builtin_return_address(0))); \
+ orig = GET_ORIG_FUNC(_feat ## _always, _name); \
+ \
+ pd.caller = (uint64_t)caller; \
+ pd.call_type = EXTERNAL_CALL; \
+ pd.orig = orig; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
+/* Wrapper to be called from kernel. Takes ret type, func name and args */ \
+DEF_WKC(_ret, _name, __VA_ARGS__) \
+{ \
+ struct probe_data_t pd; \
+ void *func; \
+ \
+ func = dlsym(RTLD_NEXT, #_name); \
+ if (func == NULL || dlerror() != NULL) { \
+ PRINTERR("Cannot find function <%s>, terminate!", #_name); \
+ exit(1); \
+ } \
+ \
+ pd.caller = 0; \
+ pd.call_type = 0; \
+ pd.orig = 0; \
+ pd.func = func; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
DEF_H(_ret, _name, __VA_ARGS__)
-#define HANDLER_WRAPPERS_THROW(_feat, _ret, _name, _throw, ...) \
-DEF_H(_ret, _name, __VA_ARGS__) throw _throw; \
- \
-DEF_W(_ret, _name, __VA_ARGS__) throw _throw \
-{ \
- unsigned long caller; \
- ElfW(Addr) orig; \
- \
- caller = (unsigned long) \
- (__builtin_extract_return_addr(__builtin_return_address(0)));\
- orig = GET_ORIG_FUNC(_feat, _name); \
- return CONCAT(_name, _handler)(orig, INTERNAL_CALL, (uint64_t)caller \
- FUNC_CALL(__VA_ARGS__)); \
-} \
- \
-DEF_WA(_ret, _name, __VA_ARGS__) throw _throw \
-{ \
- unsigned long caller; \
- ElfW(Addr) orig; \
- \
- caller = (unsigned long) \
- (__builtin_extract_return_addr(__builtin_return_address(0)));\
- orig = GET_ORIG_FUNC(_feat ## _always, _name); \
- return CONCAT(_name, _handler)(orig, EXTERNAL_CALL, (uint64_t)caller \
- FUNC_CALL(__VA_ARGS__)); \
-} \
+#define HANDLER_WRAPPERS_THROW(_feat, _ret, _name, _throw, ...) \
+DEF_H(_ret, _name, __VA_ARGS__) throw _throw; \
+ \
+DEF_W(_ret, _name, __VA_ARGS__) throw _throw \
+{ \
+ unsigned long caller; \
+ ElfW(Addr) orig; \
+ struct probe_data_t pd; \
+ \
+ caller = (unsigned long) \
+ (__builtin_extract_return_addr(__builtin_return_address(0))); \
+ orig = GET_ORIG_FUNC(_feat, _name); \
+ \
+ pd.caller = (uint64_t)caller; \
+ pd.call_type = INTERNAL_CALL; \
+ pd.orig = orig; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ return CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
+DEF_WA(_ret, _name, __VA_ARGS__) throw _throw \
+{ \
+ unsigned long caller; \
+ ElfW(Addr) orig; \
+ struct probe_data_t pd; \
+ \
+ caller = (unsigned long) \
+ (__builtin_extract_return_addr(__builtin_return_address(0))); \
+ orig = GET_ORIG_FUNC(_feat ## _always, _name); \
+ \
+ pd.caller = (uint64_t)caller; \
+ pd.call_type = EXTERNAL_CALL; \
+ pd.orig = orig; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ return CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
+/* Wrapper to be called from kernel. Takes ret type, func name and args */ \
+DEF_WKC(_ret, _name, __VA_ARGS__) throw _throw \
+{ \
+ struct probe_data_t pd; \
+ void *func; \
+ \
+ func = dlsym(RTLD_NEXT, #_name); \
+ if (func == NULL || dlerror() != NULL) { \
+ PRINTERR("Cannot find function <%s>, terminate!", #_name); \
+ exit(1); \
+ } \
+ \
+ pd.caller = 0; \
+ pd.call_type = 0; \
+ pd.orig = 0; \
+ pd.func = func; \
+ \
+ /* It is important not to have comma before FUNC_CALL macro */ \
+ return CONCAT(_name, _handler)(&pd FUNC_CALL(__VA_ARGS__)); \
+} \
+ \
DEF_H(_ret, _name, __VA_ARGS__) throw _throw
-#define HANDLER_WRAPPERS_DEF(_feat, _ret, _name, ...) \
-_ret PROBE_NAME(_name)(FUNC_DECL(__VA_ARGS__)); \
-_ret CONCAT(PROBE_NAME(_name), _always)(FUNC_DECL(__VA_ARGS__))
+#define HANDLER_WRAPPERS_DEF(_feat, _ret, _name, ...) \
+_ret PROBE_NAME(_name)(FUNC_DECL(__VA_ARGS__)); \
+_ret CONCAT(PROBE_NAME(_name), _always)(FUNC_DECL(__VA_ARGS__)); \
+_ret CONCAT(PROBE_NAME(_name), _kernel_call)(FUNC_DECL(__VA_ARGS__))
+
+
+#define CREATE_GENERIC_PROBE_DATA(CALLER, CALL_TYPE, ORIG) \
+ struct probe_data_t _pd; \
+ struct probe_data_t *probe_data; \
+ \
+ _pd.caller = CALLER; \
+ _pd.call_type = CALL_TYPE; \
+ _pd.orig = ORIG; \
+ probe_data = &_pd;
#define PACK_COMMON_BEGIN(msg_id, api_id, fmt, ...) \
RET_PTR = BUF_PTR; \
} while (0)
-#define PACK_COMMON_END(ret_type, ret, errn, intern_call, caller) \
- do { /* PACK_COMMON_END */ \
- /* return val */ \
- BUF_PTR = pack_ret(RET_PTR, ret_type, (uintptr_t)ret); \
- /* errno */ \
- BUF_PTR = pack_int64(BUF_PTR, (uint64_t)errn); \
- if (caller == 0) /* When calling handler from kernel */ \
- CALL_TYPE_PTR = BUF_PTR; \
- /* internal call*/ \
- BUF_PTR = pack_int32(BUF_PTR, (uint32_t)intern_call); \
- if (caller == 0) /* When calling handler from kernel */ \
- CALLER_PTR = BUF_PTR; \
- /* caller addr */ \
- BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)caller); \
- /* original func addr */ \
- BUF_PTR = pack_int64(BUF_PTR, orig); \
+#define PACK_COMMON_END(ret_type, ret, errn, pd) \
+ do { /* PACK_COMMON_END */ \
+ /* return val */ \
+ BUF_PTR = pack_ret(RET_PTR, ret_type, (uintptr_t)ret); \
+ /* errno */ \
+ BUF_PTR = pack_int64(BUF_PTR, (uint64_t)errn); \
+ /* When calling handler from kernel */ \
+ if (PROBE_GET_CALLER(pd) == 0) \
+ CALL_TYPE_PTR = BUF_PTR; \
+ /* internal call*/ \
+ BUF_PTR = pack_int32(BUF_PTR, \
+ (uint32_t)PROBE_GET_CALL_TYPE(pd)); \
+ /* When calling handler from kernel */ \
+ if (PROBE_GET_CALLER(pd) == 0) \
+ CALLER_PTR = BUF_PTR; \
+ /* caller addr */ \
+ BUF_PTR = pack_int64(BUF_PTR, (uintptr_t)PROBE_GET_CALLER(pd));\
+ /* original func addr */ \
+ BUF_PTR = pack_int64(BUF_PTR, PROBE_GET_ORIG(pd)); \
} while (0)
-#define PACK_COMMON_END_THOUGH(ret_type, ret, errn, intern_call, caller)\
+#define PACK_COMMON_END_THOUGH(ret_type, ret, errn, pd) \
do { /* PACK_COMMON_END */ \
/* return val */ \
BUF_PTR = pack_ret(RET_PTR, ret_type, (uintptr_t)ret); \
} while (0)
-#define BEFORE_GL_ORIG(FUNCNAME, LIB_NAME) \
- DECLARE_VARIABLE_STANDARD_NORET; \
- GLenum error = GL_NO_ERROR; \
- methodType FUNCNAME ## p = (methodType) orig; \
- int32_t vAPI_ID = API_ID_ ## FUNCNAME; \
- uint64_t start_nsec = 0; \
- PRE_PROBEBLOCK(); \
- if (blockresult != 0) \
+#define BEFORE_GL_ORIG(FUNCNAME, LIB_NAME) \
+ DECLARE_VARIABLE_STANDARD_NORET; \
+ GLenum error = GL_NO_ERROR; \
+ methodType FUNCNAME ## p = (methodType)PROBE_GET_FUNC(probe_data); \
+ int32_t vAPI_ID = API_ID_ ## FUNCNAME; \
+ uint64_t start_nsec = 0; \
+ PRE_PROBEBLOCK(); \
+ if (blockresult != 0) \
start_nsec = get_current_nsec();
#define BEFORE_GL2_ORIG(FUNCNAME) /* BEFORE_GL2_ORIG */ \
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RET_TYPE, RET_VAL, error, call_type, caller); \
+ PACK_COMMON_END(RET_TYPE, RET_VAL, error, probe_data); \
PACK_GL_ADD(APITYPE, get_current_nsec() - start_nsec, CONTEXT_VAL); \
FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
/* AFTER */ \
/* TODO Support call type ! */ \
POST_PACK_PROBEBLOCK_BEGIN(); \
- PREPARE_LOCAL_BUF(); \
GET_CALLER_ADDRESS; \
+ CREATE_GENERIC_PROBE_DATA(caller, INTERNAL_CALL, orig); \
+ PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RET_TYPE, RET_VAL, error, INTERNAL_CALL, caller); \
+ PACK_COMMON_END(RET_TYPE, RET_VAL, error, probe_data); \
PACK_GL_ADD(APITYPE, get_current_nsec() - start_nsec, CONTEXT_VAL); \
FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RET_TYPE, RET_VAL, error, call_type, caller); \
+ PACK_COMMON_END(RET_TYPE, RET_VAL, error, probe_data); \
PACK_GL_SHADER(APITYPE, get_current_nsec() - start_nsec, CONTEXT_VAL, \
CONTEXT_SIZE); \
FLUSH_LOCAL_BUF(); \
CONTEXT_SIZE, INPUTFORMAT, ...) \
/* TODO Support call type ! */ \
POST_PACK_PROBEBLOCK_BEGIN(); \
- PREPARE_LOCAL_BUF(); \
GET_CALLER_ADDRESS; \
+ CREATE_GENERIC_PROBE_DATA(caller, INTERNAL_CALL, orig); \
+ PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RET_TYPE, RET_VAL, error, INTERNAL_CALL, caller); \
+ PACK_COMMON_END(RET_TYPE, RET_VAL, error, probe_data); \
PACK_GL_SHADER(APITYPE, get_current_nsec() - start_nsec, CONTEXT_VAL, \
CONTEXT_SIZE); \
FLUSH_LOCAL_BUF(); \
#define BEFORE_EVAS_GL(FUNCNAME) \
DECLARE_VARIABLE_STANDARD_NORET; \
GLenum error = GL_NO_ERROR; \
- methodType FUNCNAME ## p = (void *)orig; \
+ methodType FUNCNAME ## p = (void *)PROBE_GET_FUNC(probe_data); \
int32_t vAPI_ID = API_ID_ ## FUNCNAME; \
uint64_t start_nsec = 0; \
PRE_PROBEBLOCK(); \
/* =========================== post block macro =========================== */
-#define POST_PROBEBLOCK_BEGIN(LCTYPE, RETTYPE, RETVALUE, CALL_TYPE, CALLER, \
- INPUTFORMAT, ...) \
- newerrno = errno; \
- do { \
- PREPARE_LOCAL_BUF(); \
- PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, \
- __VA_ARGS__); \
- PACK_COMMON_END(RETTYPE, RETVALUE, errno, CALL_TYPE, CALLER);
+#define POST_PROBEBLOCK_BEGIN(LCTYPE, RETTYPE, RETVALUE, PROBE_DATA, \
+ INPUTFORMAT, ...) \
+ newerrno = errno; \
+ do { \
+ PREPARE_LOCAL_BUF(); \
+ PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, \
+ __VA_ARGS__); \
+ PACK_COMMON_END(RETTYPE, RETVALUE, errno, PROBE_DATA);
#define POST_PROBEBLOCK_END() \
FLUSH_LOCAL_BUF(); \
#define PACK_ORIGINAL_APPFWCYCLE(API_ID, RTYPE, RVAL, INPUTFORMAT, ...) \
newerrno = errno; \
do { \
+ CREATE_GENERIC_PROBE_DATA((uint64_t)0xffffffff, blockresult, orig);\
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_LIFECYCLE, API_ID, INPUTFORMAT, __VA_ARGS__); \
/* TODO Check address */ \
/* Always feature */ \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, blockresult, (uint64_t)0xffffffff); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
FLUSH_LOCAL_BUF(); \
} while(0); \
errno = (newerrno != 0) ? newerrno : olderrno
void on_orientation_changed(int angle, bool capi)
{
if (isOptionEnabled(OPT_EVENT)) {
- ElfW(Addr) orig = 0;
-
inc_current_event_index();
+ CREATE_GENERIC_PROBE_DATA((uint64_t)0xffffffff, 0, 0);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT,
API_ID_on_orientation_changed,
"dd", angle, (uint32_t)capi);
/* TODO Check wether caller address is really unused here */
/* Always feature */
- PACK_COMMON_END('v', 0, 0, 0, (uint64_t)0xffffffff);
+ PACK_COMMON_END('v', 0, 0, probe_data);
PACK_UIEVENT(_EVENT_ORIENTATION, 0, 0, 0, "",
convert_angle(angle));
FLUSH_LOCAL_BUF();
{
struct __elm_gesture_layer_cb_set_data *d = data;
Evas_Event_Flags res;
- ElfW(Addr) orig = 0;
res = d->cb(d->data, event_info);
inc_current_event_index();
+ CREATE_GENERIC_PROBE_DATA((uint64_t)0xffffffff, 0, 0);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID___common_elm_gesture_layer_cb, "p", CALLER_ADDRESS);
/* Always feature */
- PACK_COMMON_END('d', res, 0, 0, (uint64_t)0xffffffff);
+ PACK_COMMON_END('d', res, 0, probe_data);
PACK_UIEVENT_HEAD(__get_event_type_code(d->idx), d->cb_type);
BUF_PTR = __pack_callback_data(BUF_PTR, data, event_info);
do { \
char info1_str[16]; \
inc_current_event_index(); \
+ CREATE_GENERIC_PROBE_DATA((uint64_t)0xffffffff, 0, orig); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "p", voidp_to_uint64(_ARGDETECTOR)); \
/* TODO Check if address is really unused here */ \
/* Always feature */ \
- PACK_COMMON_END('v', 0, 0, 0, (uint64_t)0xffffffff); \
+ PACK_COMMON_END('v', 0, 0, probe_data); \
sprintf(info1_str, "%d", _INFO1); \
PACK_UIEVENT(_EVENT_GESTURE, _GESTURETYPE, _X, _Y, info1_str, _INFO2); \
FLUSH_LOCAL_BUF(); \
#define PACK_HW_EVENT(API_ID, _EVENTTYPE, _DETAILTYPE, _X, _Y, _KEYCODE, _EXTRA, \
_ARGDATA, _ARGTYPE, _ARGEVENT) \
do { \
- ElfW(Addr) orig = 0; \
+ CREATE_GENERIC_PROBE_DATA((uint64_t)0xffffffff, 0, 0); \
inc_current_event_index(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, API_ID, "pdp", \
voidp_to_uint64(_ARGDATA), _ARGTYPE, \
voidp_to_uint64(_ARGEVENT)); \
/* TODO Check if address is really unused here */ \
- PACK_COMMON_END('c', 0, 0, 0, (uint64_t)0xffffffff); \
+ PACK_COMMON_END('c', 0, 0, probe_data); \
PACK_UIEVENT(_EVENTTYPE, _DETAILTYPE, _X, _Y, _KEYCODE, _EXTRA); \
FLUSH_LOCAL_BUF(); \
} while (0)
} else if (stat_regular_or_socket_p(&_statbuf)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, FD, APITYPE); \
} \
POST_PACK_PROBEBLOCK_END(); \
} else if (stat_regular_or_socket_p(&_statbuf)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, FD, APITYPE); \
} \
POST_PACK_PROBEBLOCK_ADD_END(); \
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE); \
POST_PACK_PROBEBLOCK_END(); \
} while(0)
} \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \
POST_PACK_PROBEBLOCK_END(); \
} while(0)
DEFINE_FILESIZE_FD(fd); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, 0, 0, call_type, caller); \
+ PACK_COMMON_END(RTYPE, 0, 0, probe_data); \
PACK_RESOURCE(0, FD, APITYPE, _filesize, _filepath); \
FLUSH_LOCAL_BUF(); \
} \
} else if (stat_regular_or_socket_p(&_statbuf)) { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
PACK_RESOURCE(SIZE, FD, APITYPE, _filesize, _filepath); \
FLUSH_LOCAL_BUF(); \
} \
DEFINE_FILESIZE_0(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, 0, 0, call_type, caller); \
+ PACK_COMMON_END(RTYPE, 0, 0, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_NOFD(0, APITYPE); \
PRE_PROBEBLOCK_END()
} \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, 0, 0, call_type, caller); \
+ PACK_COMMON_END(RTYPE, 0, 0, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, APITYPE); \
PRE_PROBEBLOCK_END()
inc_current_event_index(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_NOFD(SIZE, APITYPE); \
POST_PACK_PROBEBLOCK_END(); \
} while(0)
} \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, newerrno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, newerrno, probe_data); \
POST_PACK_PROBEBLOCK_MIDDLE_FD(SIZE, _fd, APITYPE); \
POST_PACK_PROBEBLOCK_END(); \
} while(0)
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, open);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, oflag);
- ret = open_handler(orig, INTERNAL_CALL, caller, path, oflag,
- args);
+ ret = open_handler(&pd, path, oflag, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, open);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, oflag);
- ret = open_handler(orig, EXTERNAL_CALL, caller, path,
- oflag, args);
+ ret = open_handler(&pd, path, oflag, args);
va_end(args);
return ret;
BEFORE_ORIGINAL_FILE(open, LIBC);
- openp = (void *)orig;
+ openp = (void *)PROBE_GET_FUNC(probe_data);
if(oflag & O_CREAT)
mode = va_arg(args, int);
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, openat);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, oflag);
- ret = openat_handler(orig, INTERNAL_CALL, caller, fd, path,
- oflag, args);
+ ret = openat_handler(&pd, fd, path, oflag, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, openat);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, oflag);
- ret = openat_handler(orig, EXTERNAL_CALL, caller, fd,
- path, oflag, args);
+ ret = openat_handler(&pd, fd, path, oflag, args);
va_end(args);
return ret;
BEFORE_ORIGINAL_FILE(openat, LIBC);
- openatp = (void *)orig;
+ openatp = (void *)PROBE_GET_FUNC(probe_data);
if(oflag & O_CREAT)
mode = va_arg(args, int);
BEFORE_ORIGINAL_FILE(creat, LIBC);
- creatp = (void *)orig;
+ creatp = (void *)PROBE_GET_FUNC(probe_data);
ret = creatp(path, mode);
DECLARE_VARIABLE_FD;
// GET_REAL_FUNC(close, LIBC);
- closep = (void *)orig;
+ closep = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
_fstatret = fstat(fd, &_statbuf);
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_close,
"d", fd);
- PACK_COMMON_END('d', ret, newerrno, call_type, caller);
+ PACK_COMMON_END('d', ret, newerrno, probe_data);
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, fd, FD_API_CLOSE);
POST_PACK_PROBEBLOCK_END();
off_t offret;
BEFORE_ORIGINAL_FILE(lseek, LIBC);
- lseekp = (void *)orig;
+ lseekp = (void *)PROBE_GET_FUNC(probe_data);
offret = lseekp(fd, offset, whence);
int (*fsyncp)(int fd);
BEFORE_ORIGINAL_FILE(fsync, LIBC);
- fsyncp = (void *)orig;
+ fsyncp = (void *)PROBE_GET_FUNC(probe_data);
ret = fsyncp(fd);
int (*fdatasyncp)(int fd);
BEFORE_ORIGINAL_FILE(fdatasync, LIBC);
- fdatasyncp = (void *)orig;
+ fdatasyncp = (void *)PROBE_GET_FUNC(probe_data);
ret = fdatasyncp(fd);
int (*ftruncatep)(int fd, off_t length);
BEFORE_ORIGINAL_FILE(ftruncate, LIBC);
- ftruncatep = (void *)orig;
+ ftruncatep = (void *)PROBE_GET_FUNC(probe_data);
ret = ftruncatep(fd, length);
int (*fchownp)(int fd, uid_t owner, gid_t group);
BEFORE_ORIGINAL_FILE(fchown, LIBC);
- fchownp = (void *)orig;
+ fchownp = (void *)PROBE_GET_FUNC(probe_data);
ret = fchownp(fd, owner, group);
AFTER_PACK_ORIGINAL_FD(API_ID_fchown, 'd', ret, 0, fd, FD_API_PERMISSION,
int api_type = FD_API_PERMISSION;
BEFORE_ORIGINAL_FILE(lockf, LIBC);
- lockfp = (void *)orig;
+ lockfp = (void *)PROBE_GET_FUNC(probe_data);
ret = lockfp(fd, function, size);
switch (function) {
int (*fchmodp)(int fd, mode_t mode);
BEFORE_ORIGINAL_FILE(fchmod, LIBC);
- fchmodp = (void *)orig;
+ fchmodp = (void *)PROBE_GET_FUNC(probe_data);
ret = fchmodp(fd, mode);
AFTER_PACK_ORIGINAL_FD(API_ID_fchmod,
'd', ret, 0, fd, FD_API_PERMISSION,
(uint64_t)(nbyte),
(uint64_t)(offset));
- preadp = (void *)orig;
+ preadp = (void *)PROBE_GET_FUNC(probe_data);
sret = preadp(fd, buf, nbyte, offset);
AFTER_ORIGINAL_START_END_FD(API_ID_pread, 'x', sret, (unsigned int)sret, fd,
"dpx", fd, voidp_to_uint64(buf),
(uint64_t)(nbyte));
- readp = (void *)orig;
+ readp = (void *)PROBE_GET_FUNC(probe_data);
sret = readp(fd, buf, nbyte);
(uint64_t)(nbyte),
(uint64_t)(offset));
- pwritep = (void *)orig;
+ pwritep = (void *)PROBE_GET_FUNC(probe_data);
sret = pwritep(fd, buf, nbyte, offset);
BEFORE_ORIGINAL_START_END_FD(API_ID_write, 'x', write, LIBC, fd, FD_API_WRITE_START,
"dpx", fd, voidp_to_uint64(buf),
(uint64_t)(nbyte));
- writep = (void *)orig;
+ writep = (void *)PROBE_GET_FUNC(probe_data);
sret = writep(fd, buf, nbyte);
BEFORE_ORIGINAL_START_END_FD(API_ID_readv, 'x', readv, LIBC, fd, FD_API_READ_START,
"dpd", fd, voidp_to_uint64(iov), iovcnt);
- readvp = (void *)orig;
+ readvp = (void *)PROBE_GET_FUNC(probe_data);
sret = readvp(fd,iov,iovcnt);
AFTER_ORIGINAL_START_END_FD(API_ID_readv, 'x', sret, (unsigned int)sret, fd,
MAKE_RESOURCE_PREBLOCK(writev, LIBC,3,VT_INT,fd,VT_PTR,iov,VT_INT,iovcnt);
ssize_t ret;
- writevp = (void *)orig;
+ writevp = (void *)PROBE_GET_FUNC(probe_data);
ret = writevp(fd,iov,iovcnt);
MAKE_RESOURCE_POSTBLOCK(VT_SSIZE_T,ret,VT_SSIZE_T,ret,VT_INT,fd, FD_API_WRITE);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, fcntl);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, cmd);
- ret = fcntl_handler(orig, INTERNAL_CALL, caller, fd, cmd, args);
+ ret = fcntl_handler(&pd, fd, cmd, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, fcntl);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, cmd);
- ret = fcntl_handler(orig, EXTERNAL_CALL, caller, fd,
- cmd, args);
+ ret = fcntl_handler(&pd, fd, cmd, args);
va_end(args);
return ret;
int whence = 0;
BEFORE_ORIGINAL_FILE(fcntl, LIBC);
- fcntlp = (void *)orig;
+ fcntlp = (void *)PROBE_GET_FUNC(probe_data);
arg = va_arg(args, long);
int (*dupp)(int fd);
BEFORE_ORIGINAL_FILE(dup, LIBC);
- dupp = (void *)orig;
+ dupp = (void *)PROBE_GET_FUNC(probe_data);
ret = dupp(fd);
AFTER_PACK_ORIGINAL_FD(API_ID_dup,
int (*dup2p)(int fd, int fd2);
BEFORE_ORIGINAL_FILE(dup2, LIBC);
- dup2p = (void *)orig;
+ dup2p = (void *)PROBE_GET_FUNC(probe_data);
ret = dup2p(fd, fd2);
AFTER_PACK_ORIGINAL_FD(API_ID_dup2,
int (*fstatp)(int fd, struct stat *buf);
BEFORE_ORIGINAL_FILE(fstat, LIBC);
- fstatp = (void *)orig;
+ fstatp = (void *)PROBE_GET_FUNC(probe_data);
ret = fstatp(fd, buf);
AFTER_PACK_ORIGINAL_FD(ret, 0, fd, FD_API_OTHER, "dp", fd,
voidp_to_uint64(buf));
int (*futimensp)(int fd, const struct timespec times[2]);
BEFORE_ORIGINAL_FILE(futimens, LIBC);
- futimensp = (void *)orig;
+ futimensp = (void *)PROBE_GET_FUNC(probe_data);
ret = futimensp(fd, times);
AFTER_PACK_ORIGINAL_FD(API_ID_futimens,
'd', ret, 0, fd, FD_API_OTHER, "dp", fd,
FILE* fret;
BEFORE_ORIGINAL_FILE(fopen, LIBC);
- fopenp = (void *)orig;
+ fopenp = (void *)PROBE_GET_FUNC(probe_data);
fret = fopenp(filename, mode);
_filepath = get_abs_path(fret, filename, buffer, PATH_MAX);
FILE* fret;
BEFORE_ORIGINAL_FILE(freopen, LIBC);
- freopenp = (void *)orig;
+ freopenp = (void *)PROBE_GET_FUNC(probe_data);
fret = freopenp(filename, mode, stream);
_filepath = get_abs_path(fret, filename, buffer, PATH_MAX);
FILE* fret;
BEFORE_ORIGINAL_FILE(fdopen, LIBC);
- fdopenp = (void *)orig;
+ fdopenp = (void *)PROBE_GET_FUNC(probe_data);
fret = fdopenp(fildes, mode);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fdopen,
int (*fflushp)(FILE* stream);
BEFORE_ORIGINAL_FILE(fflush, LIBC);
- fflushp = (void *)orig;
+ fflushp = (void *)PROBE_GET_FUNC(probe_data);
ret = fflushp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fflush,
'd', ret, 0, stream, FD_API_OTHER, "p",
DECLARE_VARIABLE_FD;
// GET_REAL_FUNC(fclose, LIBC);
- fclosep = (void *)orig;
+ fclosep = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
GET_FD_FROM_FILEP(stream);
PACK_COMMON_BEGIN(MSG_PROBE_RESOURCE,
API_ID_fclose,
"p", voidp_to_uint64(stream));
- PACK_COMMON_END('d', ret, newerrno, call_type, caller);
+ PACK_COMMON_END('d', ret, newerrno, probe_data);
POST_PACK_PROBEBLOCK_MIDDLE_FD(0, _fd, FD_API_CLOSE);
POST_PACK_PROBEBLOCK_END();
FILE* fret;
BEFORE_ORIGINAL_FILE(tmpfile, LIBC);
- tmpfilep = (void *)orig;
+ tmpfilep = (void *)PROBE_GET_FUNC(probe_data);
_filepath = "<temp file>";
fret = tmpfilep();
AFTER_PACK_ORIGINAL_FILEP(API_ID_tmpfile,
int (*fgetposp)(FILE* stream, fpos_t* position);
BEFORE_ORIGINAL_FILE(fgetpos, LIBC);
- fgetposp = (void *)orig;
+ fgetposp = (void *)PROBE_GET_FUNC(probe_data);
ret = fgetposp(stream, position);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fgetpos,
'd', ret, 0, stream, FD_API_OTHER, "pp",
int (*fseekp)(FILE* stream, long int offset, int origin);
BEFORE_ORIGINAL_FILE(fseek, LIBC);
- fseekp = (void *)orig;
+ fseekp = (void *)PROBE_GET_FUNC(probe_data);
ret = fseekp(stream, offset, origin);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fseek,
'd', ret, (unsigned int)offset, stream, FD_API_OTHER,
int (*fsetposp)(FILE* stream, const fpos_t* pos);
BEFORE_ORIGINAL_FILE(fsetpos, LIBC);
- fsetposp = (void *)orig;
+ fsetposp = (void *)PROBE_GET_FUNC(probe_data);
ret = fsetposp(stream, pos);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fsetpos,
'd', ret, 0, stream, FD_API_OTHER, "pp",
long int lret;
BEFORE_ORIGINAL_FILE(ftell, LIBC);
- ftellp = (void *)orig;
+ ftellp = (void *)PROBE_GET_FUNC(probe_data);
lret = ftellp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_ftell,
void (*rewindp)(FILE* stream);
BEFORE_ORIGINAL_FILE(rewind, LIBC);
- rewindp = (void *)orig;
+ rewindp = (void *)PROBE_GET_FUNC(probe_data);
rewindp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_rewind,
void (*clearerrp)(FILE* stream);
BEFORE_ORIGINAL_FILE(clearerr, LIBC);
- clearerrp = (void *)orig;
+ clearerrp = (void *)PROBE_GET_FUNC(probe_data);
clearerrp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_clearerr,
int (*feofp)(FILE* stream);
BEFORE_ORIGINAL_FILE(feof, LIBC);
- feofp = (void *)orig;
+ feofp = (void *)PROBE_GET_FUNC(probe_data);
ret = feofp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_feof,
'd', ret, 0, stream, FD_API_OTHER, "p",
int (*ferrorp)(FILE* stream);
BEFORE_ORIGINAL_FILE(ferror, LIBC);
- ferrorp = (void *)orig;
+ ferrorp = (void *)PROBE_GET_FUNC(probe_data);
ret = ferrorp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_ferror,
'd', ret, 0, stream, FD_API_OTHER, "p",
int (*filenop)(FILE* stream);
BEFORE_ORIGINAL_FILE(fileno, LIBC);
- filenop = (void *)orig;
+ filenop = (void *)PROBE_GET_FUNC(probe_data);
ret = filenop(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_fileno,
'd', ret, 0, stream, FD_API_OTHER, "p",
BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfprintf, 'd', vfprintf, LIBC, stream,
FD_API_WRITE_START, "ps",
voidp_to_uint64(stream), format);
- vfprintfp = (void *)orig;
+ vfprintfp = (void *)PROBE_GET_FUNC(probe_data);
ret = vfprintfp(stream, format, arg);
AFTER_ORIGINAL_START_END_FILEP(API_ID_vfprintf, 'd', ret, ret, stream,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_vfscanf, 'd', vfscanf, LIBC, stream,
FD_API_READ_START, "ps",
voidp_to_uint64(stream), format);
- vfscanfp = (void *)orig;
+ vfscanfp = (void *)PROBE_GET_FUNC(probe_data);
ret = vfscanfp(stream, format, arg);
AFTER_ORIGINAL_START_END_FILEP(API_ID_vfscanf, 'd', ret, ret, stream,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fgetc, 'd', fgetc, LIBC, stream,
FD_API_READ_START, "p",
voidp_to_uint64(stream));
- fgetcp = (void *)orig;
+ fgetcp = (void *)PROBE_GET_FUNC(probe_data);
ret = fgetcp(stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fgetc, 'd', ret, (ret != EOF), stream,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputc, 'd', fputc, LIBC, stream,
FD_API_WRITE_START, "dp", character,
voidp_to_uint64(stream));
- fputcp = (void *)orig;
+ fputcp = (void *)PROBE_GET_FUNC(probe_data);
ret = fputcp(character, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fputc, 'd', ret, (ret == EOF ? 0 : 1),
BEFORE_ORIGINAL_START_END_FILEP(API_ID_fputs, 'd', fputs, LIBC, stream,
FD_API_WRITE_START, "sp", str,
voidp_to_uint64(stream));
- fputsp = (void *)orig;
+ fputsp = (void *)PROBE_GET_FUNC(probe_data);
ret = fputsp(str, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fputs, 'd', ret, ret, stream,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', getc, LIBC, stream,
FD_API_READ_START, "p",
voidp_to_uint64(stream));
- getcp = (void *)orig;
+ getcp = (void *)PROBE_GET_FUNC(probe_data);
ret = getcp(stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', ret, (ret == EOF ? 0 : 1), stream,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', _IO_getc, LIBC, stream,
FD_API_READ_START, "p",
voidp_to_uint64(stream));
- getcp = (void *)orig;
+ getcp = (void *)PROBE_GET_FUNC(probe_data);
ret = getcp(stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_getc, 'd', ret,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', putc, LIBC, stream,
FD_API_WRITE_START, "dp", character,
voidp_to_uint64(stream));
- putcp = (void *)orig;
+ putcp = (void *)PROBE_GET_FUNC(probe_data);
ret = putcp(character, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', ret, (ret == EOF ? 0 : 1),
BEFORE_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', _IO_putc, LIBC, stream,
FD_API_WRITE_START, "dp", character,
voidp_to_uint64(stream));
- _IO_putcp = (void *)orig;
+ _IO_putcp = (void *)PROBE_GET_FUNC(probe_data);
ret = _IO_putcp(character, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_putc, 'd', ret,
BEFORE_ORIGINAL_START_END_FILEP(API_ID_ungetc, 'd', ungetc, LIBC, stream,
FD_API_WRITE_START, "dp", character,
voidp_to_uint64(stream));
- ungetcp = (void *)orig;
+ ungetcp = (void *)PROBE_GET_FUNC(probe_data);
ret = ungetcp(character, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_ungetc, 'd', ret, 0, stream,
(uint64_t)(count),
voidp_to_uint64(stream));
- freadp = (void *)orig;
+ freadp = (void *)PROBE_GET_FUNC(probe_data);
tret = freadp(ptr, size, count, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fread, 'x', tret, tret*size, stream,
(uint64_t)(count),
voidp_to_uint64(stream));
- fwritep = (void *)orig;
+ fwritep = (void *)PROBE_GET_FUNC(probe_data);
tret = fwritep(ptr, size, count, stream);
AFTER_ORIGINAL_START_END_FILEP(API_ID_fwrite, 'x', tret, tret*size, stream,
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, fprintf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = fprintf_handler(orig, INTERNAL_CALL, caller, stream,
- format, args);
+ ret = fprintf_handler(&pd, stream, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, fprintf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = fprintf_handler(orig, EXTERNAL_CALL, caller,
- stream, format, args);
+ ret = fprintf_handler(&pd, stream, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, fscanf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = fscanf_handler(orig, INTERNAL_CALL, caller, stream,
- format, args);
+ ret = fscanf_handler(&pd, stream, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, fscanf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = fscanf_handler(orig, EXTERNAL_CALL, caller,
- stream, format, args);
+ ret = fscanf_handler(&pd, stream, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, printf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = printf_handler(orig, INTERNAL_CALL, caller, format, args);
+ ret = printf_handler(&pd, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, printf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = printf_handler(orig, EXTERNAL_CALL, caller,
- format, args);
+ ret = printf_handler(&pd, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, scanf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = INTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = scanf_handler(orig, INTERNAL_CALL, caller, format, args);
+ ret = scanf_handler(&pd, format, args);
va_end(args);
return ret;
unsigned long caller;
ElfW(Addr) orig;
va_list args;
+ struct probe_data_t pd;
int ret;
caller = (unsigned long)
(__builtin_extract_return_addr(__builtin_return_address(0)));
orig = GET_ORIG_FUNC(file_feature, scanf);
+ pd.caller = (uint64_t)caller;
+ pd.call_type = EXTERNAL_CALL;
+ pd.orig = orig;
+
va_start(args, format);
- ret = scanf_handler(orig, EXTERNAL_CALL, caller, format,
- args);
+ ret = scanf_handler(&pd, format, args);
va_end(args);
return ret;
BEFORE_ORIGINAL_START_END_NOFD(API_ID_getchar, 'd', getchar, LIBC,
FD_API_READ_START, "", 0);
- getcharp = (void *)orig;
+ getcharp = (void *)PROBE_GET_FUNC(probe_data);
ret = getcharp();
AFTER_ORIGINAL_START_END_NOFD(API_ID_getchar, 'd', ret, (ret == EOF ? 0 : 1),
BEFORE_ORIGINAL_START_END_NOFD(API_ID_putchar, 'd', putchar, LIBC,
FD_API_WRITE_START, "d", c);
- putcharp = (void *)orig;
+ putcharp = (void *)PROBE_GET_FUNC(probe_data);
ret = putcharp(c);
AFTER_ORIGINAL_START_END_NOFD(API_ID_putchar, 'd', ret, (ret == EOF ? 0 : 1),
BEFORE_ORIGINAL_START_END_NOFD(API_ID_gets, 'p', gets, LIBC,
FD_API_READ_START, "s", str);
- getsp = (void *)orig;
+ getsp = (void *)PROBE_GET_FUNC(probe_data);
cret = getsp(str);
AFTER_ORIGINAL_START_END_NOFD(API_ID_gets, 'p', cret, strlen(cret),
BEFORE_ORIGINAL_START_END_NOFD(API_ID_puts, 'd', puts, LIBC,
FD_API_WRITE_START, "s", str);
- putsp = (void *)orig;
+ putsp = (void *)PROBE_GET_FUNC(probe_data);
ret = putsp(str);
AFTER_ORIGINAL_START_END_NOFD(API_ID_puts, 'd', ret, ret,
BEFORE_ORIGINAL_FILE(setbuf, LIBC);
- setbufp = (void *)orig;
+ setbufp = (void *)PROBE_GET_FUNC(probe_data);
setbufp(stream, buf);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuf,
BEFORE_ORIGINAL_FILE(setbuffer, LIBC);
- setbufferp = (void *)orig;
+ setbufferp = (void *)PROBE_GET_FUNC(probe_data);
setbufferp(stream, buf, size);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setbuffer,
BEFORE_ORIGINAL_FILE(setlinebuf, LIBC);
- setlinebufp = (void *)orig;
+ setlinebufp = (void *)PROBE_GET_FUNC(probe_data);
setlinebufp(stream);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setlinebuf,
BEFORE_ORIGINAL_FILE(setvbuf, LIBC);
- setvbufp = (void *)orig;
+ setvbufp = (void *)PROBE_GET_FUNC(probe_data);
ret = setvbufp(stream,buf,mode,size);
AFTER_PACK_ORIGINAL_FILEP(API_ID_setvbuf,
'd', ret, size, stream, FD_API_OTHER,
real_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,
&maxVal[1]);
snprintf(maxValString, sizeof(maxValString), "%d,%d", maxVal[0], maxVal[1]);
+ CREATE_GENERIC_PROBE_DATA((uint64_t)0xffffffff, 0, orig);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_GL, vAPI_ID, "", 0);
/* Pack any address, cause this is not an event probe */
- PACK_COMMON_END('p', 1, 0, 0, (uint64_t)0xffffffff);
+ PACK_COMMON_END('p', 1, 0, probe_data);
PACK_GL_ADD(APITYPE_INIT, 0, maxValString);
FLUSH_LOCAL_BUF();
}
lsan_mallocp = lsan_get_sym(lsan_interceptors[MEM_MALLOC]);
/* If LSan is used - call LSan allocator instead of origin */
- mallocp = lsan_init_succeeded ? lsan_mallocp : (void *)orig;
+ mallocp = lsan_init_succeeded ? lsan_mallocp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = (*mallocp)(size);
if(pret != NULL)
- add_memory_hash(pret, size, MEMTYPE_ALLOC, call_type);
+ add_memory_hash(pret, size, MEMTYPE_ALLOC,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_malloc,
"x", (int64_t) size);
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
lsan_freep = lsan_get_sym(lsan_interceptors[MEM_FREE]);
/* If LSan is used - call LSan free instead of origin */
- freep = lsan_init_succeeded ? lsan_freep : (void *)orig;
+ freep = lsan_init_succeeded ? lsan_freep :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_free,
"p", voidp_to_uint64(ptr));
- PACK_COMMON_END('v', 0, newerrno, call_type, caller);
+ PACK_COMMON_END('v', 0, newerrno, probe_data);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
lsan_reallocp = lsan_get_sym(lsan_interceptors[MEM_REALLOC]);
/* If LSan is used - call LSan realloc instead of origin */
- reallocp = lsan_init_succeeded ? lsan_reallocp : (void *)orig;
+ reallocp = lsan_init_succeeded ? lsan_reallocp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
if(memblock != NULL)
pret = (*reallocp)(memblock, size);
if(pret != NULL)
- add_memory_hash(pret, size, MEMTYPE_ALLOC, call_type);
+ add_memory_hash(pret, size, MEMTYPE_ALLOC,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_realloc,
"px", voidp_to_uint64(memblock), (uint64_t) size);
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
lsan_callocp = lsan_get_sym(lsan_interceptors[MEM_CALLOC]);
/* If LSan is used - call LSan calloc instead of origin */
- callocp = lsan_init_succeeded ? lsan_callocp : (void *)orig;
+ callocp = lsan_init_succeeded ? lsan_callocp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = (*callocp)(nelem, elsize);
if(pret != NULL)
- add_memory_hash(pret, nelem * elsize, MEMTYPE_ALLOC, call_type);
+ add_memory_hash(pret, nelem * elsize, MEMTYPE_ALLOC,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_calloc,
"xx", (uint64_t)nelem, (uint64_t)elsize);
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(nelem * elsize, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
lsan_interceptors[MEM_POSIX_MEMALIGN]);
/* If LSan is used - call LSan calloc instead of origin */
- posix_memalignp = lsan_init_succeeded ? lsan_posix_memalignp :
- (void *)orig;
+ posix_memalignp = lsan_init_succeeded ?
+ lsan_posix_memalignp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
iret = (*posix_memalignp)(memptr, alignment, size);
if (iret == 0)
- add_memory_hash(*memptr, size, MEMTYPE_ALLOC, CALL_TYPE);
+ add_memory_hash(*memptr, size, MEMTYPE_ALLOC,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_posix_memalign, "x",
(int64_t)size);
- PACK_COMMON_END('p', *memptr, newerrno, call_type, caller);
+ PACK_COMMON_END('p', *memptr, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, *memptr);
FLUSH_LOCAL_BUF();
lsan_strdupp = lsan_get_sym(lsan_interceptors[MEM_STRDUP]);
/* If LSan is used - call LSan strdup instead of origin */
- strdupp = lsan_init_succeeded ? lsan_strdupp : (void *)orig;
+ strdupp = lsan_init_succeeded ? lsan_strdupp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = (*strdupp)(s);
if (pret == 0)
- add_memory_hash(pret, size, MEMTYPE_ALLOC, CALL_TYPE);
+ add_memory_hash(pret, size, MEMTYPE_ALLOC,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY, API_ID_strdup, "x",
(int64_t)size);
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
void *pret;
// GET_REAL_FUNC_RTLD_NEXT(memset);
- memsetp = (void *)orig;
+ memsetp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
API_ID_memset,
"pdx", voidp_to_uint64(memblock), c,
(uint64_t)(n));
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(n, MEMORY_API_MANAGE, pret);
FLUSH_LOCAL_BUF();
DECLARE_VARIABLE_STANDARD;
// GET_REAL_FUNC_RTLD_NEXT(memcmp);
- memcmpp = (void *)orig;
+ memcmpp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
API_ID_memcmp,
"ppx", voidp_to_uint64(ptr1), voidp_to_uint64(ptr2),
(uint64_t)(num));
- PACK_COMMON_END('d', ret, newerrno, call_type, caller);
+ PACK_COMMON_END('d', ret, newerrno, probe_data);
PACK_MEMORY(num, MEMORY_API_MANAGE, ret);
FLUSH_LOCAL_BUF();
void *pret;
// GET_REAL_FUNC_RTLD_NEXT(memcpy);
- memcpyp = (void *)orig;
+ memcpyp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
"ppx", voidp_to_uint64(destination),
voidp_to_uint64(source),
(uint64_t)(num));
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(num, MEMORY_API_MANAGE, pret);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_newp == NULL) {
lsan_newp = lsan_get_sym(lsan_interceptors[MEM_NEW]);
- newp = lsan_init_succeeded ? lsan_newp : (void*(*)(std::size_t size))orig;
+ newp = lsan_init_succeeded ? lsan_newp :
+ (void*(*)(std::size_t size))PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = newp(size);
if(pret != NULL)
- add_memory_hash(pret, size, MEMTYPE_NEW, (unsigned short)call_type);
+ add_memory_hash(pret, size, MEMTYPE_NEW,
+ (unsigned short)PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new_std__size_t_size__throw__std__bad_alloc_,
"x", (uint64_t)(size));
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_newp == NULL) {
lsan_newp = lsan_get_sym(lsan_interceptors[MEM_NEW_ARRAY]);
- newp = lsan_init_succeeded ? lsan_newp : (void*(*)(std::size_t size))orig;
+ newp = lsan_init_succeeded ? lsan_newp :
+ (void*(*)(std::size_t size))PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = newp(size);
if(pret != NULL)
- add_memory_hash(pret, size, MEMTYPE_NEW, call_type);
+ add_memory_hash(pret, size, MEMTYPE_NEW,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new___std__size_t_size__throw__std__bad_alloc_,
"x", (uint64_t)(size));
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_deletep == NULL) {
lsan_deletep = lsan_get_sym(lsan_interceptors[MEM_DELETE]);
- deletep = lsan_init_succeeded ? lsan_deletep : (void (*)(void *))orig;
+ deletep = lsan_init_succeeded ? lsan_deletep :
+ (void (*)(void *))PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete_void__ptr__throw__,
"p", voidp_to_uint64(ptr));
- PACK_COMMON_END('v', 0, newerrno, call_type, caller);
+ PACK_COMMON_END('v', 0, newerrno, probe_data);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_deletep == NULL) {
lsan_deletep = lsan_get_sym(lsan_interceptors[MEM_DELETE_ARRAY]);
- deletep = lsan_init_succeeded ? lsan_deletep : (void (*)(void *))orig;
+ deletep = lsan_init_succeeded ? lsan_deletep :
+ (void (*)(void *))PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
{
/* TODO call_type rewrited as it was previously. Is it needed? */
ret = del_memory_hash(ptr, MEMTYPE_DELETE, &ct);
- if(blockresult == 0 && ret == 0 && call_type == EXTERNAL_CALL)
+ if(blockresult == 0 && ret == 0 &&
+ PROBE_GET_CALL_TYPE(probe_data) == EXTERNAL_CALL)
{
inc_current_event_index();
blockresult = 2;
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete___void__ptr__throw__,
"p", voidp_to_uint64(ptr));
- PACK_COMMON_END('v', 0, newerrno, call_type, caller);
+ PACK_COMMON_END('v', 0, newerrno, probe_data);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_newp == NULL) {
lsan_newp = lsan_get_sym(lsan_interceptors[MEM_NEW_NOTHROW]);
- newp = lsan_init_succeeded ? lsan_newp : (void*(*)(std::size_t, const std::nothrow_t& ))orig;
+ newp = lsan_init_succeeded ? lsan_newp :
+ (void*(*)(std::size_t, const std::nothrow_t& ))
+ PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = newp(size, nothrow);
if(pret != NULL)
- add_memory_hash(pret, size, MEMTYPE_NEW, (unsigned short)call_type);
+ add_memory_hash(pret, size, MEMTYPE_NEW,
+ (unsigned short)PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new_std__size_t_size__const_std__nothrow_t__nothrow__throw__,
"xp", (uint64_t)(size), voidp_to_uint64(¬hrow));
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_newp == NULL) {
lsan_newp = lsan_get_sym(lsan_interceptors[MEM_NEW_ARRAY_NOTHROW]);
- newp = lsan_init_succeeded ? lsan_newp : (void*(*)(std::size_t, const std::nothrow_t&))orig;
+ newp = lsan_init_succeeded ? lsan_newp :
+ (void*(*)(std::size_t, const std::nothrow_t&))
+ PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
pret = newp(size, nothrow);
if(pret != NULL)
- add_memory_hash(pret, size, MEMTYPE_NEW, call_type);
+ add_memory_hash(pret, size, MEMTYPE_NEW,
+ PROBE_GET_CALL_TYPE(probe_data));
POST_PACK_PROBEBLOCK_BEGIN();
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void__operator_new___std__size_t_size__const_std__nothrow_t__nothrow__throw__,
"xp", (uint64_t)(size), voidp_to_uint64(¬hrow));
- PACK_COMMON_END('p', pret, newerrno, call_type, caller);
+ PACK_COMMON_END('p', pret, newerrno, probe_data);
PACK_MEMORY(size, MEMORY_API_ALLOC, pret);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_deletep == NULL) {
lsan_deletep = lsan_get_sym(lsan_interceptors[MEM_DELETE_NOTHROW]);
- deletep = lsan_init_succeeded ? lsan_deletep : (void (*)(void *, const std::nothrow_t&))orig;
+ deletep = lsan_init_succeeded ? lsan_deletep :
+ (void (*)(void *, const std::nothrow_t&))
+ PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
{
/* TODO call_type rewrited as it was previously. Is it needed? */
ret = del_memory_hash(ptr, MEMTYPE_DELETE, &ct);
- if(blockresult == 0 && ret == 0 && call_type == EXTERNAL_CALL)
+ if(blockresult == 0 && ret == 0 &&
+ PROBE_GET_CALL_TYPE(probe_data) == EXTERNAL_CALL)
{
inc_current_event_index();
blockresult = 2;
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete_void__ptr__const_std__nothrow_t__nothrow__throw__,
"pp", voidp_to_uint64(ptr), voidp_to_uint64(¬hrow));
- PACK_COMMON_END('v', 0, newerrno, call_type, caller);
+ PACK_COMMON_END('v', 0, newerrno, probe_data);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_deletep == NULL) {
lsan_deletep = lsan_get_sym(lsan_interceptors[MEM_DELETE_ARRAY_NOTHROW]);
- deletep = lsan_init_succeeded ? lsan_deletep : (void (*)(void *, const std::nothrow_t&))orig;
+ deletep = lsan_init_succeeded ? lsan_deletep :
+ (void (*)(void *, const std::nothrow_t&))
+ PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
{
/* TODO call_type rewrited as it was previously. Is it needed? */
ret = del_memory_hash(ptr, MEMTYPE_DELETE, &ct);
- if(blockresult == 0 && ret == 0 && call_type == EXTERNAL_CALL)
+ if(blockresult == 0 && ret == 0 &&
+ PROBE_GET_CALL_TYPE(probe_data) == EXTERNAL_CALL)
{
inc_current_event_index();
blockresult = 2;
PACK_COMMON_BEGIN(MSG_PROBE_MEMORY,
API_ID_void_operator_delete___void__ptr__const_std__nothrow_t__nothrow__throw__,
"pp", voidp_to_uint64(ptr), voidp_to_uint64(¬hrow));
- PACK_COMMON_END('v', 0, newerrno, call_type, caller);
+ PACK_COMMON_END('v', 0, newerrno, probe_data);
PACK_MEMORY(0, MEMORY_API_FREE, ptr);
FLUSH_LOCAL_BUF();
PREPARE_LOCAL_BUF_THOUGH(buf);
PACK_COMMON_BEGIN(MSG_PROBE_SCREENSHOT, API_ID_captureScreen, "", 0);
/* Pack any address, cause this is not an event probe */
- PACK_COMMON_END_THOUGH('d', 0, 0, 0, 0xffffffff);
+ PACK_COMMON_END_THOUGH('d', 0, 0, NULL);
return BUF_PTR - LOCAL_BUF;
}
//lib Common Function
#define AFTER_ORIGINAL_LIBC_SOCK(RTYPE, RVAL, OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO, INPUTFORMAT, ...) \
- POST_PROBEBLOCK_BEGIN(LC_SOCKET, RTYPE, RVAL, call_type, caller, INPUTFORMAT, __VA_ARGS__); \
+ POST_PROBEBLOCK_BEGIN(LC_SOCKET, RTYPE, RVAL, probe_data, INPUTFORMAT, __VA_ARGS__); \
POST_PROBEBLOCK_MIDDLE_LIBC_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ); \
POST_PROBEBLOCK_END();
do { \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RTYPE, RETVALUE, errno, call_type, caller)
+ PACK_COMMON_END(RTYPE, RETVALUE, errno, probe_data)
//lib END Function
inc_current_event_index(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_NETWORK, vAPI_ID, INPUTFORMAT, __VA_ARGS__);\
- PACK_COMMON_END(RTYPE, RETVALUE, errno, call_type, caller)
+ PACK_COMMON_END(RTYPE, RETVALUE, errno, probe_data)
#define POST_PROBEBLOCK_MIDDLE_TIZEN_SOCK(OBJECTPTR, FDVALUE, APITYPE, TOTAL_INFO ) \
do { \
info_t info; \
INIT_INFO; \
int32_t __attribute__((unused)) vAPI_ID = API_ID_ ## FUNCNAME; \
- FUNCNAME ## p = (void *)orig; \
+ FUNCNAME ## p = (void *)PROBE_GET_FUNC(probe_data); \
PRE_PROBEBLOCK()
#define BEFORE_ORIGINAL_SYNC(FUNCNAME, LIBNAME) \
DECLARE_VARIABLE_STANDARD; \
- FUNCNAME ## p = (void *)orig; \
+ FUNCNAME ## p = (void *)PROBE_GET_FUNC(probe_data); \
PRE_PROBEBLOCK()
#define AFTER_PACK_ORIGINAL_SYNC(API_ID, RTYPE, RVAL, SYNCVAL, SYNCTYPE, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_SYNC, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, errno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, errno, probe_data); \
PACK_SYNC(SYNCVAL, SYNCTYPE, APITYPE); \
FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
#define BEFORE_ORIGINAL_THREAD(FUNCNAME, LIBNAME) \
DECLARE_VARIABLE_STANDARD; \
- FUNCNAME ## p = (void *)orig; \
+ FUNCNAME ## p = (void *)PROBE_GET_FUNC(probe_data); \
PRE_PROBEBLOCK()
#define AFTER_PACK_ORIGINAL_THREAD(API_ID, RTYPE, RVAL, THREADVAL, APITYPE, INPUTFORMAT, ...) \
POST_PACK_PROBEBLOCK_BEGIN(); \
PREPARE_LOCAL_BUF(); \
PACK_COMMON_BEGIN(MSG_PROBE_THREAD, API_ID, INPUTFORMAT, __VA_ARGS__); \
- PACK_COMMON_END(RTYPE, RVAL, errno, call_type, caller); \
+ PACK_COMMON_END(RTYPE, RVAL, errno, probe_data); \
PACK_THREAD(THREADVAL, THREAD_PTHREAD, APITYPE, THREAD_CLASS_BLANK); \
FLUSH_LOCAL_BUF(); \
POST_PACK_PROBEBLOCK_END()
DECLARE_VARIABLE_STANDARD;
// GET_REAL_FUNC(pthread_mutex_lock, LIBPTHREAD);
- pthread_mutex_lockp = (void *)orig;
+ pthread_mutex_lockp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_lock,
"p", voidp_to_uint64(mutex));
- PACK_COMMON_END('d', 0, 0, call_type, caller);
+ PACK_COMMON_END('d', 0, 0, probe_data);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_SYNC,
API_ID_pthread_mutex_lock,
"p", voidp_to_uint64(mutex));
- PACK_COMMON_END('p', ret, errno, call_type, caller);
+ PACK_COMMON_END('p', ret, errno, probe_data);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
DECLARE_VARIABLE_STANDARD;
// GET_REAL_FUNC(pthread_mutex_timedlock, LIBPTHREAD);
- pthread_mutex_timedlockp = (void *)orig;
+ pthread_mutex_timedlockp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
API_ID_pthread_mutex_timedlock,
"pp", voidp_to_uint64(mutex),
voidp_to_uint64(abs_timeout));
- PACK_COMMON_END('d', 0, 0, call_type, caller);
+ PACK_COMMON_END('d', 0, 0, probe_data);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_START);
FLUSH_LOCAL_BUF();
API_ID_pthread_mutex_timedlock,
"pp", voidp_to_uint64(mutex),
voidp_to_uint64(abs_timeout));
- PACK_COMMON_END('d', ret, errno, call_type, caller);
+ PACK_COMMON_END('d', ret, errno, probe_data);
PACK_SYNC(mutex, SYNC_PTHREAD_MUTEX, SYNC_API_ACQUIRE_WAIT_END);
FLUSH_LOCAL_BUF();
DECLARE_VARIABLE_STANDARD;
// GET_REAL_FUNC(pthread_cond_wait, LIBPTHREAD);
- pthread_cond_waitp = (void *)orig;
+ pthread_cond_waitp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
"pp",
voidp_to_uint64(cond),
voidp_to_uint64(mutex));
- PACK_COMMON_END('d', 0, 0, call_type, caller);
+ PACK_COMMON_END('d', 0, 0, probe_data);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
"pp",
voidp_to_uint64(cond),
voidp_to_uint64(mutex));
- PACK_COMMON_END('d', ret, errno, call_type, caller);
+ PACK_COMMON_END('d', ret, errno, probe_data);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
DECLARE_VARIABLE_STANDARD;
// GET_REAL_FUNC(pthread_cond_timedwait, LIBPTHREAD);
- pthread_cond_timedwaitp = (void *)orig;
+ pthread_cond_timedwaitp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
// send WAIT_START log
voidp_to_uint64(cond),
voidp_to_uint64(mutex),
voidp_to_uint64(abstime));
- PACK_COMMON_END('d', 0, 0, call_type, caller);
+ PACK_COMMON_END('d', 0, 0, probe_data);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_START);
FLUSH_LOCAL_BUF();
voidp_to_uint64(cond),
voidp_to_uint64(mutex),
voidp_to_uint64(abstime));
- PACK_COMMON_END('d', ret, errno, call_type, caller);
+ PACK_COMMON_END('d', ret, errno, probe_data);
PACK_SYNC(cond, SYNC_PTHREAD_COND_VARIABLE, SYNC_API_COND_WAIT_END);
FLUSH_LOCAL_BUF();
if (lsan_init_succeeded && lsan_pthread_createp == NULL)
lsan_pthread_createp = lsan_get_sym(lsan_pthread_create);
- pthread_createp = lsan_init_succeeded ? lsan_pthread_createp : (void *)orig;
+ pthread_createp = lsan_init_succeeded ? lsan_pthread_createp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK();
lsan_pthread_joinp = lsan_get_sym(lsan_pthread_join);
// GET_REAL_FUNC(pthread_join, LIBPTHREAD);
- pthread_joinp = lsan_init_succeeded ? lsan_pthread_joinp : (void *)orig;
+ pthread_joinp = lsan_init_succeeded ? lsan_pthread_joinp :
+ (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_join,
"xp", (uint64_t)(thread), voidp_to_uint64(retval));
- PACK_COMMON_END('d', 0, 0, call_type, caller);
+ PACK_COMMON_END('d', 0, 0, probe_data);
PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_START, THREAD_CLASS_BLANK);
FLUSH_LOCAL_BUF();
"xp",
(uint64_t)(thread),
voidp_to_uint64(retval));
- PACK_COMMON_END('d', ret, errno, call_type, caller);
+ PACK_COMMON_END('d', ret, errno, probe_data);
PACK_THREAD(thread, THREAD_PTHREAD, THREAD_API_WAIT_END, THREAD_CLASS_BLANK);
FLUSH_LOCAL_BUF();
DECLARE_VARIABLE_STANDARD;
// GET_REAL_FUNC(pthread_exit, LIBPTHREAD);
- pthread_exitp = (void *)orig;
+ pthread_exitp = (void *)PROBE_GET_FUNC(probe_data);
PRE_PROBEBLOCK_BEGIN();
newerrno = errno;
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID_pthread_exit,
"p", voidp_to_uint64(retval));
- PACK_COMMON_END('v', 0, 0, call_type, caller);
+ PACK_COMMON_END('v', 0, 0, probe_data);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_EXIT, THREAD_CLASS_BLANK);
FLUSH_LOCAL_BUF();
pSelf = pthread_self();
+ CREATE_GENERIC_PROBE_DATA(caller, 1, orig);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_cleanup_handler,
"p", voidp_to_uint64(data));
- PACK_COMMON_END('v', 0, 0, 1, caller);
+ PACK_COMMON_END('v', 0, 0, probe_data);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP, THREAD_CLASS_BLANK);
FLUSH_LOCAL_BUF();
pSelf = pthread_self();
+ CREATE_GENERIC_PROBE_DATA(caller, 1, orig);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_ThreadProc,
"p", voidp_to_uint64(params));
- PACK_COMMON_END('p', 0, 0, 1, caller);
+ PACK_COMMON_END('p', 0, 0, probe_data);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_START, THREAD_CLASS_BLANK);
FLUSH_LOCAL_BUF();
pSelf = pthread_self();
+ CREATE_GENERIC_PROBE_DATA(caller, 1, orig);
PREPARE_LOCAL_BUF();
PACK_COMMON_BEGIN(MSG_PROBE_THREAD,
API_ID__da_ThreadProc,
"p", voidp_to_uint64(params));
- PACK_COMMON_END('p', ret, 0, 1, caller);
+ PACK_COMMON_END('p', ret, 0, probe_data);
PACK_THREAD(pSelf, THREAD_PTHREAD, THREAD_API_INTERNAL_STOP, THREAD_CLASS_BLANK);
FLUSH_LOCAL_BUF();
projects / platform / core / system / swap-probe.git / commitdiff