From: Mathieu Desnoyers Date: Wed, 13 Apr 2011 19:45:48 +0000 (-0400) Subject: Markers: Namespace cleanup, with API change. X-Git-Tag: v0.13~29 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=b521931e0000388ff9080d46719936be98af54c6;p=ust.git Markers: Namespace cleanup, with API change. ** API change: MARK_NOARGS becomes UST_MARKER_NOARGS ** Cleanup the "marker" namespace by using "ust_marker/UST_MARKER". Signed-off-by: Mathieu Desnoyers --- diff --git a/include/ust/marker.h b/include/ust/marker.h index 906d78d..99bb724 100644 --- a/include/ust/marker.h +++ b/include/ust/marker.h @@ -34,10 +34,10 @@ #include -struct marker; +struct ust_marker; /** - * marker_probe_func - Type of a marker probe function + * ust_marker_probe_func - Type of a marker probe function * @mdata: marker data * @probe_private: probe private data * @call_private: call site private data @@ -49,16 +49,16 @@ struct marker; * Type of marker probe functions. They receive the mdata and need to parse the * format string to recover the variable argument list. */ -typedef void marker_probe_func(const struct marker *mdata, +typedef void ust_marker_probe_func(const struct ust_marker *mdata, void *probe_private, struct registers *regs, void *call_private, const char *fmt, va_list *args); -struct marker_probe_closure { - marker_probe_func *func; /* Callback */ +struct ust_marker_probe_closure { + ust_marker_probe_func *func; /* Callback */ void *probe_private; /* Private probe data */ }; -struct marker { +struct ust_marker { const char *channel; /* Name of channel where to send data */ const char *name; /* Marker name */ const char *format; /* Marker format string, describing the @@ -69,18 +69,18 @@ struct marker { /* Probe wrapper */ u16 channel_id; /* Numeric channel identifier, dynamic */ u16 event_id; /* Numeric event identifier, dynamic */ - void (*call)(const struct marker *mdata, void *call_private, struct registers *regs, ...); - struct marker_probe_closure single; - struct marker_probe_closure *multi; + void (*call)(const struct ust_marker *mdata, void *call_private, struct registers *regs, ...); + struct ust_marker_probe_closure single; + struct ust_marker_probe_closure *multi; const char *tp_name; /* Optional tracepoint name */ void *tp_cb; /* Optional tracepoint callback */ void *location; /* Address of marker in code */ }; -#define GET_MARKER(name) (__mark_ust_##name) +#define GET_UST_MARKER(name) (__ust_marker_ust_##name) -#define _DEFINE_MARKER(channel, name, tp_name_str, tp_cb, format, unique, m) \ - struct registers __marker_regs; \ +#define _DEFINE_UST_MARKER(channel, name, tp_name_str, tp_cb, format, unique, m) \ + struct registers __ust_marker_regs; \ \ /* This next asm has to be a basic inline asm (no input/output/clobber), \ * because it must not require %-sign escaping, as we most certainly \ @@ -93,8 +93,8 @@ struct marker { * is not unusual as it can be the result of function inlining. \ */ \ ".ifndef __mstrtab_" __stringify(channel) "_" __stringify(name) "_channel_" __stringify(unique) "\n\t" \ - /*".section __markers_strings\n\t"*/ \ - ".section __markers_strings,\"aw\"\n\t" \ + /*".section __ust_marker_strings\n\t"*/ \ + ".section __ust_marker_strings,\"aw\"\n\t" \ "__mstrtab_" __stringify(channel) "_" __stringify(name) "_channel_" __stringify(unique) ":\n\t" \ ".string \"" __stringify(channel) "\"\n\t" \ "__mstrtab_" __stringify(channel) "_" __stringify(name) "_name_" __stringify(unique) ":\n\t" \ @@ -105,8 +105,8 @@ struct marker { ".endif\n\t" \ ); \ asm volatile ( \ - /*".section __markers\n\t"*/ \ - ".section __markers,\"aw\"\n\t" \ + /*".section __ust_marker\n\t"*/ \ + ".section __ust_marker,\"aw\"\n\t" \ "2:\n\t" \ _ASM_PTR "(__mstrtab_" __stringify(channel) "_" __stringify(name) "_channel_" __stringify(unique) ")\n\t" /* channel string */ \ _ASM_PTR "(__mstrtab_" __stringify(channel) "_" __stringify(name) "_name_" __stringify(unique) ")\n\t" /* name string */ \ @@ -116,49 +116,49 @@ struct marker { ".hword 0\n\t" /* channel_id */ \ ".hword 0\n\t" /* event_id */ \ ".balign " __stringify(__WORDSIZE) " / 8\n\t" /* alignment */ \ - _ASM_PTR "(marker_probe_cb)\n\t" /* call */ \ - _ASM_PTR "(__mark_empty_function)\n\t" /* marker_probe_closure single.field1 */ \ - _ASM_PTR "0\n\t" /* marker_probe_closure single.field2 */ \ - _ASM_PTR "0\n\t" /* marker_probe_closure *multi */ \ + _ASM_PTR "(ust_marker_probe_cb)\n\t" /* call */ \ + _ASM_PTR "(__ust_marker_empty_function)\n\t" /* ust_marker_probe_closure single.field1 */ \ + _ASM_PTR "0\n\t" /* ust_marker_probe_closure single.field2 */ \ + _ASM_PTR "0\n\t" /* ust_marker_probe_closure *multi */ \ _ASM_PTR "0\n\t" /* tp_name */ \ _ASM_PTR "0\n\t" /* tp_cb */ \ _ASM_PTR "(1f)\n\t" /* location */ \ ".previous\n\t" \ - /*".section __markers_ptrs\n\t"*/ \ - ".section __markers_ptrs,\"a\"\n\t" \ + /*".section __ust_marker_ptrs\n\t"*/ \ + ".section __ust_marker_ptrs,\"a\"\n\t" \ _ASM_PTR "(2b)\n\t" \ ".previous\n\t" \ "1:\n\t" \ ARCH_COPY_ADDR("%[outptr]") \ : [outptr] "=r" (m) ); \ \ - save_registers(&__marker_regs) + save_registers(&__ust_marker_regs) -#define DEFINE_MARKER(name, format, unique, m) \ - _DEFINE_MARKER(ust, name, NULL, NULL, format, unique, m) +#define DEFINE_UST_MARKER(name, format, unique, m) \ + _DEFINE_UST_MARKER(ust, name, NULL, NULL, format, unique, m) -#define DEFINE_MARKER_TP(name, tp_name, tp_cb, format) \ - _DEFINE_MARKER_TP(ust, name, #tp_name, tp_cb, format) +#define DEFINE_UST_MARKER_TP(name, tp_name, tp_cb, format) \ + _DEFINE_UST_MARKER_TP(ust, name, #tp_name, tp_cb, format) -#define _DEFINE_MARKER_TP(channel, name, tp_name_str, tp_cb, format) \ +#define _DEFINE_UST_MARKER_TP(channel, name, tp_name_str, tp_cb, format)\ static const char __mstrtab_##channel##_##name[] \ - __attribute__((section("__markers_strings"))) \ + __attribute__((section("__ust_marker_strings"))) \ = #channel "\0" #name "\0" format; \ - static struct marker __mark_##channel##_##name \ - __attribute__((section("__markers"))) = \ + static struct ust_marker __ust_marker_##channel##_##name\ + __attribute__((section("__ust_marker"))) = \ { __mstrtab_##channel##_##name, \ - &__mstrtab_##channel##_##name[sizeof(#channel)], \ + &__mstrtab_##channel##_##name[sizeof(#channel)],\ &__mstrtab_##channel##_##name[sizeof(#channel) + sizeof(#name)], \ - 0, 0, 0, 0, marker_probe_cb, \ - { __mark_empty_function, NULL}, \ + 0, 0, 0, 0, ust_marker_probe_cb, \ + { __ust_marker_empty_function, NULL}, \ NULL, tp_name_str, tp_cb }; \ - static struct marker * const __mark_ptr_##channel##_##name \ - __attribute__((used, section("__markers_ptrs"))) = \ - &__mark_##channel##_##name; + static struct ust_marker * const __ust_marker_ptr_##channel##_##name \ + __attribute__((used, section("__ust_marker_ptrs"))) = \ + &__ust_marker_##channel##_##name; /* - * Make sure the alignment of the structure in the __markers section will + * Make sure the alignment of the structure in the __ust_marker section will * not add unwanted padding between the beginning of the section and the * structure. Force alignment to the same alignment as the section start. * @@ -172,15 +172,15 @@ struct marker { #define __ust_marker_counter(generic, channel, name, unique, call_private, format, args...) \ do { \ - struct marker *__marker_counter_ptr; \ - _DEFINE_MARKER(channel, name, NULL, NULL, format, unique, __marker_counter_ptr); \ - __mark_check_format(format, ## args); \ + struct ust_marker *__ust_marker_counter_ptr; \ + _DEFINE_UST_MARKER(channel, name, NULL, NULL, format, unique, __ust_marker_counter_ptr); \ + __ust_marker_check_format(format, ## args); \ if (!generic) { \ - if (unlikely(imv_read(__marker_counter_ptr->state))) \ - (__marker_counter_ptr->call)(__marker_counter_ptr, call_private, &__marker_regs, ## args); \ + if (unlikely(imv_read(__ust_marker_counter_ptr->state))) \ + (__ust_marker_counter_ptr->call)(__ust_marker_counter_ptr, call_private, &__ust_marker_regs, ## args); \ } else { \ - if (unlikely(_imv_read(__marker_counter_ptr->state))) \ - (__marker_counter_ptr->call)(__marker_counter_ptr, call_private, &__marker_regs, ## args); \ + if (unlikely(_imv_read(__ust_marker_counter_ptr->state))) \ + (__ust_marker_counter_ptr->call)(__ust_marker_counter_ptr, call_private, &__ust_marker_regs, ## args); \ } \ } while (0) @@ -189,19 +189,19 @@ struct marker { #define __ust_marker_tp_counter(channel, name, unique, call_private, tp_name, tp_cb, format, args...) \ do { \ - struct registers __marker_regs; \ + struct registers __ust_marker_regs; \ void __check_tp_type(void) \ { \ register_trace_##tp_name(tp_cb, call_private); \ } \ - _DEFINE_MARKER_TP(channel, name, #tp_name, tp_cb, format); \ - __mark_check_format(format, ## args); \ - (*__mark_##channel##_##name.call)(&__mark_##channel##_##name, \ - call_private, &__marker_regs, ## args); \ + _DEFINE_UST_MARKER_TP(channel, name, #tp_name, tp_cb, format); \ + __ust_marker_check_format(format, ## args); \ + (*__ust_marker_##channel##_##name.call)(&__ust_marker_##channel##_##name, \ + call_private, &__ust_marker_regs, ## args); \ } while (0) -extern void marker_update_probe_range(struct marker * const *begin, - struct marker * const *end); +extern void ust_marker_update_probe_range(struct ust_marker * const *begin, + struct ust_marker * const *end); /** * ust_marker - Marker using code patching @@ -243,121 +243,121 @@ extern void marker_update_probe_range(struct marker * const *begin, __ust_marker_tp(ust, name, NULL, tp_name, tp_cb, format, ## args) /** - * MARK_NOARGS - Format string for a marker with no argument. + * UST_MARKER_NOARGS - Format string for a marker with no argument. */ -#define MARK_NOARGS " " +#define UST_MARKER_NOARGS " " -extern void lock_markers(void); -extern void unlock_markers(void); +extern void lock_ust_marker(void); +extern void unlock_ust_marker(void); -extern void markers_compact_event_ids(void); +extern void ust_marker_compact_event_ids(void); /* To be used for string format validity checking with gcc */ -static inline void __printf(1, 2) ___mark_check_format(const char *fmt, ...) +static inline void __printf(1, 2) ___ust_marker_check_format(const char *fmt, ...) { } -#define __mark_check_format(format, args...) \ +#define __ust_marker_check_format(format, args...) \ do { \ if (0) \ - ___mark_check_format(format, ## args); \ + ___ust_marker_check_format(format, ## args); \ } while (0) -extern marker_probe_func __mark_empty_function; +extern ust_marker_probe_func __ust_marker_empty_function; -extern void marker_probe_cb(const struct marker *mdata, +extern void ust_marker_probe_cb(const struct ust_marker *mdata, void *call_private, struct registers *regs, ...); /* * Connect a probe to a marker. * private data pointer must be a valid allocated memory address, or NULL. */ -extern int marker_probe_register(const char *channel, const char *name, - const char *format, marker_probe_func *probe, void *probe_private); +extern int ust_marker_probe_register(const char *channel, const char *name, + const char *format, ust_marker_probe_func *probe, void *probe_private); /* - * Returns the private data given to marker_probe_register. + * Returns the private data given to ust_marker_probe_register. */ -extern int marker_probe_unregister(const char *channel, const char *name, - marker_probe_func *probe, void *probe_private); +extern int ust_marker_probe_unregister(const char *channel, const char *name, + ust_marker_probe_func *probe, void *probe_private); /* * Unregister a marker by providing the registered private data. */ -extern int marker_probe_unregister_private_data(marker_probe_func *probe, +extern int ust_marker_probe_unregister_private_data(ust_marker_probe_func *probe, void *probe_private); -extern void *marker_get_private_data(const char *channel, const char *name, - marker_probe_func *probe, int num); +extern void *ust_marker_get_private_data(const char *channel, const char *name, + ust_marker_probe_func *probe, int num); /* - * marker_synchronize_unregister must be called between the last marker probe + * ust_marker_synchronize_unregister must be called between the last marker probe * unregistration and the first one of * - the end of module exit function * - the free of any resource used by the probes * to ensure the code and data are valid for any possibly running probes. */ -#define marker_synchronize_unregister() synchronize_sched() +#define ust_marker_synchronize_unregister() synchronize_sched() -struct marker_iter { +struct ust_marker_iter { //ust// struct module *module; - struct lib *lib; - struct marker * const *marker; + struct ust_marker_lib *lib; + struct ust_marker * const *ust_marker; }; -extern void marker_iter_start(struct marker_iter *iter); -extern void marker_iter_next(struct marker_iter *iter); -extern void marker_iter_stop(struct marker_iter *iter); -extern void marker_iter_reset(struct marker_iter *iter); -extern int marker_get_iter_range(struct marker * const **marker, struct marker * const *begin, - struct marker * const *end); +extern void ust_marker_iter_start(struct ust_marker_iter *iter); +extern void ust_marker_iter_next(struct ust_marker_iter *iter); +extern void ust_marker_iter_stop(struct ust_marker_iter *iter); +extern void ust_marker_iter_reset(struct ust_marker_iter *iter); +extern int ust_marker_get_iter_range(struct ust_marker * const **marker, struct ust_marker * const *begin, + struct ust_marker * const *end); -extern void marker_update_process(void); -extern int is_marker_enabled(const char *channel, const char *name); +extern void ust_marker_update_process(void); +extern int is_ust_marker_enabled(const char *channel, const char *name); -//ust// #ifdef CONFIG_MARKERS_USERSPACE -//ust// extern void exit_user_markers(struct task_struct *p); +//ust// #ifdef CONFIG_UST_MARKER_USERSPACE +//ust// extern void exit_user_ust_marker(struct task_struct *p); //ust// #else -//ust// static inline void exit_user_markers(struct task_struct *p) +//ust// static inline void exit_user_ust_marker(struct task_struct *p) //ust// { //ust// } //ust// #endif -struct marker_addr { - struct marker *marker; +struct ust_marker_addr { + struct ust_marker *marker; void *addr; }; -struct lib { - struct marker * const *markers_start; +struct ust_marker_lib { + struct ust_marker * const *ust_marker_start; #ifdef CONFIG_UST_GDB_INTEGRATION - struct marker_addr *markers_addr_start; + struct ust_marker_addr *ust_marker_addr_start; #endif - int markers_count; + int ust_marker_count; struct cds_list_head list; }; -extern int marker_register_lib(struct marker * const *markers_start, int markers_count); -extern int marker_unregister_lib(struct marker * const *markers_start); +extern int ust_marker_register_lib(struct ust_marker * const *ust_marker_start, int ust_marker_count); +extern int ust_marker_unregister_lib(struct ust_marker * const *ust_marker_start); -#define MARKER_LIB \ - extern struct marker * const __start___markers_ptrs[] __attribute__((weak, visibility("hidden"))); \ - extern struct marker * const __stop___markers_ptrs[] __attribute__((weak, visibility("hidden"))); \ - static struct marker * const __mark_ptr_dummy \ - __attribute__((used, section("__markers_ptrs"))) = NULL;\ +#define UST_MARKER_LIB \ + extern struct ust_marker * const __start___ust_marker_ptrs[] __attribute__((weak, visibility("hidden"))); \ + extern struct ust_marker * const __stop___ust_marker_ptrs[] __attribute__((weak, visibility("hidden"))); \ + static struct ust_marker * const __ust_marker_ptr_dummy \ + __attribute__((used, section("__ust_marker_ptrs"))) = NULL;\ \ - static void __attribute__((constructor)) __markers__init(void) \ + static void __attribute__((constructor)) __ust_marker__init(void) \ { \ - marker_register_lib(__start___markers_ptrs, \ - __stop___markers_ptrs \ - - __start___markers_ptrs); \ + ust_marker_register_lib(__start___ust_marker_ptrs, \ + __stop___ust_marker_ptrs \ + - __start___ust_marker_ptrs); \ } \ \ - static void __attribute__((destructor)) __markers__destroy(void)\ + static void __attribute__((destructor)) __ust_marker__destroy(void)\ { \ - marker_unregister_lib(__start___markers_ptrs); \ + ust_marker_unregister_lib(__start___ust_marker_ptrs); \ } -extern void marker_set_new_marker_cb(void (*cb)(struct marker *)); -extern void init_markers(void); +extern void ust_marker_set_new_ust_marker_cb(void (*cb)(struct ust_marker *)); +extern void init_ust_marker(void); #endif /* _UST_MARKER_H */ diff --git a/include/ust/probe.h b/include/ust/probe.h index 5002721..a4f3a0e 100644 --- a/include/ust/probe.h +++ b/include/ust/probe.h @@ -36,16 +36,16 @@ typedef size_t (*ltt_serialize_cb)(struct ust_buffer *buf, size_t buf_offset, struct ltt_available_probe { const char *name; /* probe name */ const char *format; - marker_probe_func *probe_func; + ust_marker_probe_func *probe_func; ltt_serialize_cb callbacks[LTT_NR_CALLBACKS]; struct cds_list_head node; /* registered probes list */ }; extern int ltt_probe_register(struct ltt_available_probe *pdata); extern int ltt_probe_unregister(struct ltt_available_probe *pdata); -extern int ltt_marker_connect(const char *channel, const char *mname, +extern int ltt_ust_marker_connect(const char *channel, const char *mname, const char *pname); -extern int ltt_marker_disconnect(const char *channel, const char *mname, +extern int ltt_ust_marker_disconnect(const char *channel, const char *mname, const char *pname); #endif /* _UST_PROBE_H */ diff --git a/include/ust/type-serializer.h b/include/ust/type-serializer.h index 8457a47..ef9af1c 100644 --- a/include/ust/type-serializer.h +++ b/include/ust/type-serializer.h @@ -9,7 +9,7 @@ * largest_align must be non-zero, equal to the minimum between the largest type * and sizeof(void *). */ -extern void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, +extern void _ltt_specialized_trace(const struct ust_marker *mdata, void *probe_data, void *serialize_private, unsigned int data_size, unsigned int largest_align); @@ -18,7 +18,7 @@ extern void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, * dumb-proof. It will make sure 0 is changed into 1 and unsigned long long is * changed into sizeof(void *) on 32-bit architectures. */ -static inline void ltt_specialized_trace(const struct marker *mdata, +static inline void ltt_specialized_trace(const struct ust_marker *mdata, void *probe_data, void *serialize_private, unsigned int data_size, unsigned int largest_align) diff --git a/include/ust/ustctl.h b/include/ust/ustctl.h index 35f7617..33d7ade 100644 --- a/include/ust/ustctl.h +++ b/include/ust/ustctl.h @@ -36,11 +36,11 @@ #define USTCTL_SOCK_PATH "/tmp/socks/" /* Channel/marker/state/format string (cmsf) info. structure */ -struct marker_status { - char *channel; /* Channel name (end of marker_status array if NULL) */ - char *marker; /* Marker name (end of marker_status array if NULL) */ +struct ust_marker_status { + char *channel; /* Channel name (end of ust_marker_status array if NULL) */ + char *ust_marker; /* Marker name (end of ust_marker_status array if NULL) */ int state; /* State (0 := marker disabled, 1 := marker enabled) */ - char *fs; /* Format string (end of marker_status array if NULL) */ + char *fs; /* Format string (end of ust_marker_status array if NULL) */ }; struct trace_event_status { @@ -51,8 +51,8 @@ extern pid_t *ustctl_get_online_pids(void); extern int ustctl_connect_pid(pid_t pid); -extern int ustctl_set_marker_state(int sock, const char *trace, - const char *channel, const char *marker, +extern int ustctl_set_ust_marker_state(int sock, const char *trace, + const char *channel, const char *ust_marker, int state); extern int ustctl_set_subbuf_size(int sock, const char *trace, @@ -81,11 +81,11 @@ extern int ustctl_start_trace(int sock, const char *trace); extern int ustctl_alloc_trace(int sock, const char *trace); -extern int ustctl_free_cmsf(struct marker_status *); +extern int ustctl_free_cmsf(struct ust_marker_status *); extern int ustctl_free_tes(struct trace_event_status *); extern unsigned int ustctl_count_nl(const char *); -extern int ustctl_get_cmsf(int sock, struct marker_status **); +extern int ustctl_get_cmsf(int sock, struct ust_marker_status **); extern int ustctl_get_tes(int sock, struct trace_event_status **); diff --git a/java/UST.c b/java/UST.c index 7e01e92..0904ad2 100644 --- a/java/UST.c +++ b/java/UST.c @@ -10,4 +10,4 @@ JNIEXPORT void JNICALL Java_UST_ust_1java_1event (JNIEnv *env, jobject jobj, jst ust_marker(ust, java_event, "name %s args %s", ev_name_cstr, args_cstr); } -MARKER_LIB +UST_MARKER_LIB diff --git a/libust-initializer.c b/libust-initializer.c index 2314e5e..83635d6 100644 --- a/libust-initializer.c +++ b/libust-initializer.c @@ -11,6 +11,6 @@ #include #include -MARKER_LIB; +UST_MARKER_LIB; TRACEPOINT_LIB; TRACE_EVENT_LIB; diff --git a/libust/channels.c b/libust/channels.c index 13178e6..402b915 100644 --- a/libust/channels.c +++ b/libust/channels.c @@ -294,12 +294,12 @@ end: */ void ltt_channels_trace_free(struct ust_channel *channels) { - lock_markers(); + lock_ust_marker(); pthread_mutex_lock(<t_channel_mutex); free(channels); urcu_ref_put(&index_urcu_ref, release_trace_channel); pthread_mutex_unlock(<t_channel_mutex); - unlock_markers(); + unlock_ust_marker(); } //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_free); diff --git a/libust/marker-control.c b/libust/marker-control.c index 3d50952..e83ee1a 100644 --- a/libust/marker-control.c +++ b/libust/marker-control.c @@ -17,8 +17,8 @@ * */ -/* This file contains a high-level API for activating and deactivating markers, - * and making sure markers in a given library can be released when the library +/* This file contains a high-level API for activating and deactivating ust_markers, + * and making sure ust_markers in a given library can be released when the library * is unloaded. */ @@ -46,8 +46,8 @@ struct ltt_available_probe default_probe = { .callbacks[0] = ltt_serialize_data, }; -//ust//static struct kmem_cache *markers_loaded_cachep; -static CDS_LIST_HEAD(markers_loaded_list); +//ust//static struct kmem_cache *ust_markers_loaded_cachep; +static CDS_LIST_HEAD(ust_markers_loaded_list); /* * List sorted by name strcmp order. */ @@ -92,7 +92,7 @@ static char *skip_nonspaces(char *buf) return buf; } -static void get_marker_string(char *buf, char **start, +static void get_ust_marker_string(char *buf, char **start, char **end) { *start = skip_spaces(buf); @@ -132,12 +132,12 @@ end: int ltt_probe_unregister(struct ltt_available_probe *pdata) { int ret = 0; - struct ltt_active_marker *amark, *tmp; + struct ltt_active_ust_marker *amark, *tmp; pthread_mutex_lock(&probes_mutex); - cds_list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) { + cds_list_for_each_entry_safe(amark, tmp, &ust_markers_loaded_list, node) { if (amark->probe == pdata) { - ret = marker_probe_unregister_private_data( + ret = ust_marker_probe_unregister_private_data( pdata->probe_func, amark); if (ret) goto end; @@ -152,15 +152,15 @@ end: } /* - * Connect marker "mname" to probe "pname". - * Only allow _only_ probe instance to be connected to a marker. + * Connect ust_marker "mname" to probe "pname". + * Only allow _only_ probe instance to be connected to a ust_marker. */ -int ltt_marker_connect(const char *channel, const char *mname, +int ltt_ust_marker_connect(const char *channel, const char *mname, const char *pname) { int ret; - struct ltt_active_marker *pdata; + struct ltt_active_ust_marker *pdata; struct ltt_available_probe *probe; ltt_lock_traces(); @@ -170,12 +170,12 @@ int ltt_marker_connect(const char *channel, const char *mname, ret = -ENOENT; goto end; } - pdata = marker_get_private_data(channel, mname, probe->probe_func, 0); + pdata = ust_marker_get_private_data(channel, mname, probe->probe_func, 0); if (pdata && !IS_ERR(pdata)) { ret = -EEXIST; goto end; } - pdata = zmalloc(sizeof(struct ltt_active_marker)); + pdata = zmalloc(sizeof(struct ltt_active_ust_marker)); if (!pdata) { ret = -ENOMEM; goto end; @@ -184,12 +184,12 @@ int ltt_marker_connect(const char *channel, const char *mname, /* * ID has priority over channel in case of conflict. */ - ret = marker_probe_register(channel, mname, NULL, + ret = ust_marker_probe_register(channel, mname, NULL, probe->probe_func, pdata); if (ret) free(pdata); else - cds_list_add(&pdata->node, &markers_loaded_list); + cds_list_add(&pdata->node, &ust_markers_loaded_list); end: pthread_mutex_unlock(&probes_mutex); ltt_unlock_traces(); @@ -197,12 +197,12 @@ end: } /* - * Disconnect marker "mname", probe "pname". + * Disconnect ust_marker "mname", probe "pname". */ -int ltt_marker_disconnect(const char *channel, const char *mname, +int ltt_ust_marker_disconnect(const char *channel, const char *mname, const char *pname) { - struct ltt_active_marker *pdata; + struct ltt_active_ust_marker *pdata; struct ltt_available_probe *probe; int ret = 0; @@ -212,7 +212,7 @@ int ltt_marker_disconnect(const char *channel, const char *mname, ret = -ENOENT; goto end; } - pdata = marker_get_private_data(channel, mname, probe->probe_func, 0); + pdata = ust_marker_get_private_data(channel, mname, probe->probe_func, 0); if (IS_ERR(pdata)) { ret = PTR_ERR(pdata); goto end; @@ -223,7 +223,7 @@ int ltt_marker_disconnect(const char *channel, const char *mname, ret = -EPERM; goto end; } - ret = marker_probe_unregister(channel, mname, probe->probe_func, pdata); + ret = ust_marker_probe_unregister(channel, mname, probe->probe_func, pdata); if (ret) goto end; else { @@ -238,14 +238,14 @@ end: /* * function handling proc entry write. * - * connect []] - * disconnect [] + * connect []] + * disconnect [] */ //ust// static ssize_t ltt_write(struct file *file, const char __user *buffer, //ust// size_t count, loff_t *offset) //ust// { //ust// char *kbuf; -//ust// char *iter, *marker_action, *arg[4]; +//ust// char *iter, *ust_marker_action, *arg[4]; //ust// ssize_t ret; //ust// int i; //ust// @@ -259,8 +259,8 @@ end: //ust// ret = -EINVAL; //ust// goto end; //ust// } -//ust// get_marker_string(kbuf, &marker_action, &iter); -//ust// if (!marker_action || marker_action == iter) { +//ust// get_ust_marker_string(kbuf, &ust_marker_action, &iter); +//ust// if (!ust_marker_action || ust_marker_action == iter) { //ust// ret = -EINVAL; //ust// goto end; //ust// } @@ -268,7 +268,7 @@ end: //ust// arg[i] = NULL; //ust// if (iter < kbuf + count) { //ust// iter++; /* skip the added '\0' */ -//ust// get_marker_string(iter, &arg[i], &iter); +//ust// get_ust_marker_string(iter, &arg[i], &iter); //ust// if (arg[i] == iter) //ust// arg[i] = NULL; //ust// } @@ -279,12 +279,12 @@ end: //ust// goto end; //ust// } //ust// -//ust// if (!strcmp(marker_action, "connect")) { -//ust// ret = ltt_marker_connect(arg[0], arg[1], arg[2]); +//ust// if (!strcmp(ust_marker_action, "connect")) { +//ust// ret = ltt_ust_marker_connect(arg[0], arg[1], arg[2]); //ust// if (ret) //ust// goto end; -//ust// } else if (!strcmp(marker_action, "disconnect")) { -//ust// ret = ltt_marker_disconnect(arg[0], arg[1], arg[2]); +//ust// } else if (!strcmp(ust_marker_action, "disconnect")) { +//ust// ret = ltt_ust_marker_disconnect(arg[0], arg[1], arg[2]); //ust// if (ret) //ust// goto end; //ust// } @@ -296,57 +296,57 @@ end: //ust// //ust// static void *s_next(struct seq_file *m, void *p, loff_t *pos) //ust// { -//ust// struct marker_iter *iter = m->private; +//ust// struct ust_marker_iter *iter = m->private; //ust// -//ust// marker_iter_next(iter); -//ust// if (!iter->marker) { +//ust// ust_marker_iter_next(iter); +//ust// if (!iter->ust_marker) { //ust// /* //ust// * Setting the iter module to -1UL will make sure -//ust// * that no module can possibly hold the current marker. +//ust// * that no module can possibly hold the current ust_marker. //ust// */ //ust// iter->module = (void *)-1UL; //ust// return NULL; //ust// } -//ust// return iter->marker; +//ust// return iter->ust_marker; //ust// } //ust// //ust// static void *s_start(struct seq_file *m, loff_t *pos) //ust// { -//ust// struct marker_iter *iter = m->private; +//ust// struct ust_marker_iter *iter = m->private; //ust// //ust// if (!*pos) -//ust// marker_iter_reset(iter); -//ust// marker_iter_start(iter); -//ust// if (!iter->marker) { +//ust// ust_marker_iter_reset(iter); +//ust// ust_marker_iter_start(iter); +//ust// if (!iter->ust_marker) { //ust// /* //ust// * Setting the iter module to -1UL will make sure -//ust// * that no module can possibly hold the current marker. +//ust// * that no module can possibly hold the current ust_marker. //ust// */ //ust// iter->module = (void *)-1UL; //ust// return NULL; //ust// } -//ust// return iter->marker; +//ust// return iter->ust_marker; //ust// } //ust// //ust// static void s_stop(struct seq_file *m, void *p) //ust// { -//ust// marker_iter_stop(m->private); +//ust// ust_marker_iter_stop(m->private); //ust// } //ust// //ust// static int s_show(struct seq_file *m, void *p) //ust// { -//ust// struct marker_iter *iter = m->private; +//ust// struct ust_marker_iter *iter = m->private; //ust// -//ust// seq_printf(m, "channel: %s marker: %s format: \"%s\" state: %d " +//ust// seq_printf(m, "channel: %s ust_marker: %s format: \"%s\" state: %d " //ust// "event_id: %hu call: 0x%p probe %s : 0x%p\n", -//ust// iter->marker->channel, -//ust// iter->marker->name, iter->marker->format, -//ust// _imv_read(iter->marker->state), -//ust// iter->marker->event_id, -//ust// iter->marker->call, -//ust// iter->marker->ptype ? "multi" : "single", -//ust// iter->marker->ptype ? -//ust// (void*)iter->marker->multi : (void*)iter->marker->single.func); +//ust// iter->ust_marker->channel, +//ust// iter->ust_marker->name, iter->ust_marker->format, +//ust// _imv_read(iter->ust_marker->state), +//ust// iter->ust_marker->event_id, +//ust// iter->ust_marker->call, +//ust// iter->ust_marker->ptype ? "multi" : "single", +//ust// iter->ust_marker->ptype ? +//ust// (void*)iter->ust_marker->multi : (void*)iter->ust_marker->single.func); //ust// return 0; //ust// } //ust// @@ -365,7 +365,7 @@ end: //ust// * the module mutex between those. //ust// */ //ust// int ret; -//ust// struct marker_iter *iter; +//ust// struct ust_marker_iter *iter; //ust// //ust// iter = kzalloc(sizeof(*iter), GFP_KERNEL); //ust// if (!iter) @@ -387,12 +387,12 @@ end: //ust// .release = seq_release_private, //ust// }; -static void disconnect_all_markers(void) +static void disconnect_all_ust_markers(void) { - struct ltt_active_marker *pdata, *tmp; + struct ltt_active_ust_marker *pdata, *tmp; - cds_list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) { - marker_probe_unregister_private_data(pdata->probe->probe_func, + cds_list_for_each_entry_safe(pdata, tmp, &ust_markers_loaded_list, node) { + ust_marker_probe_unregister_private_data(pdata->probe->probe_func, pdata); cds_list_del(&pdata->node); free(pdata); @@ -401,7 +401,7 @@ static void disconnect_all_markers(void) static char initialized = 0; -void __attribute__((constructor)) init_marker_control(void) +void __attribute__((constructor)) init_ust_marker_control(void) { if(!initialized) { int ret; @@ -409,40 +409,40 @@ void __attribute__((constructor)) init_marker_control(void) //ust// pentry = create_proc_entry("ltt", S_IRUSR|S_IWUSR, NULL); //ust// if (!pentry) //ust// return -EBUSY; -//ust// markers_loaded_cachep = KMEM_CACHE(ltt_active_marker, 0); +//ust// ust_markers_loaded_cachep = KMEM_CACHE(ltt_active_ust_marker, 0); ret = ltt_probe_register(&default_probe); BUG_ON(ret); - ret = ltt_marker_connect("metadata", "core_marker_format", + ret = ltt_ust_marker_connect("metadata", "core_marker_format", DEFAULT_PROBE); BUG_ON(ret); - ret = ltt_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE); + ret = ltt_ust_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE); BUG_ON(ret); //ust// pentry->proc_fops = <t_fops; initialized = 1; } } -//ust// module_init(marker_control_init); +//ust// module_init(ust_marker_control_init); -static void __attribute__((destructor)) marker_control_exit(void) +static void __attribute__((destructor)) ust_marker_control_exit(void) { int ret; //ust// remove_proc_entry("ltt", NULL); - ret = ltt_marker_disconnect("metadata", "core_marker_format", + ret = ltt_ust_marker_disconnect("metadata", "core_marker_format", DEFAULT_PROBE); BUG_ON(ret); - ret = ltt_marker_disconnect("metadata", "core_marker_id", + ret = ltt_ust_marker_disconnect("metadata", "core_marker_id", DEFAULT_PROBE); BUG_ON(ret); ret = ltt_probe_unregister(&default_probe); BUG_ON(ret); - disconnect_all_markers(); -//ust// kmem_cache_destroy(markers_loaded_cachep); -//ust// marker_synchronize_unregister(); + disconnect_all_ust_markers(); +//ust// kmem_cache_destroy(ust_markers_loaded_cachep); +//ust// ust_marker_synchronize_unregister(); } -//ust// module_exit(marker_control_exit); +//ust// module_exit(ust_marker_control_exit); //ust// MODULE_LICENSE("GPL"); //ust// MODULE_AUTHOR("Mathieu Desnoyers"); diff --git a/libust/marker-control.h b/libust/marker-control.h index 6557272..a1b65a1 100644 --- a/libust/marker-control.h +++ b/libust/marker-control.h @@ -19,7 +19,7 @@ #ifndef MARKER_CONTROL_H #define MARKER_CONTROL_H -int init_marker_control(void); +int init_ust_marker_control(void); int ltt_probe_register(struct ltt_available_probe *pdata); #endif /* MARKER_CONTROL_H */ diff --git a/libust/marker.c b/libust/marker.c index 0aa3d60..4a7eec6 100644 --- a/libust/marker.c +++ b/libust/marker.c @@ -35,55 +35,55 @@ __thread long ust_reg_stack[500]; volatile __thread long *ust_reg_stack_ptr = (long *) 0; -extern struct marker * const __start___markers_ptrs[] __attribute__((visibility("hidden"))); -extern struct marker * const __stop___markers_ptrs[] __attribute__((visibility("hidden"))); +extern struct ust_marker * const __start___ust_marker_ptrs[] __attribute__((visibility("hidden"))); +extern struct ust_marker * const __stop___ust_marker_ptrs[] __attribute__((visibility("hidden"))); -/* Set to 1 to enable marker debug output */ -static const int marker_debug; +/* Set to 1 to enable ust_marker debug output */ +static const int ust_marker_debug; /* - * markers_mutex nests inside module_mutex. Markers mutex protects the builtin - * and module markers and the hash table. + * ust_marker_mutex nests inside module_mutex. ust_marker mutex protects + * the builtin and module ust_marker and the hash table. */ -static DEFINE_MUTEX(markers_mutex); +static DEFINE_MUTEX(ust_marker_mutex); -static CDS_LIST_HEAD(libs); +static CDS_LIST_HEAD(ust_marker_libs); -void lock_markers(void) +void lock_ust_marker(void) { - pthread_mutex_lock(&markers_mutex); + pthread_mutex_lock(&ust_marker_mutex); } -void unlock_markers(void) +void unlock_ust_marker(void) { - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); } /* - * Marker hash table, containing the active markers. + * ust_marker hash table, containing the active ust_marker. * Protected by module_mutex. */ -#define MARKER_HASH_BITS 6 -#define MARKER_TABLE_SIZE (1 << MARKER_HASH_BITS) -static struct cds_hlist_head marker_table[MARKER_TABLE_SIZE]; +#define ust_marker_HASH_BITS 6 +#define ust_marker_TABLE_SIZE (1 << ust_marker_HASH_BITS) +static struct cds_hlist_head ust_marker_table[ust_marker_TABLE_SIZE]; /* * Note about RCU : - * It is used to make sure every handler has finished using its private data - * between two consecutive operation (add or remove) on a given marker. It is - * also used to delay the free of multiple probes array until a quiescent state - * is reached. - * marker entries modifications are protected by the markers_mutex. + * It is used to make sure every handler has finished using its private + * data between two consecutive operation (add or remove) on a given + * ust_marker. It is also used to delay the free of multiple probes + * array until a quiescent state is reached. ust_marker entries + * modifications are protected by the ust_marker_mutex. */ -struct marker_entry { +struct ust_marker_entry { struct cds_hlist_node hlist; char *format; char *name; /* Probe wrapper */ - void (*call)(const struct marker *mdata, void *call_private, struct registers *regs, ...); - struct marker_probe_closure single; - struct marker_probe_closure *multi; + void (*call)(const struct ust_marker *mdata, void *call_private, struct registers *regs, ...); + struct ust_marker_probe_closure single; + struct ust_marker_probe_closure *multi; int refcount; /* Number of times armed. 0 if disarmed. */ struct rcu_head rcu; void *oldptr; @@ -95,36 +95,37 @@ struct marker_entry { char channel[0]; /* Contains channel'\0'name'\0'format'\0' */ }; -#ifdef CONFIG_MARKERS_USERSPACE -static void marker_update_processes(void); +#ifdef CONFIG_UST_MARKER_USERSPACE +static void ust_marker_update_processes(void); #else -static void marker_update_processes(void) +static void ust_marker_update_processes(void) { } #endif /** - * __mark_empty_function - Empty probe callback - * @mdata: marker data + * __ust_marker_empty_function - Empty probe callback + * @mdata: ust_marker data * @probe_private: probe private data * @call_private: call site private data * @fmt: format string * @...: variable argument list * - * Empty callback provided as a probe to the markers. By providing this to a - * disabled marker, we make sure the execution flow is always valid even - * though the function pointer change and the marker enabling are two distinct - * operations that modifies the execution flow of preemptible code. + * Empty callback provided as a probe to the ust_marker. By providing + * this to a disabled ust_marker, we make sure the execution flow is + * always valid even though the function pointer change and the + * ust_marker enabling are two distinct operations that modifies the + * execution flow of preemptible code. */ -notrace void __mark_empty_function(const struct marker *mdata, +notrace void __ust_marker_empty_function(const struct ust_marker *mdata, void *probe_private, struct registers *regs, void *call_private, const char *fmt, va_list *args) { } -//ust// EXPORT_SYMBOL_GPL(__mark_empty_function); +//ust// EXPORT_SYMBOL_GPL(__ust_marker_empty_function); /* - * marker_probe_cb Callback that prepares the variable argument list for probes. - * @mdata: pointer of type struct marker + * ust_marker_probe_cb Callback that prepares the variable argument list for probes. + * @mdata: pointer of type struct ust_marker * @call_private: caller site private data * @...: Variable argument list. * @@ -132,7 +133,7 @@ notrace void __mark_empty_function(const struct marker *mdata, * need to put a full cmm_smp_rmb() in this branch. This is why we do not use * rcu_dereference() for the pointer read. */ -notrace void marker_probe_cb(const struct marker *mdata, +notrace void ust_marker_probe_cb(const struct ust_marker *mdata, void *call_private, struct registers *regs, ...) { va_list args; @@ -146,7 +147,7 @@ notrace void marker_probe_cb(const struct marker *mdata, //ust// rcu_read_lock_sched_notrace(); ptype = mdata->ptype; if (likely(!ptype)) { - marker_probe_func *func; + ust_marker_probe_func *func; /* Must read the ptype before ptr. They are not data dependant, * so we put an explicit cmm_smp_rmb() here. */ cmm_smp_rmb(); @@ -159,7 +160,7 @@ notrace void marker_probe_cb(const struct marker *mdata, mdata->format, &args); va_end(args); } else { - struct marker_probe_closure *multi; + struct ust_marker_probe_closure *multi; int i; /* * Read mdata->ptype before mdata->multi. @@ -183,17 +184,17 @@ notrace void marker_probe_cb(const struct marker *mdata, } //ust// rcu_read_unlock_sched_notrace(); } -//ust// EXPORT_SYMBOL_GPL(marker_probe_cb); +//ust// EXPORT_SYMBOL_GPL(ust_marker_probe_cb); /* - * marker_probe_cb Callback that does not prepare the variable argument list. - * @mdata: pointer of type struct marker + * ust_marker_probe_cb Callback that does not prepare the variable argument list. + * @mdata: pointer of type struct ust_marker * @call_private: caller site private data * @...: Variable argument list. * - * Should be connected to markers "MARK_NOARGS". + * Should be connected to ust_marker "UST_MARKER_NOARGS". */ -static notrace void marker_probe_cb_noarg(const struct marker *mdata, +static notrace void ust_marker_probe_cb_noarg(const struct ust_marker *mdata, void *call_private, struct registers *regs, ...) { va_list args; /* not initialized */ @@ -202,7 +203,7 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, //ust// rcu_read_lock_sched_notrace(); ptype = mdata->ptype; if (likely(!ptype)) { - marker_probe_func *func; + ust_marker_probe_func *func; /* Must read the ptype before ptr. They are not data dependant, * so we put an explicit cmm_smp_rmb() here. */ cmm_smp_rmb(); @@ -213,7 +214,7 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, func(mdata, mdata->single.probe_private, regs, call_private, mdata->format, &args); } else { - struct marker_probe_closure *multi; + struct ust_marker_probe_closure *multi; int i; /* * Read mdata->ptype before mdata->multi. @@ -237,19 +238,19 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, static void free_old_closure(struct rcu_head *head) { - struct marker_entry *entry = _ust_container_of(head, - struct marker_entry, rcu); + struct ust_marker_entry *entry = _ust_container_of(head, + struct ust_marker_entry, rcu); free(entry->oldptr); /* Make sure we free the data before setting the pending flag to 0 */ cmm_smp_wmb(); entry->rcu_pending = 0; } -static void debug_print_probes(struct marker_entry *entry) +static void debug_print_probes(struct ust_marker_entry *entry) { int i; - if (!marker_debug) + if (!ust_marker_debug) return; if (!entry->ptype) { @@ -264,12 +265,12 @@ static void debug_print_probes(struct marker_entry *entry) } } -static struct marker_probe_closure * -marker_entry_add_probe(struct marker_entry *entry, - marker_probe_func *probe, void *probe_private) +static struct ust_marker_probe_closure * +ust_marker_entry_add_probe(struct ust_marker_entry *entry, + ust_marker_probe_func *probe, void *probe_private) { int nr_probes = 0; - struct marker_probe_closure *old, *new; + struct ust_marker_probe_closure *old, *new; WARN_ON(!probe); @@ -279,7 +280,7 @@ marker_entry_add_probe(struct marker_entry *entry, if (entry->single.func == probe && entry->single.probe_private == probe_private) return ERR_PTR(-EBUSY); - if (entry->single.func == __mark_empty_function) { + if (entry->single.func == __ust_marker_empty_function) { /* 0 -> 1 probes */ entry->single.func = probe; entry->single.probe_private = probe_private; @@ -301,14 +302,14 @@ marker_entry_add_probe(struct marker_entry *entry, return ERR_PTR(-EBUSY); } /* + 2 : one for new probe, one for NULL func */ - new = zmalloc((nr_probes + 2) * sizeof(struct marker_probe_closure)); + new = zmalloc((nr_probes + 2) * sizeof(struct ust_marker_probe_closure)); if (new == NULL) return ERR_PTR(-ENOMEM); if (!old) new[0] = entry->single; else memcpy(new, old, - nr_probes * sizeof(struct marker_probe_closure)); + nr_probes * sizeof(struct ust_marker_probe_closure)); new[nr_probes].func = probe; new[nr_probes].probe_private = probe_private; entry->refcount = nr_probes + 1; @@ -318,23 +319,23 @@ marker_entry_add_probe(struct marker_entry *entry, return old; } -static struct marker_probe_closure * -marker_entry_remove_probe(struct marker_entry *entry, - marker_probe_func *probe, void *probe_private) +static struct ust_marker_probe_closure * +ust_marker_entry_remove_probe(struct ust_marker_entry *entry, + ust_marker_probe_func *probe, void *probe_private) { int nr_probes = 0, nr_del = 0, i; - struct marker_probe_closure *old, *new; + struct ust_marker_probe_closure *old, *new; old = entry->multi; debug_print_probes(entry); if (!entry->ptype) { /* 0 -> N is an error */ - WARN_ON(entry->single.func == __mark_empty_function); + WARN_ON(entry->single.func == __ust_marker_empty_function); /* 1 -> 0 probes */ WARN_ON(probe && entry->single.func != probe); WARN_ON(entry->single.probe_private != probe_private); - entry->single.func = __mark_empty_function; + entry->single.func = __ust_marker_empty_function; entry->refcount = 0; entry->ptype = 0; debug_print_probes(entry); @@ -351,7 +352,7 @@ marker_entry_remove_probe(struct marker_entry *entry, if (nr_probes - nr_del == 0) { /* N -> 0, (N > 1) */ - entry->single.func = __mark_empty_function; + entry->single.func = __ust_marker_empty_function; entry->refcount = 0; entry->ptype = 0; } else if (nr_probes - nr_del == 1) { @@ -366,7 +367,7 @@ marker_entry_remove_probe(struct marker_entry *entry, int j = 0; /* N -> M, (N > 1, M > 1) */ /* + 1 for NULL */ - new = zmalloc((nr_probes - nr_del + 1) * sizeof(struct marker_probe_closure)); + new = zmalloc((nr_probes - nr_del + 1) * sizeof(struct ust_marker_probe_closure)); if (new == NULL) return ERR_PTR(-ENOMEM); for (i = 0; old[i].func; i++) @@ -382,21 +383,21 @@ marker_entry_remove_probe(struct marker_entry *entry, } /* - * Get marker if the marker is present in the marker hash table. - * Must be called with markers_mutex held. + * Get ust_marker if the ust_marker is present in the ust_marker hash table. + * Must be called with ust_marker_mutex held. * Returns NULL if not present. */ -static struct marker_entry *get_marker(const char *channel, const char *name) +static struct ust_marker_entry *get_ust_marker(const char *channel, const char *name) { struct cds_hlist_head *head; struct cds_hlist_node *node; - struct marker_entry *e; + struct ust_marker_entry *e; size_t channel_len = strlen(channel) + 1; size_t name_len = strlen(name) + 1; u32 hash; hash = jhash(channel, channel_len-1, 0) ^ jhash(name, name_len-1, 0); - head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)]; + head = &ust_marker_table[hash & ((1 << ust_marker_HASH_BITS)-1)]; cds_hlist_for_each_entry(e, node, head, hlist) { if (!strcmp(channel, e->channel) && !strcmp(name, e->name)) return e; @@ -405,15 +406,15 @@ static struct marker_entry *get_marker(const char *channel, const char *name) } /* - * Add the marker to the marker hash table. Must be called with markers_mutex - * held. + * Add the ust_marker to the ust_marker hash table. Must be called with + * ust_marker_mutex held. */ -static struct marker_entry *add_marker(const char *channel, const char *name, +static struct ust_marker_entry *add_ust_marker(const char *channel, const char *name, const char *format) { struct cds_hlist_head *head; struct cds_hlist_node *node; - struct marker_entry *e; + struct ust_marker_entry *e; size_t channel_len = strlen(channel) + 1; size_t name_len = strlen(name) + 1; size_t format_len = 0; @@ -422,10 +423,10 @@ static struct marker_entry *add_marker(const char *channel, const char *name, hash = jhash(channel, channel_len-1, 0) ^ jhash(name, name_len-1, 0); if (format) format_len = strlen(format) + 1; - head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)]; + head = &ust_marker_table[hash & ((1 << ust_marker_HASH_BITS)-1)]; cds_hlist_for_each_entry(e, node, head, hlist) { if (!strcmp(channel, e->channel) && !strcmp(name, e->name)) { - DBG("Marker %s.%s busy", channel, name); + DBG("ust_marker %s.%s busy", channel, name); return ERR_PTR(-EBUSY); /* Already there */ } } @@ -433,7 +434,7 @@ static struct marker_entry *add_marker(const char *channel, const char *name, * Using zmalloc here to allocate a variable length element. Could * cause some memory fragmentation if overused. */ - e = zmalloc(sizeof(struct marker_entry) + e = zmalloc(sizeof(struct ust_marker_entry) + channel_len + name_len + format_len); if (!e) return ERR_PTR(-ENOMEM); @@ -443,18 +444,18 @@ static struct marker_entry *add_marker(const char *channel, const char *name, if (format) { e->format = &e->name[name_len]; memcpy(e->format, format, format_len); - if (strcmp(e->format, MARK_NOARGS) == 0) - e->call = marker_probe_cb_noarg; + if (strcmp(e->format, UST_MARKER_NOARGS) == 0) + e->call = ust_marker_probe_cb_noarg; else - e->call = marker_probe_cb; + e->call = ust_marker_probe_cb; __ust_marker(0, metadata, core_marker_format, NULL, "channel %s name %s format %s", e->channel, e->name, e->format); } else { e->format = NULL; - e->call = marker_probe_cb; + e->call = ust_marker_probe_cb; } - e->single.func = __mark_empty_function; + e->single.func = __ust_marker_empty_function; e->single.probe_private = NULL; e->multi = NULL; e->ptype = 0; @@ -466,14 +467,14 @@ static struct marker_entry *add_marker(const char *channel, const char *name, } /* - * Remove the marker from the marker hash table. Must be called with mutex_lock + * Remove the ust_marker from the ust_marker hash table. Must be called with mutex_lock * held. */ -static int remove_marker(const char *channel, const char *name) +static int remove_ust_marker(const char *channel, const char *name) { struct cds_hlist_head *head; struct cds_hlist_node *node; - struct marker_entry *e; + struct ust_marker_entry *e; int found = 0; size_t channel_len = strlen(channel) + 1; size_t name_len = strlen(name) + 1; @@ -481,7 +482,7 @@ static int remove_marker(const char *channel, const char *name) int ret; hash = jhash(channel, channel_len-1, 0) ^ jhash(name, name_len-1, 0); - head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)]; + head = &ust_marker_table[hash & ((1 << ust_marker_HASH_BITS)-1)]; cds_hlist_for_each_entry(e, node, head, hlist) { if (!strcmp(channel, e->channel) && !strcmp(name, e->name)) { found = 1; @@ -490,7 +491,7 @@ static int remove_marker(const char *channel, const char *name) } if (!found) return -ENOENT; - if (e->single.func != __mark_empty_function) + if (e->single.func != __ust_marker_empty_function) return -EBUSY; cds_hlist_del(&e->hlist); if (e->format_allocated) @@ -507,7 +508,7 @@ static int remove_marker(const char *channel, const char *name) /* * Set the mark_entry format to the format found in the element. */ -static int marker_set_format(struct marker_entry *entry, const char *format) +static int ust_marker_set_format(struct ust_marker_entry *entry, const char *format) { entry->format = strdup(format); if (!entry->format) @@ -521,9 +522,9 @@ static int marker_set_format(struct marker_entry *entry, const char *format) } /* - * Sets the probe callback corresponding to one marker. + * Sets the probe callback corresponding to one ust_marker. */ -static int set_marker(struct marker_entry *entry, struct marker *elem, +static int set_ust_marker(struct ust_marker_entry *entry, struct ust_marker *elem, int active) { int ret = 0; @@ -531,14 +532,14 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, if (entry->format) { if (strcmp(entry->format, elem->format) != 0) { - ERR("Format mismatch for probe %s (%s), marker (%s)", + ERR("Format mismatch for probe %s (%s), ust_marker (%s)", entry->name, entry->format, elem->format); return -EPERM; } } else { - ret = marker_set_format(entry, elem->format); + ret = ust_marker_set_format(entry, elem->format); if (ret) return ret; } @@ -557,7 +558,7 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, * We only update the single probe private data when the ptr is * set to a _non_ single probe! (0 -> 1 and N -> 1, N != 1) */ - WARN_ON(elem->single.func != __mark_empty_function + WARN_ON(elem->single.func != __ust_marker_empty_function && elem->single.probe_private != entry->single.probe_private && !elem->ptype); elem->single.probe_private = entry->single.probe_private; @@ -589,7 +590,7 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, if (active) { /* * try_module_get should always succeed because we hold - * markers_mutex to get the tp_cb address. + * ust_marker_mutex to get the tp_cb address. */ //ust// ret = try_module_get(__module_text_address( //ust// (unsigned long)elem->tp_cb)); @@ -615,12 +616,12 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, } /* - * Disable a marker and its probe callback. + * Disable a ust_marker and its probe callback. * Note: only waiting an RCU period after setting elem->call to the empty * function insures that the original callback is not used anymore. This insured * by rcu_read_lock_sched around the call site. */ -static void disable_marker(struct marker *elem) +static void disable_ust_marker(struct ust_marker *elem) { int ret; @@ -641,7 +642,7 @@ static void disable_marker(struct marker *elem) //ust// module_put(__module_text_address((unsigned long)elem->tp_cb)); } elem->state__imv = 0; - elem->single.func = __mark_empty_function; + elem->single.func = __ust_marker_empty_function; /* Update the function before setting the ptype */ cmm_smp_wmb(); elem->ptype = 0; /* single probe */ @@ -653,62 +654,62 @@ static void disable_marker(struct marker *elem) } /* - * is_marker_enabled - Check if a marker is enabled + * is_ust_marker_enabled - Check if a ust_marker is enabled * @channel: channel name - * @name: marker name + * @name: ust_marker name * - * Returns 1 if the marker is enabled, 0 if disabled. + * Returns 1 if the ust_marker is enabled, 0 if disabled. */ -int is_marker_enabled(const char *channel, const char *name) +int is_ust_marker_enabled(const char *channel, const char *name) { - struct marker_entry *entry; + struct ust_marker_entry *entry; - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); + pthread_mutex_unlock(&ust_marker_mutex); return entry && !!entry->refcount; } /** - * marker_update_probe_range - Update a probe range + * ust_marker_update_probe_range - Update a probe range * @begin: beginning of the range * @end: end of the range * - * Updates the probe callback corresponding to a range of markers. + * Updates the probe callback corresponding to a range of ust_marker. */ -void marker_update_probe_range(struct marker * const *begin, - struct marker * const *end) +void ust_marker_update_probe_range(struct ust_marker * const *begin, + struct ust_marker * const *end) { - struct marker * const *iter; - struct marker_entry *mark_entry; + struct ust_marker * const *iter; + struct ust_marker_entry *mark_entry; - pthread_mutex_lock(&markers_mutex); + pthread_mutex_lock(&ust_marker_mutex); for (iter = begin; iter < end; iter++) { if (!*iter) continue; /* skip dummy */ - mark_entry = get_marker((*iter)->channel, (*iter)->name); + mark_entry = get_ust_marker((*iter)->channel, (*iter)->name); if (mark_entry) { - set_marker(mark_entry, *iter, !!mark_entry->refcount); + set_ust_marker(mark_entry, *iter, !!mark_entry->refcount); /* * ignore error, continue */ } else { - disable_marker(*iter); + disable_ust_marker(*iter); } } - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); } -static void lib_update_markers(void) +static void lib_update_ust_marker(void) { - struct lib *lib; + struct ust_marker_lib *lib; /* FIXME: we should probably take a mutex here on libs */ //ust// pthread_mutex_lock(&module_mutex); - cds_list_for_each_entry(lib, &libs, list) - marker_update_probe_range(lib->markers_start, - lib->markers_start + lib->markers_count); + cds_list_for_each_entry(lib, &ust_marker_libs, list) + ust_marker_update_probe_range(lib->ust_marker_start, + lib->ust_marker_start + lib->ust_marker_count); //ust// pthread_mutex_unlock(&module_mutex); } @@ -726,23 +727,23 @@ static void lib_update_markers(void) * 1 -> 2 callbacks * 2 -> 1 callbacks * Other updates all behave the same, just like the 2 -> 3 or 3 -> 2 updates. - * Site effect : marker_set_format may delete the marker entry (creating a + * Site effect : ust_marker_set_format may delete the ust_marker entry (creating a * replacement). */ -static void marker_update_probes(void) +static void ust_marker_update_probes(void) { - lib_update_markers(); + lib_update_ust_marker(); tracepoint_probe_update_all(); /* Update immediate values */ core_imv_update(); //ust// module_imv_update(); /* FIXME: need to port for libs? */ - marker_update_processes(); + ust_marker_update_processes(); } /** - * marker_probe_register - Connect a probe to a marker - * @channel: marker channel - * @name: marker name + * ust_marker_probe_register - Connect a probe to a ust_marker + * @channel: ust_marker channel + * @name: ust_marker name * @format: format string * @probe: probe handler * @probe_private: probe private data @@ -751,27 +752,27 @@ static void marker_update_probes(void) * Returns 0 if ok, error value on error. * The probe address must at least be aligned on the architecture pointer size. */ -int marker_probe_register(const char *channel, const char *name, - const char *format, marker_probe_func *probe, +int ust_marker_probe_register(const char *channel, const char *name, + const char *format, ust_marker_probe_func *probe, void *probe_private) { - struct marker_entry *entry; + struct ust_marker_entry *entry; int ret = 0, ret_err; - struct marker_probe_closure *old; + struct ust_marker_probe_closure *old; int first_probe = 0; - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); if (!entry) { first_probe = 1; - entry = add_marker(channel, name, format); + entry = add_ust_marker(channel, name, format); if (IS_ERR(entry)) ret = PTR_ERR(entry); if (ret) goto end; ret = ltt_channels_register(channel); if (ret) - goto error_remove_marker; + goto error_remove_ust_marker; ret = ltt_channels_get_index_from_name(channel); if (ret < 0) goto error_unregister_channel; @@ -790,7 +791,7 @@ int marker_probe_register(const char *channel, const char *name, sizeof(size_t), ltt_get_alignment()); } else if (format) { if (!entry->format) - ret = marker_set_format(entry, format); + ret = ust_marker_set_format(entry, format); else if (strcmp(entry->format, format)) ret = -EPERM; if (ret) @@ -798,12 +799,12 @@ int marker_probe_register(const char *channel, const char *name, } /* - * If we detect that a call_rcu is pending for this marker, + * If we detect that a call_rcu is pending for this ust_marker, * make sure it's executed now. */ //ust// if (entry->rcu_pending) //ust// rcu_cmm_barrier_sched(); - old = marker_entry_add_probe(entry, probe, probe_private); + old = ust_marker_entry_add_probe(entry, probe, probe_private); if (IS_ERR(old)) { ret = PTR_ERR(old); if (first_probe) @@ -811,13 +812,13 @@ int marker_probe_register(const char *channel, const char *name, else goto end; } - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); - /* Activate marker if necessary */ - marker_update_probes(); + /* Activate ust_marker if necessary */ + ust_marker_update_probes(); - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); if (!entry) goto end; //ust// if (entry->rcu_pending) @@ -833,48 +834,48 @@ int marker_probe_register(const char *channel, const char *name, error_unregister_channel: ret_err = ltt_channels_unregister(channel); WARN_ON(ret_err); -error_remove_marker: - ret_err = remove_marker(channel, name); +error_remove_ust_marker: + ret_err = remove_ust_marker(channel, name); WARN_ON(ret_err); end: - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); return ret; } -//ust// EXPORT_SYMBOL_GPL(marker_probe_register); +//ust// EXPORT_SYMBOL_GPL(ust_marker_probe_register); /** - * marker_probe_unregister - Disconnect a probe from a marker - * @channel: marker channel - * @name: marker name + * ust_marker_probe_unregister - Disconnect a probe from a ust_marker + * @channel: ust_marker channel + * @name: ust_marker name * @probe: probe function pointer * @probe_private: probe private data * - * Returns the private data given to marker_probe_register, or an ERR_PTR(). + * Returns the private data given to ust_marker_probe_register, or an ERR_PTR(). * We do not need to call a synchronize_sched to make sure the probes have * finished running before doing a module unload, because the module unload * itself uses stop_machine(), which insures that every preempt disabled section * have finished. */ -int marker_probe_unregister(const char *channel, const char *name, - marker_probe_func *probe, void *probe_private) +int ust_marker_probe_unregister(const char *channel, const char *name, + ust_marker_probe_func *probe, void *probe_private) { - struct marker_entry *entry; - struct marker_probe_closure *old; + struct ust_marker_entry *entry; + struct ust_marker_probe_closure *old; int ret = -ENOENT; - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); if (!entry) goto end; //ust// if (entry->rcu_pending) //ust// rcu_cmm_barrier_sched(); - old = marker_entry_remove_probe(entry, probe, probe_private); - pthread_mutex_unlock(&markers_mutex); + old = ust_marker_entry_remove_probe(entry, probe, probe_private); + pthread_mutex_unlock(&ust_marker_mutex); - marker_update_probes(); + ust_marker_update_probes(); - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); if (!entry) goto end; //ust// if (entry->rcu_pending) @@ -885,24 +886,24 @@ int marker_probe_unregister(const char *channel, const char *name, cmm_smp_wmb(); //ust// call_rcu_sched(&entry->rcu, free_old_closure); synchronize_rcu(); free_old_closure(&entry->rcu); - remove_marker(channel, name); /* Ignore busy error message */ + remove_ust_marker(channel, name); /* Ignore busy error message */ ret = 0; end: - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); return ret; } -//ust// EXPORT_SYMBOL_GPL(marker_probe_unregister); +//ust// EXPORT_SYMBOL_GPL(ust_marker_probe_unregister); -static struct marker_entry * -get_marker_from_private_data(marker_probe_func *probe, void *probe_private) +static struct ust_marker_entry * +get_ust_marker_from_private_data(ust_marker_probe_func *probe, void *probe_private) { - struct marker_entry *entry; + struct ust_marker_entry *entry; unsigned int i; struct cds_hlist_head *head; struct cds_hlist_node *node; - for (i = 0; i < MARKER_TABLE_SIZE; i++) { - head = &marker_table[i]; + for (i = 0; i < ust_marker_TABLE_SIZE; i++) { + head = &ust_marker_table[i]; cds_hlist_for_each_entry(entry, node, head, hlist) { if (!entry->ptype) { if (entry->single.func == probe @@ -910,7 +911,7 @@ get_marker_from_private_data(marker_probe_func *probe, void *probe_private) == probe_private) return entry; } else { - struct marker_probe_closure *closure; + struct ust_marker_probe_closure *closure; closure = entry->multi; for (i = 0; closure[i].func; i++) { if (closure[i].func == probe && @@ -925,43 +926,43 @@ get_marker_from_private_data(marker_probe_func *probe, void *probe_private) } /** - * marker_probe_unregister_private_data - Disconnect a probe from a marker + * ust_marker_probe_unregister_private_data - Disconnect a probe from a ust_marker * @probe: probe function * @probe_private: probe private data * * Unregister a probe by providing the registered private data. - * Only removes the first marker found in hash table. + * Only removes the first ust_marker found in hash table. * Return 0 on success or error value. * We do not need to call a synchronize_sched to make sure the probes have * finished running before doing a module unload, because the module unload * itself uses stop_machine(), which insures that every preempt disabled section * have finished. */ -int marker_probe_unregister_private_data(marker_probe_func *probe, +int ust_marker_probe_unregister_private_data(ust_marker_probe_func *probe, void *probe_private) { - struct marker_entry *entry; + struct ust_marker_entry *entry; int ret = 0; - struct marker_probe_closure *old; + struct ust_marker_probe_closure *old; char *channel = NULL, *name = NULL; - pthread_mutex_lock(&markers_mutex); - entry = get_marker_from_private_data(probe, probe_private); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker_from_private_data(probe, probe_private); if (!entry) { ret = -ENOENT; goto end; } //ust// if (entry->rcu_pending) //ust// rcu_cmm_barrier_sched(); - old = marker_entry_remove_probe(entry, NULL, probe_private); + old = ust_marker_entry_remove_probe(entry, NULL, probe_private); channel = strdup(entry->channel); name = strdup(entry->name); - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); - marker_update_probes(); + ust_marker_update_probes(); - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); if (!entry) goto end; //ust// if (entry->rcu_pending) @@ -973,19 +974,19 @@ int marker_probe_unregister_private_data(marker_probe_func *probe, //ust// call_rcu_sched(&entry->rcu, free_old_closure); synchronize_rcu(); free_old_closure(&entry->rcu); /* Ignore busy error message */ - remove_marker(channel, name); + remove_ust_marker(channel, name); end: - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); free(channel); free(name); return ret; } -//ust// EXPORT_SYMBOL_GPL(marker_probe_unregister_private_data); +//ust// EXPORT_SYMBOL_GPL(ust_marker_probe_unregister_private_data); /** - * marker_get_private_data - Get a marker's probe private data - * @channel: marker channel - * @name: marker name + * ust_marker_get_private_data - Get a ust_marker's probe private data + * @channel: ust_marker channel + * @name: ust_marker name * @probe: probe to match * @num: get the nth matching probe's private data * @@ -996,26 +997,26 @@ end: * owner of the data, or its content could vanish. This is mostly used to * confirm that a caller is the owner of a registered probe. */ -void *marker_get_private_data(const char *channel, const char *name, - marker_probe_func *probe, int num) +void *ust_marker_get_private_data(const char *channel, const char *name, + ust_marker_probe_func *probe, int num) { struct cds_hlist_head *head; struct cds_hlist_node *node; - struct marker_entry *e; + struct ust_marker_entry *e; size_t channel_len = strlen(channel) + 1; size_t name_len = strlen(name) + 1; int i; u32 hash; hash = jhash(channel, channel_len-1, 0) ^ jhash(name, name_len-1, 0); - head = &marker_table[hash & ((1 << MARKER_HASH_BITS)-1)]; + head = &ust_marker_table[hash & ((1 << ust_marker_HASH_BITS)-1)]; cds_hlist_for_each_entry(e, node, head, hlist) { if (!strcmp(channel, e->channel) && !strcmp(name, e->name)) { if (!e->ptype) { if (num == 0 && e->single.func == probe) return e->single.probe_private; } else { - struct marker_probe_closure *closure; + struct ust_marker_probe_closure *closure; int match = 0; closure = e->multi; for (i = 0; closure[i].func; i++) { @@ -1030,24 +1031,24 @@ void *marker_get_private_data(const char *channel, const char *name, } return ERR_PTR(-ENOENT); } -//ust// EXPORT_SYMBOL_GPL(marker_get_private_data); +//ust// EXPORT_SYMBOL_GPL(ust_marker_get_private_data); /** - * markers_compact_event_ids - Compact markers event IDs and reassign channels + * ust_marker_compact_event_ids - Compact ust_marker event IDs and reassign channels * * Called when no channel users are active by the channel infrastructure. - * Called with lock_markers() and channel mutex held. + * Called with lock_ust_marker() and channel mutex held. */ -//ust// void markers_compact_event_ids(void) +//ust// void ust_marker_compact_event_ids(void) //ust// { -//ust// struct marker_entry *entry; +//ust// struct ust_marker_entry *entry; //ust// unsigned int i; //ust// struct hlist_head *head; //ust// struct hlist_node *node; //ust// int ret; //ust// -//ust// for (i = 0; i < MARKER_TABLE_SIZE; i++) { -//ust// head = &marker_table[i]; +//ust// for (i = 0; i < ust_marker_TABLE_SIZE; i++) { +//ust// head = &ust_marker_table[i]; //ust// hlist_for_each_entry(entry, node, head, hlist) { //ust// ret = ltt_channels_get_index_from_name(entry->channel); //ust// WARN_ON(ret < 0); @@ -1066,20 +1067,20 @@ void *marker_get_private_data(const char *channel, const char *name, * Returns 0 if current not found. * Returns 1 if current found. */ -int lib_get_iter_markers(struct marker_iter *iter) +int lib_get_iter_ust_marker(struct ust_marker_iter *iter) { - struct lib *iter_lib; + struct ust_marker_lib *iter_lib; int found = 0; //ust// pthread_mutex_lock(&module_mutex); - cds_list_for_each_entry(iter_lib, &libs, list) { + cds_list_for_each_entry(iter_lib, &ust_marker_libs, list) { if (iter_lib < iter->lib) continue; else if (iter_lib > iter->lib) - iter->marker = NULL; - found = marker_get_iter_range(&iter->marker, - iter_lib->markers_start, - iter_lib->markers_start + iter_lib->markers_count); + iter->ust_marker = NULL; + found = ust_marker_get_iter_range(&iter->ust_marker, + iter_lib->ust_marker_start, + iter_lib->ust_marker_start + iter_lib->ust_marker_count); if (found) { iter->lib = iter_lib; break; @@ -1090,76 +1091,76 @@ int lib_get_iter_markers(struct marker_iter *iter) } /** - * marker_get_iter_range - Get a next marker iterator given a range. - * @marker: current markers (in), next marker (out) + * ust_marker_get_iter_range - Get a next ust_marker iterator given a range. + * @ust_marker: current ust_marker (in), next ust_marker (out) * @begin: beginning of the range * @end: end of the range * - * Returns whether a next marker has been found (1) or not (0). - * Will return the first marker in the range if the input marker is NULL. + * Returns whether a next ust_marker has been found (1) or not (0). + * Will return the first ust_marker in the range if the input ust_marker is NULL. */ -int marker_get_iter_range(struct marker * const **marker, - struct marker * const *begin, - struct marker * const *end) +int ust_marker_get_iter_range(struct ust_marker * const **ust_marker, + struct ust_marker * const *begin, + struct ust_marker * const *end) { - if (!*marker && begin != end) - *marker = begin; - while (*marker >= begin && *marker < end) { - if (!**marker) - (*marker)++; /* skip dummy */ + if (!*ust_marker && begin != end) + *ust_marker = begin; + while (*ust_marker >= begin && *ust_marker < end) { + if (!**ust_marker) + (*ust_marker)++; /* skip dummy */ else return 1; } return 0; } -//ust// EXPORT_SYMBOL_GPL(marker_get_iter_range); +//ust// EXPORT_SYMBOL_GPL(ust_marker_get_iter_range); -static void marker_get_iter(struct marker_iter *iter) +static void ust_marker_get_iter(struct ust_marker_iter *iter) { int found = 0; - found = lib_get_iter_markers(iter); + found = lib_get_iter_ust_marker(iter); if (!found) - marker_iter_reset(iter); + ust_marker_iter_reset(iter); } -void marker_iter_start(struct marker_iter *iter) +void ust_marker_iter_start(struct ust_marker_iter *iter) { - marker_get_iter(iter); + ust_marker_get_iter(iter); } -//ust// EXPORT_SYMBOL_GPL(marker_iter_start); +//ust// EXPORT_SYMBOL_GPL(ust_marker_iter_start); -void marker_iter_next(struct marker_iter *iter) +void ust_marker_iter_next(struct ust_marker_iter *iter) { - iter->marker++; + iter->ust_marker++; /* - * iter->marker may be invalid because we blindly incremented it. - * Make sure it is valid by marshalling on the markers, getting the - * markers from following modules if necessary. + * iter->ust_marker may be invalid because we blindly incremented it. + * Make sure it is valid by marshalling on the ust_marker, getting the + * ust_marker from following modules if necessary. */ - marker_get_iter(iter); + ust_marker_get_iter(iter); } -//ust// EXPORT_SYMBOL_GPL(marker_iter_next); +//ust// EXPORT_SYMBOL_GPL(ust_marker_iter_next); -void marker_iter_stop(struct marker_iter *iter) +void ust_marker_iter_stop(struct ust_marker_iter *iter) { } -//ust// EXPORT_SYMBOL_GPL(marker_iter_stop); +//ust// EXPORT_SYMBOL_GPL(ust_marker_iter_stop); -void marker_iter_reset(struct marker_iter *iter) +void ust_marker_iter_reset(struct ust_marker_iter *iter) { iter->lib = NULL; - iter->marker = NULL; + iter->ust_marker = NULL; } -//ust// EXPORT_SYMBOL_GPL(marker_iter_reset); +//ust// EXPORT_SYMBOL_GPL(ust_marker_iter_reset); -#ifdef CONFIG_MARKERS_USERSPACE +#ifdef CONFIG_UST_MARKER_USERSPACE /* - * must be called with current->user_markers_mutex held + * must be called with current->user_ust_marker_mutex held */ -static void free_user_marker(char __user *state, struct cds_hlist_head *head) +static void free_user_ust_marker(char __user *state, struct cds_hlist_head *head) { - struct user_marker *umark; + struct user_ust_marker *umark; struct cds_hlist_node *pos, *n; cds_hlist_for_each_entry_safe(umark, pos, n, head, hlist) { @@ -1173,23 +1174,23 @@ static void free_user_marker(char __user *state, struct cds_hlist_head *head) /* * Update current process. * Note that we have to wait a whole scheduler period before we are sure that - * every running userspace threads have their markers updated. + * every running userspace threads have their ust_marker updated. * (synchronize_sched() can be used to insure this). */ -//ust// void marker_update_process(void) +//ust// void ust_marker_update_process(void) //ust// { -//ust// struct user_marker *umark; +//ust// struct user_ust_marker *umark; //ust// struct hlist_node *pos; -//ust// struct marker_entry *entry; +//ust// struct ust_marker_entry *entry; //ust// -//ust// pthread_mutex_lock(&markers_mutex); -//ust// pthread_mutex_lock(¤t->group_leader->user_markers_mutex); +//ust// pthread_mutex_lock(&ust_marker_mutex); +//ust// pthread_mutex_lock(¤t->group_leader->user_ust_marker_mutex); //ust// if (strcmp(current->comm, "testprog") == 0) //ust// DBG("do update pending for testprog"); //ust// hlist_for_each_entry(umark, pos, -//ust// ¤t->group_leader->user_markers, hlist) { -//ust// DBG("Updating marker %s in %s", umark->name, current->comm); -//ust// entry = get_marker("userspace", umark->name); +//ust// ¤t->group_leader->user_ust_marker, hlist) { +//ust// DBG("Updating ust_marker %s in %s", umark->name, current->comm); +//ust// entry = get_ust_marker("userspace", umark->name); //ust// if (entry) { //ust// if (entry->format && //ust// strcmp(entry->format, umark->format) != 0) { @@ -1198,20 +1199,20 @@ static void free_user_marker(char __user *state, struct cds_hlist_head *head) //ust// break; //ust// } //ust// if (put_user(!!entry->refcount, umark->state)) { -//ust// WARN("Marker in %s caused a fault", +//ust// WARN("ust_marker in %s caused a fault", //ust// current->comm); //ust// break; //ust// } //ust// } else { //ust// if (put_user(0, umark->state)) { -//ust// WARN("Marker in %s caused a fault", current->comm); +//ust// WARN("ust_marker in %s caused a fault", current->comm); //ust// break; //ust// } //ust// } //ust// } -//ust// clear_thread_flag(TIF_MARKER_PENDING); -//ust// pthread_mutex_unlock(¤t->group_leader->user_markers_mutex); -//ust// pthread_mutex_unlock(&markers_mutex); +//ust// clear_thread_flag(TIF_ust_marker_PENDING); +//ust// pthread_mutex_unlock(¤t->group_leader->user_ust_marker_mutex); +//ust// pthread_mutex_unlock(&ust_marker_mutex); //ust// } /* @@ -1219,82 +1220,82 @@ static void free_user_marker(char __user *state, struct cds_hlist_head *head) * We assume that when the leader exits, no more references can be done to the * leader structure by the other threads. */ -void exit_user_markers(struct task_struct *p) +void exit_user_ust_marker(struct task_struct *p) { - struct user_marker *umark; + struct user_ust_marker *umark; struct cds_hlist_node *pos, *n; if (thread_group_leader(p)) { - pthread_mutex_lock(&markers_mutex); - pthread_mutex_lock(&p->user_markers_mutex); - cds_hlist_for_each_entry_safe(umark, pos, n, &p->user_markers, + pthread_mutex_lock(&ust_marker_mutex); + pthread_mutex_lock(&p->user_ust_marker_mutex); + cds_hlist_for_each_entry_safe(umark, pos, n, &p->user_ust_marker, hlist) free(umark); - INIT_HLIST_HEAD(&p->user_markers); - p->user_markers_sequence++; - pthread_mutex_unlock(&p->user_markers_mutex); - pthread_mutex_unlock(&markers_mutex); + INIT_HLIST_HEAD(&p->user_ust_marker); + p->user_ust_marker_sequence++; + pthread_mutex_unlock(&p->user_ust_marker_mutex); + pthread_mutex_unlock(&ust_marker_mutex); } } -int is_marker_enabled(const char *channel, const char *name) +int is_ust_marker_enabled(const char *channel, const char *name) { - struct marker_entry *entry; + struct ust_marker_entry *entry; - pthread_mutex_lock(&markers_mutex); - entry = get_marker(channel, name); - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_lock(&ust_marker_mutex); + entry = get_ust_marker(channel, name); + pthread_mutex_unlock(&ust_marker_mutex); return entry && !!entry->refcount; } //ust// #endif -int marker_module_notify(struct notifier_block *self, +int ust_marker_module_notify(struct notifier_block *self, unsigned long val, void *data) { struct module *mod = data; switch (val) { case MODULE_STATE_COMING: - marker_update_probe_range(mod->markers, - mod->markers + mod->num_markers); + ust_marker_update_probe_range(mod->ust_marker, + mod->ust_marker + mod->num_ust_marker); break; case MODULE_STATE_GOING: - marker_update_probe_range(mod->markers, - mod->markers + mod->num_markers); + ust_marker_update_probe_range(mod->ust_marker, + mod->ust_marker + mod->num_ust_marker); break; } return 0; } -struct notifier_block marker_module_nb = { - .notifier_call = marker_module_notify, +struct notifier_block ust_marker_module_nb = { + .notifier_call = ust_marker_module_notify, .priority = 0, }; -//ust// static int init_markers(void) +//ust// static int init_ust_marker(void) //ust// { -//ust// return register_module_notifier(&marker_module_nb); +//ust// return register_module_notifier(&ust_marker_module_nb); //ust// } -//ust// __initcall(init_markers); -/* TODO: call marker_module_nb() when a library is linked at runtime (dlopen)? */ +//ust// __initcall(init_ust_marker); +/* TODO: call ust_marker_module_nb() when a library is linked at runtime (dlopen)? */ #endif /* CONFIG_MODULES */ -void ltt_dump_marker_state(struct ust_trace *trace) +void ltt_dump_ust_marker_state(struct ust_trace *trace) { - struct marker_entry *entry; + struct ust_marker_entry *entry; struct ltt_probe_private_data call_data; struct cds_hlist_head *head; struct cds_hlist_node *node; unsigned int i; - pthread_mutex_lock(&markers_mutex); + pthread_mutex_lock(&ust_marker_mutex); call_data.trace = trace; call_data.serializer = NULL; - for (i = 0; i < MARKER_TABLE_SIZE; i++) { - head = &marker_table[i]; + for (i = 0; i < ust_marker_TABLE_SIZE; i++) { + head = &ust_marker_table[i]; cds_hlist_for_each_entry(entry, node, head, hlist) { __ust_marker(0, metadata, core_marker_id, &call_data, @@ -1317,45 +1318,45 @@ void ltt_dump_marker_state(struct ust_trace *trace) entry->format); } } - pthread_mutex_unlock(&markers_mutex); + pthread_mutex_unlock(&ust_marker_mutex); } -//ust// EXPORT_SYMBOL_GPL(ltt_dump_marker_state); +//ust// EXPORT_SYMBOL_GPL(ltt_dump_ust_marker_state); -static void (*new_marker_cb)(struct marker *) = NULL; +static void (*new_ust_marker_cb)(struct ust_marker *) = NULL; -void marker_set_new_marker_cb(void (*cb)(struct marker *)) +void ust_marker_set_new_ust_marker_cb(void (*cb)(struct ust_marker *)) { - new_marker_cb = cb; + new_ust_marker_cb = cb; } -static void new_markers(struct marker * const *start, struct marker * const *end) +static void new_ust_marker(struct ust_marker * const *start, struct ust_marker * const *end) { - if (new_marker_cb) { - struct marker * const *m; + if (new_ust_marker_cb) { + struct ust_marker * const *m; for(m = start; m < end; m++) { if (*m) - new_marker_cb(*m); + new_ust_marker_cb(*m); } } } -int marker_register_lib(struct marker * const *markers_start, int markers_count) +int ust_marker_register_lib(struct ust_marker * const *ust_marker_start, int ust_marker_count) { - struct lib *pl, *iter; + struct ust_marker_lib *pl, *iter; - pl = (struct lib *) zmalloc(sizeof(struct lib)); + pl = (struct ust_marker_lib *) zmalloc(sizeof(struct ust_marker_lib)); - pl->markers_start = markers_start; - pl->markers_count = markers_count; + pl->ust_marker_start = ust_marker_start; + pl->ust_marker_count = ust_marker_count; /* FIXME: maybe protect this with its own mutex? */ - lock_markers(); + lock_ust_marker(); /* * We sort the libs by struct lib pointer address. */ - cds_list_for_each_entry_reverse(iter, &libs, list) { + cds_list_for_each_entry_reverse(iter, &ust_marker_libs, list) { BUG_ON(iter == pl); /* Should never be in the list twice */ if (iter < pl) { /* We belong to the location right after iter. */ @@ -1364,58 +1365,58 @@ int marker_register_lib(struct marker * const *markers_start, int markers_count) } } /* We should be added at the head of the list */ - cds_list_add(&pl->list, &libs); + cds_list_add(&pl->list, &ust_marker_libs); lib_added: - unlock_markers(); + unlock_ust_marker(); - new_markers(markers_start, markers_start + markers_count); + new_ust_marker(ust_marker_start, ust_marker_start + ust_marker_count); /* FIXME: update just the loaded lib */ - lib_update_markers(); + lib_update_ust_marker(); - DBG("just registered a markers section from %p and having %d markers (minus dummy markers)", markers_start, markers_count); + DBG("just registered a ust_marker section from %p and having %d ust_marker (minus dummy ust_marker)", ust_marker_start, ust_marker_count); return 0; } -int marker_unregister_lib(struct marker * const *markers_start) +int ust_marker_unregister_lib(struct ust_marker * const *ust_marker_start) { - struct lib *lib; + struct ust_marker_lib *lib; - /*FIXME: implement; but before implementing, marker_register_lib must + /*FIXME: implement; but before implementing, ust_marker_register_lib must have appropriate locking. */ - lock_markers(); + lock_ust_marker(); /* FIXME: we should probably take a mutex here on libs */ //ust// pthread_mutex_lock(&module_mutex); - cds_list_for_each_entry(lib, &libs, list) { - if(lib->markers_start == markers_start) { - struct lib *lib2free = lib; + cds_list_for_each_entry(lib, &ust_marker_libs, list) { + if(lib->ust_marker_start == ust_marker_start) { + struct ust_marker_lib *lib2free = lib; cds_list_del(&lib->list); free(lib2free); break; } } - unlock_markers(); + unlock_ust_marker(); return 0; } static int initialized = 0; -void __attribute__((constructor)) init_markers(void) +void __attribute__((constructor)) init_ust_marker(void) { if (!initialized) { - marker_register_lib(__start___markers_ptrs, - __stop___markers_ptrs - - __start___markers_ptrs); + ust_marker_register_lib(__start___ust_marker_ptrs, + __stop___ust_marker_ptrs + - __start___ust_marker_ptrs); initialized = 1; } } -void __attribute__((destructor)) destroy_markers(void) +void __attribute__((destructor)) destroy_ust_marker(void) { - marker_unregister_lib(__start___markers_ptrs); + ust_marker_unregister_lib(__start___ust_marker_ptrs); } diff --git a/libust/serialize.c b/libust/serialize.c index c637786..31174d8 100644 --- a/libust/serialize.c +++ b/libust/serialize.c @@ -624,12 +624,12 @@ void ltt_write_event_data(struct ust_buffer *buf, size_t buf_offset, } -notrace void ltt_vtrace(const struct marker *mdata, void *probe_data, +notrace void ltt_vtrace(const struct ust_marker *mdata, void *probe_data, struct registers *regs, void *call_data, const char *fmt, va_list *args) { int largest_align, ret; - struct ltt_active_marker *pdata; + struct ltt_active_ust_marker *pdata; uint16_t eID; size_t data_size, slot_size; unsigned int chan_index; @@ -661,7 +661,7 @@ notrace void ltt_vtrace(const struct marker *mdata, void *probe_data, stack_pos_ctx = tracer_stack_pos; cmm_barrier(); - pdata = (struct ltt_active_marker *)probe_data; + pdata = (struct ltt_active_ust_marker *)probe_data; eID = mdata->event_id; chan_index = mdata->channel_id; closure.callbacks = pdata->probe->callbacks; @@ -752,7 +752,7 @@ notrace void ltt_vtrace(const struct marker *mdata, void *probe_data, rcu_read_unlock(); //ust// rcu_read_unlock_sched_notrace(); } -notrace void ltt_trace(const struct marker *mdata, void *probe_data, +notrace void ltt_trace(const struct ust_marker *mdata, void *probe_data, struct registers *regs, void *call_data, const char *fmt, ...) { diff --git a/libust/tracectl.c b/libust/tracectl.c index 4d93cc6..414162c 100644 --- a/libust/tracectl.c +++ b/libust/tracectl.c @@ -98,24 +98,24 @@ static long long make_pidunique(void) return retval; } -static void print_markers(FILE *fp) +static void print_ust_marker(FILE *fp) { - struct marker_iter iter; - - lock_markers(); - marker_iter_reset(&iter); - marker_iter_start(&iter); - - while (iter.marker) { - fprintf(fp, "marker: %s/%s %d \"%s\" %p\n", - (*iter.marker)->channel, - (*iter.marker)->name, - (int)imv_read((*iter.marker)->state), - (*iter.marker)->format, - (*iter.marker)->location); - marker_iter_next(&iter); - } - unlock_markers(); + struct ust_marker_iter iter; + + lock_ust_marker(); + ust_marker_iter_reset(&iter); + ust_marker_iter_start(&iter); + + while (iter.ust_marker) { + fprintf(fp, "ust_marker: %s/%s %d \"%s\" %p\n", + (*iter.ust_marker)->channel, + (*iter.ust_marker)->name, + (int)imv_read((*iter.ust_marker)->state), + (*iter.ust_marker)->format, + (*iter.ust_marker)->location); + ust_marker_iter_next(&iter); + } + unlock_ust_marker(); } static void print_trace_events(FILE *fp) @@ -830,8 +830,8 @@ static void process_buffer_cmd(int sock, int command, } -static void process_marker_cmd(int sock, int command, - struct ustcomm_marker_info *marker_inf) +static void process_ust_marker_cmd(int sock, int command, + struct ustcomm_ust_marker_info *ust_marker_inf) { struct ustcomm_header _reply_header; struct ustcomm_header *reply_header = &_reply_header; @@ -842,26 +842,26 @@ static void process_marker_cmd(int sock, int command, switch(command) { case ENABLE_MARKER: - result = ltt_marker_connect(marker_inf->channel, - marker_inf->marker, + result = ltt_ust_marker_connect(ust_marker_inf->channel, + ust_marker_inf->ust_marker, "default"); if (result < 0) { - WARN("could not enable marker; channel=%s," + WARN("could not enable ust_marker; channel=%s," " name=%s", - marker_inf->channel, - marker_inf->marker); + ust_marker_inf->channel, + ust_marker_inf->ust_marker); } break; case DISABLE_MARKER: - result = ltt_marker_disconnect(marker_inf->channel, - marker_inf->marker, + result = ltt_ust_marker_disconnect(ust_marker_inf->channel, + ust_marker_inf->ust_marker, "default"); if (result < 0) { - WARN("could not disable marker; channel=%s," + WARN("could not disable ust_marker; channel=%s," " name=%s", - marker_inf->channel, - marker_inf->marker); + ust_marker_inf->channel, + ust_marker_inf->ust_marker); } break; } @@ -919,15 +919,15 @@ static void process_client_cmd(struct ustcomm_header *recv_header, case ENABLE_MARKER: case DISABLE_MARKER: { - struct ustcomm_marker_info *marker_inf; - marker_inf = (struct ustcomm_marker_info *)recv_buf; - result = ustcomm_unpack_marker_info(marker_inf); + struct ustcomm_ust_marker_info *ust_marker_inf; + ust_marker_inf = (struct ustcomm_ust_marker_info *)recv_buf; + result = ustcomm_unpack_ust_marker_info(ust_marker_inf); if (result < 0) { - ERR("couldn't unpack marker info"); + ERR("couldn't unpack ust_marker info"); reply_header->result = -EINVAL; goto send_response; } - process_marker_cmd(sock, recv_header->command, marker_inf); + process_ust_marker_cmd(sock, recv_header->command, ust_marker_inf); return; } case LIST_MARKERS: @@ -941,7 +941,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header, ERR("opening memstream failed"); return; } - print_markers(fp); + print_ust_marker(fp); fclose(fp); reply_header->size = size + 1; /* Include final \0 */ @@ -951,7 +951,7 @@ static void process_client_cmd(struct ustcomm_header *recv_header, free(ptr); if (result < 0) { - PERROR("failed to send markers list"); + PERROR("failed to send ust_marker list"); } break; @@ -1188,7 +1188,7 @@ void create_listener(void) static int autoprobe_method = AUTOPROBE_DISABLED; static regex_t autoprobe_regex; -static void auto_probe_connect(struct marker *m) +static void auto_probe_connect(struct ust_marker *m) { int result; @@ -1200,7 +1200,7 @@ static void auto_probe_connect(struct marker *m) } else if (autoprobe_method == AUTOPROBE_ENABLE_REGEX) { result = asprintf(&concat_name, "%s/%s", m->channel, m->name); if (result == -1) { - ERR("auto_probe_connect: asprintf failed (marker %s/%s)", + ERR("auto_probe_connect: asprintf failed (ust_marker %s/%s)", m->channel, m->name); return; } @@ -1211,11 +1211,11 @@ static void auto_probe_connect(struct marker *m) free(concat_name); } - result = ltt_marker_connect(m->channel, m->name, probe_name); + result = ltt_ust_marker_connect(m->channel, m->name, probe_name); if (result && result != -EEXIST) - ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m->channel, m->name, -result); + ERR("ltt_ust_marker_connect (ust_marker = %s/%s, errno = %d)", m->channel, m->name, -result); - DBG("auto connected marker %s (addr: %p) %s to probe default", m->channel, m, m->name); + DBG("auto connected ust_marker %s (addr: %p) %s to probe default", m->channel, m, m->name); } @@ -1305,18 +1305,18 @@ static void __attribute__((constructor)) init() autoprobe_val = getenv("UST_AUTOPROBE"); if (autoprobe_val) { - struct marker_iter iter; + struct ust_marker_iter iter; DBG("Autoprobe enabled."); - /* Ensure markers are initialized */ - //init_markers(); + /* Ensure ust_marker are initialized */ + //init_ust_marker(); - /* Ensure marker control is initialized, for the probe */ - init_marker_control(); + /* Ensure ust_marker control is initialized, for the probe */ + init_ust_marker_control(); /* first, set the callback that will connect the - * probe on new markers + * probe on new ust_marker */ if (autoprobe_val[0] == '/') { result = regcomp(&autoprobe_regex, autoprobe_val+1, 0); @@ -1334,17 +1334,17 @@ static void __attribute__((constructor)) init() autoprobe_method = AUTOPROBE_ENABLE_ALL; } - marker_set_new_marker_cb(auto_probe_connect); + ust_marker_set_new_ust_marker_cb(auto_probe_connect); /* Now, connect the probes that were already registered. */ - marker_iter_reset(&iter); - marker_iter_start(&iter); - - DBG("now iterating on markers already registered"); - while (iter.marker) { - DBG("now iterating on marker %s", (*iter.marker)->name); - auto_probe_connect(*iter.marker); - marker_iter_next(&iter); + ust_marker_iter_reset(&iter); + ust_marker_iter_start(&iter); + + DBG("now iterating on ust_marker already registered"); + while (iter.ust_marker) { + DBG("now iterating on ust_marker %s", (*iter.ust_marker)->name); + auto_probe_connect(*iter.ust_marker); + ust_marker_iter_next(&iter); } } @@ -1389,11 +1389,11 @@ static void __attribute__((constructor)) init() DBG("starting early tracing"); - /* Ensure marker control is initialized */ - init_marker_control(); + /* Ensure ust_marker control is initialized */ + init_ust_marker_control(); - /* Ensure markers are initialized */ - init_markers(); + /* Ensure ust_marker are initialized */ + init_ust_marker(); /* Ensure buffers are initialized, for the transport to be available. * We are about to set a trace type and it will fail without this. @@ -1401,7 +1401,7 @@ static void __attribute__((constructor)) init() init_ustrelay_transport(); /* FIXME: When starting early tracing (here), depending on the - * order of constructors, it is very well possible some marker + * order of constructors, it is very well possible some ust_marker * sections are not yet registered. Because of this, some * channels may not be registered. Yet, we are about to ask the * daemon to collect the channels. Channels which are not yet @@ -1576,7 +1576,7 @@ static void __attribute__((destructor)) keepalive() void ust_potential_exec(void) { - ust_marker(potential_exec, MARK_NOARGS); + ust_marker(potential_exec, UST_MARKER_NOARGS); DBG("test"); diff --git a/libust/tracer.c b/libust/tracer.c index e2be0ae..347ca48 100644 --- a/libust/tracer.c +++ b/libust/tracer.c @@ -679,7 +679,7 @@ int ltt_trace_start(const char *trace_name) * to record events only in a single trace in the trace session list. */ - ltt_dump_marker_state(trace); + ltt_dump_ust_marker_state(trace); return err; diff --git a/libust/tracer.h b/libust/tracer.h index 2f489f6..5d7d4f6 100644 --- a/libust/tracer.h +++ b/libust/tracer.h @@ -48,9 +48,9 @@ #define LTT_ARCH_VARIANT LTT_ARCH_VARIANT_NONE #endif -struct ltt_active_marker; +struct ltt_active_ust_marker; -/* Maximum number of callbacks per marker */ +/* Maximum number of callbacks per ust_marker */ #define LTT_NR_CALLBACKS 10 struct ltt_serialize_closure; @@ -93,7 +93,7 @@ struct chan_info_struct { unsigned int def_subbufcount; }; -struct ltt_active_marker { +struct ltt_active_ust_marker { struct cds_list_head node; /* active markers list */ const char *channel; const char *name; @@ -101,30 +101,30 @@ struct ltt_active_marker { struct ltt_available_probe *probe; }; -struct marker; //ust// -extern void ltt_vtrace(const struct marker *mdata, void *probe_data, +struct ust_marker; //ust// +extern void ltt_vtrace(const struct ust_marker *mdata, void *probe_data, struct registers *regs, void *call_data, const char *fmt, va_list *args); -extern void ltt_trace(const struct marker *mdata, void *probe_data, +extern void ltt_trace(const struct ust_marker *mdata, void *probe_data, struct registers *regs, void *call_data, const char *fmt, ...); /* * Unique ID assigned to each registered probe. */ -enum marker_id { - MARKER_ID_SET_MARKER_ID = 0, /* Static IDs available (range 0-7) */ - MARKER_ID_SET_MARKER_FORMAT, - MARKER_ID_COMPACT, /* Compact IDs (range: 8-127) */ - MARKER_ID_DYNAMIC, /* Dynamic IDs (range: 128-65535) */ +enum ust_marker_id { + UST_MARKER_ID_SET_MARKER_ID = 0, /* Static IDs available (range 0-7) */ + UST_MARKER_ID_SET_MARKER_FORMAT, + UST_MARKER_ID_COMPACT, /* Compact IDs (range: 8-127) */ + UST_MARKER_ID_DYNAMIC, /* Dynamic IDs (range: 128-65535) */ }; /* static ids 0-1 reserved for internal use. */ -#define MARKER_CORE_IDS 2 -static __inline__ enum marker_id marker_id_type(uint16_t id) +#define UST_MARKER_CORE_IDS 2 +static __inline__ enum ust_marker_id ust_marker_id_type(uint16_t id) { - if (id < MARKER_CORE_IDS) - return (enum marker_id)id; + if (id < UST_MARKER_CORE_IDS) + return (enum ust_marker_id)id; else - return MARKER_ID_DYNAMIC; + return UST_MARKER_ID_DYNAMIC; } struct user_dbg_data { @@ -445,7 +445,7 @@ extern void ltt_core_unregister(void); extern void ltt_release_trace(struct urcu_ref *urcu_ref); extern void ltt_release_transport(struct urcu_ref *urcu_ref); -extern void ltt_dump_marker_state(struct ust_trace *trace); +extern void ltt_dump_ust_marker_state(struct ust_trace *trace); extern void ltt_lock_traces(void); extern void ltt_unlock_traces(void); diff --git a/libust/type-serializer.c b/libust/type-serializer.c index dcaea1e..261c09c 100644 --- a/libust/type-serializer.c +++ b/libust/type-serializer.c @@ -17,7 +17,7 @@ #include "tracer.h" notrace -void _ltt_specialized_trace(const struct marker *mdata, void *probe_data, +void _ltt_specialized_trace(const struct ust_marker *mdata, void *probe_data, void *serialize_private, unsigned int data_size, unsigned int largest_align) { diff --git a/libustcomm/ustcomm.c b/libustcomm/ustcomm.c index dcf8cd8..ed6d8f1 100644 --- a/libustcomm/ustcomm.c +++ b/libustcomm/ustcomm.c @@ -838,68 +838,68 @@ int ustcomm_unpack_buffer_info(struct ustcomm_buffer_info *buf_inf) return 0; } -int ustcomm_pack_marker_info(struct ustcomm_header *header, - struct ustcomm_marker_info *marker_inf, +int ustcomm_pack_ust_marker_info(struct ustcomm_header *header, + struct ustcomm_ust_marker_info *ust_marker_inf, const char *trace, const char *channel, - const char *marker) + const char *ust_marker) { int offset = 0; - marker_inf->trace = ustcomm_print_data(marker_inf->data, - sizeof(marker_inf->data), + ust_marker_inf->trace = ustcomm_print_data(ust_marker_inf->data, + sizeof(ust_marker_inf->data), &offset, trace); - if (marker_inf->trace == USTCOMM_POISON_PTR) { + if (ust_marker_inf->trace == USTCOMM_POISON_PTR) { return -ENOMEM; } - marker_inf->channel = ustcomm_print_data(marker_inf->data, - sizeof(marker_inf->data), + ust_marker_inf->channel = ustcomm_print_data(ust_marker_inf->data, + sizeof(ust_marker_inf->data), &offset, channel); - if (marker_inf->channel == USTCOMM_POISON_PTR) { + if (ust_marker_inf->channel == USTCOMM_POISON_PTR) { return -ENOMEM; } - marker_inf->marker = ustcomm_print_data(marker_inf->data, - sizeof(marker_inf->data), + ust_marker_inf->ust_marker = ustcomm_print_data(ust_marker_inf->data, + sizeof(ust_marker_inf->data), &offset, - marker); + ust_marker); - if (marker_inf->marker == USTCOMM_POISON_PTR) { + if (ust_marker_inf->ust_marker == USTCOMM_POISON_PTR) { return -ENOMEM; } - header->size = COMPUTE_MSG_SIZE(marker_inf, offset); + header->size = COMPUTE_MSG_SIZE(ust_marker_inf, offset); return 0; } -int ustcomm_unpack_marker_info(struct ustcomm_marker_info *marker_inf) +int ustcomm_unpack_ust_marker_info(struct ustcomm_ust_marker_info *ust_marker_inf) { - marker_inf->trace = ustcomm_restore_ptr(marker_inf->trace, - marker_inf->data, - sizeof(marker_inf->data)); - if (!marker_inf->trace) { + ust_marker_inf->trace = ustcomm_restore_ptr(ust_marker_inf->trace, + ust_marker_inf->data, + sizeof(ust_marker_inf->data)); + if (!ust_marker_inf->trace) { return -EINVAL; } - marker_inf->channel = ustcomm_restore_ptr(marker_inf->channel, - marker_inf->data, - sizeof(marker_inf->data)); - if (!marker_inf->channel) { + ust_marker_inf->channel = ustcomm_restore_ptr(ust_marker_inf->channel, + ust_marker_inf->data, + sizeof(ust_marker_inf->data)); + if (!ust_marker_inf->channel) { return -EINVAL; } - marker_inf->marker = ustcomm_restore_ptr(marker_inf->marker, - marker_inf->data, - sizeof(marker_inf->data)); - if (!marker_inf->marker) { + ust_marker_inf->ust_marker = ustcomm_restore_ptr(ust_marker_inf->ust_marker, + ust_marker_inf->data, + sizeof(ust_marker_inf->data)); + if (!ust_marker_inf->ust_marker) { return -EINVAL; } diff --git a/libustcomm/ustcomm.h b/libustcomm/ustcomm.h index 9952958..a91c111 100644 --- a/libustcomm/ustcomm.h +++ b/libustcomm/ustcomm.h @@ -105,10 +105,10 @@ struct ustcomm_buffer_info { char data[USTCOMM_DATA_SIZE]; }; -struct ustcomm_marker_info { +struct ustcomm_ust_marker_info { char *trace; char *channel; - char *marker; + char *ust_marker; char data[USTCOMM_DATA_SIZE]; }; @@ -202,12 +202,12 @@ extern int ustcomm_pack_buffer_info(struct ustcomm_header *header, extern int ustcomm_unpack_buffer_info(struct ustcomm_buffer_info *buf_inf); -extern int ustcomm_pack_marker_info(struct ustcomm_header *header, - struct ustcomm_marker_info *marker_inf, +extern int ustcomm_pack_ust_marker_info(struct ustcomm_header *header, + struct ustcomm_ust_marker_info *ust_marker_inf, const char *trace, const char *channel, - const char *marker); + const char *ust_marker); -extern int ustcomm_unpack_marker_info(struct ustcomm_marker_info *marker_inf); +extern int ustcomm_unpack_ust_marker_info(struct ustcomm_ust_marker_info *ust_marker_inf); #endif /* USTCOMM_H */ diff --git a/libustctl/libustctl.c b/libustctl/libustctl.c index c781283..8b0dfc1 100644 --- a/libustctl/libustctl.c +++ b/libustctl/libustctl.c @@ -265,25 +265,25 @@ pid_t *ustctl_get_online_pids(void) } /** - * Sets marker state (USTCTL_MS_ON or USTCTL_MS_OFF). + * Sets ust_marker state (USTCTL_MS_ON or USTCTL_MS_OFF). * * @param mn Marker name * @param state Marker's new state * @param pid Traced process ID * @return 0 if successful, or errors {USTCTL_ERR_GEN, USTCTL_ERR_ARG} */ -int ustctl_set_marker_state(int sock, const char *trace, const char *channel, - const char *marker, int state) +int ustctl_set_ust_marker_state(int sock, const char *trace, const char *channel, + const char *ust_marker, int state) { struct ustcomm_header req_header, res_header; - struct ustcomm_marker_info marker_inf; + struct ustcomm_ust_marker_info ust_marker_inf; int result; - result = ustcomm_pack_marker_info(&req_header, - &marker_inf, + result = ustcomm_pack_ust_marker_info(&req_header, + &ust_marker_inf, trace, channel, - marker); + ust_marker); if (result < 0) { errno = -result; return -1; @@ -291,7 +291,7 @@ int ustctl_set_marker_state(int sock, const char *trace, const char *channel, req_header.command = state ? ENABLE_MARKER : DISABLE_MARKER; - return do_cmd(sock, &req_header, (char *)&marker_inf, + return do_cmd(sock, &req_header, (char *)&ust_marker_inf, &res_header, NULL); } @@ -549,7 +549,7 @@ unsigned int ustctl_count_nl(const char *str) * @param cmsf CMSF array to free * @return 0 if successful, or error USTCTL_ERR_ARG */ -int ustctl_free_cmsf(struct marker_status *cmsf) +int ustctl_free_cmsf(struct ust_marker_status *cmsf) { if (cmsf == NULL) { return USTCTL_ERR_ARG; @@ -558,7 +558,7 @@ int ustctl_free_cmsf(struct marker_status *cmsf) unsigned int i = 0; while (cmsf[i].channel != NULL) { free(cmsf[i].channel); - free(cmsf[i].marker); + free(cmsf[i].ust_marker); free(cmsf[i].fs); ++i; } @@ -568,19 +568,19 @@ int ustctl_free_cmsf(struct marker_status *cmsf) } /** - * Gets channel/marker/state/format string for a given PID. + * Gets channel/ust_marker/state/format string for a given PID. * * @param cmsf Pointer to CMSF array to be filled (callee allocates, caller * frees with `ustctl_free_cmsf') * @param pid Targeted PID * @return 0 if successful, or -1 on error */ -int ustctl_get_cmsf(int sock, struct marker_status **cmsf) +int ustctl_get_cmsf(int sock, struct ust_marker_status **cmsf) { struct ustcomm_header req_header, res_header; char *big_str = NULL; int result; - struct marker_status *tmp_cmsf = NULL; + struct ust_marker_status *tmp_cmsf = NULL; unsigned int i = 0, cmsf_ind = 0; if (cmsf == NULL) { @@ -592,17 +592,17 @@ int ustctl_get_cmsf(int sock, struct marker_status **cmsf) result = ustcomm_send(sock, &req_header, NULL); if (result <= 0) { - PERROR("error while requesting markers list"); + PERROR("error while requesting ust_marker list"); return -1; } result = ustcomm_recv_alloc(sock, &res_header, &big_str); if (result <= 0) { - ERR("error while receiving markers list"); + ERR("error while receiving ust_marker list"); return -1; } - tmp_cmsf = (struct marker_status *) zmalloc(sizeof(struct marker_status) * + tmp_cmsf = (struct ust_marker_status *) zmalloc(sizeof(struct ust_marker_status) * (ustctl_count_nl(big_str) + 1)); if (tmp_cmsf == NULL) { ERR("Failed to allocate CMSF array"); @@ -613,9 +613,9 @@ int ustctl_get_cmsf(int sock, struct marker_status **cmsf) while (big_str[i] != '\0') { char state; - sscanf(big_str + i, "marker: %a[^/]/%a[^ ] %c %a[^\n]", + sscanf(big_str + i, "ust_marker: %a[^/]/%a[^ ] %c %a[^\n]", &tmp_cmsf[cmsf_ind].channel, - &tmp_cmsf[cmsf_ind].marker, + &tmp_cmsf[cmsf_ind].ust_marker, &state, &tmp_cmsf[cmsf_ind].fs); tmp_cmsf[cmsf_ind].state = (state == USTCTL_MS_CHR_ON ? @@ -628,7 +628,7 @@ int ustctl_get_cmsf(int sock, struct marker_status **cmsf) ++cmsf_ind; } tmp_cmsf[cmsf_ind].channel = NULL; - tmp_cmsf[cmsf_ind].marker = NULL; + tmp_cmsf[cmsf_ind].ust_marker = NULL; tmp_cmsf[cmsf_ind].fs = NULL; *cmsf = tmp_cmsf; @@ -690,7 +690,7 @@ int ustctl_get_tes(int sock, struct trace_event_status **tes) result = ustcomm_recv_alloc(sock, &res_header, &big_str); if (result != 1) { - ERR("error while receiving markers list"); + ERR("error while receiving ust_marker list"); return -1; } diff --git a/libustinstr-malloc/mallocwrap.c b/libustinstr-malloc/mallocwrap.c index 28cd4e3..a7730c9 100644 --- a/libustinstr-malloc/mallocwrap.c +++ b/libustinstr-malloc/mallocwrap.c @@ -97,4 +97,4 @@ void free(void *ptr) plibc_free(ptr); } -MARKER_LIB +UST_MARKER_LIB diff --git a/tests/fork/fork.c b/tests/fork/fork.c index f2b3f18..f9b515c 100644 --- a/tests/fork/fork.c +++ b/tests/fork/fork.c @@ -32,7 +32,7 @@ int main(int argc, char **argv, char *env[]) } printf("Fork test program, parent pid is %d\n", getpid()); - ust_marker(before_fork, MARK_NOARGS); + ust_marker(before_fork, UST_MARKER_NOARGS); /* Sleep here to make sure the consumer is initialized before we fork */ sleep(1); @@ -47,7 +47,7 @@ int main(int argc, char **argv, char *env[]) printf("Child pid is %d\n", getpid()); - ust_marker(after_fork_child, MARK_NOARGS); + ust_marker(after_fork_child, UST_MARKER_NOARGS); ust_marker(before_exec, "pid %d", getpid()); @@ -60,7 +60,7 @@ int main(int argc, char **argv, char *env[]) ust_marker(after_exec, "pid %d", getpid()); } else { - ust_marker(after_fork_parent, MARK_NOARGS); + ust_marker(after_fork_parent, UST_MARKER_NOARGS); } return 0; diff --git a/tests/fork/fork2.c b/tests/fork/fork2.c index c77a705..b156ac1 100644 --- a/tests/fork/fork2.c +++ b/tests/fork/fork2.c @@ -24,7 +24,7 @@ int main() { printf("IN FORK2\n"); - ust_marker(after_exec, MARK_NOARGS); + ust_marker(after_exec, UST_MARKER_NOARGS); return 0; } diff --git a/tests/libustctl_function_tests/libustctl_function_tests.c b/tests/libustctl_function_tests/libustctl_function_tests.c index 4589420..0aba01c 100644 --- a/tests/libustctl_function_tests/libustctl_function_tests.c +++ b/tests/libustctl_function_tests/libustctl_function_tests.c @@ -33,7 +33,7 @@ static void ustctl_function_tests(pid_t pid) int result, sock; unsigned int subbuf_size, subbuf_num; unsigned int new_subbuf_size, new_subbuf_num; - struct marker_status *marker_status, *ms_ptr; + struct ust_marker_status *marker_status, *ms_ptr; char *old_socket_path, *new_socket_path; char *tmp_ustd_socket = "/tmp/tmp_ustd_socket"; char *trace = "auto"; @@ -50,7 +50,7 @@ static void ustctl_function_tests(pid_t pid) result = 0; for (ms_ptr = marker_status; ms_ptr->channel; ms_ptr++) { if (!strcmp(ms_ptr->channel, "ust") && - !strcmp(ms_ptr->marker, "bar")) { + !strcmp(ms_ptr->ust_marker, "bar")) { result = 1; } } @@ -81,8 +81,8 @@ static void ustctl_function_tests(pid_t pid) free(old_socket_path); /* Enable, disable markers */ - tap_ok(!ustctl_set_marker_state(sock, trace, "ust", "bar", 1), - "ustctl_set_marker_state - existing marker ust bar"); + tap_ok(!ustctl_set_ust_marker_state(sock, trace, "ust", "bar", 1), + "ustctl_set_ust_marker_state - existing marker ust bar"); /* Create and allocate a trace */ tap_ok(!ustctl_create_trace(sock, trace), "ustctl_create_trace"); @@ -144,13 +144,13 @@ static void ustctl_function_tests(pid_t pid) * Activate a non-existent marker, this should be possible as the marker * can be loaded at a later time. */ - tap_ok(ustctl_set_marker_state(sock, trace, "ustl", "blar", 1) == 0, + tap_ok(ustctl_set_ust_marker_state(sock, trace, "ustl", "blar", 1) == 0, "Enable non-existent marker ustl blar"); printf("##### Tests that definetly should work are completed #####\n"); printf("############## Start expected failure cases ##############\n"); - tap_ok(ustctl_set_marker_state(sock, trace, "ust","bar", 1), + tap_ok(ustctl_set_ust_marker_state(sock, trace, "ust","bar", 1), "Enable already enabled marker ust/bar"); tap_ok(EEXIST == errno, diff --git a/tests/make_shared_lib/basic_lib.c b/tests/make_shared_lib/basic_lib.c index 3feaac1..4facd9d 100644 --- a/tests/make_shared_lib/basic_lib.c +++ b/tests/make_shared_lib/basic_lib.c @@ -7,4 +7,4 @@ void myfunc(void) printf("testfunc\n"); } -//MARKER_LIB +//UST_MARKER_LIB diff --git a/tests/tracepoint/benchmark/tracepoint_benchmark.c b/tests/tracepoint/benchmark/tracepoint_benchmark.c index 43ec21f..5d23975 100644 --- a/tests/tracepoint/benchmark/tracepoint_benchmark.c +++ b/tests/tracepoint/benchmark/tracepoint_benchmark.c @@ -34,16 +34,16 @@ DEFINE_TRACE(ust_event); void tp_probe(void *data, unsigned int p1); -DEFINE_MARKER_TP(event, ust_event, tp_probe, "p1 %u"); +DEFINE_UST_MARKER_TP(event, ust_event, tp_probe, "p1 %u"); /* * Probe 1 --> ust_event */ void tp_probe(void *data, unsigned int p1) { - struct marker *marker; + struct ust_marker *marker; - marker = &GET_MARKER(event); + marker = &GET_UST_MARKER(event); ltt_specialized_trace(marker, data, &p1, sizeof(p1), sizeof(p1)); } diff --git a/ustctl/marker_cmds.c b/ustctl/marker_cmds.c index da14358..8bcab83 100644 --- a/ustctl/marker_cmds.c +++ b/ustctl/marker_cmds.c @@ -24,7 +24,7 @@ static int list_markers(int argc, char *argv[]) { - struct marker_status *cmsf = NULL; + struct ust_marker_status *cmsf = NULL; int i, sock; sock = parse_and_connect_pid(argv[1]); @@ -38,7 +38,7 @@ static int list_markers(int argc, char *argv[]) "state: %u, fmt: %s}\n", argv[1], cmsf[i].channel, - cmsf[i].marker, + cmsf[i].ust_marker, cmsf[i].state, cmsf[i].fs); } @@ -66,7 +66,7 @@ static int enable_marker(int argc, char *argv[]) if (marker) free(marker); } - if (ustctl_set_marker_state(sock, argv[2], channel, marker, 1)) { + if (ustctl_set_ust_marker_state(sock, argv[2], channel, marker, 1)) { PERROR("error while trying to enable marker %s with PID %s", argv[i], argv[1]); result = -1; @@ -98,7 +98,7 @@ static int disable_marker(int argc, char *argv[]) free(marker); return -1; } - if (ustctl_set_marker_state(sock, argv[2], channel, marker, 0)) { + if (ustctl_set_ust_marker_state(sock, argv[2], channel, marker, 0)) { PERROR("error while trying to disable marker %s with PID %s", argv[i], argv[1]); result = -1; @@ -110,7 +110,7 @@ static int disable_marker(int argc, char *argv[]) return result; } -struct cli_cmd __cli_cmds marker_cmds[] = { +struct cli_cmd __cli_cmds ust_marker_cmds[] = { { .name = "list-markers", .description = "List markers for a given pid",