X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Fmarker.c;h=146fbc9db648a212e5bcabe55f7d5ebb92f9dde9;hb=a5850bc4ccd4fab794c76a368648e21236d7db01;hp=39da7f40f08338a69ae85cc6915cac303376390e;hpb=48454c953fc1117fbbbe5fc7bc23b6cd28b50d32;p=ust.git diff --git a/libust/marker.c b/libust/marker.c index 39da7f4..146fbc9 100644 --- a/libust/marker.c +++ b/libust/marker.c @@ -31,18 +31,23 @@ //ust// #include #define _LGPL_SOURCE -#include +#include -#include "kernelcompat.h" +#include -#include "marker.h" +#include +#include #include "usterr.h" #include "channels.h" #include "tracercore.h" -#include "tracer.h" + +__thread long ust_reg_stack[500]; +volatile __thread long *ust_reg_stack_ptr = (long *) 0; extern struct marker __start___markers[] __attribute__((visibility("hidden"))); extern struct marker __stop___markers[] __attribute__((visibility("hidden"))); +extern struct marker_addr __start___marker_addr[] __attribute__((visibility("hidden"))); +extern struct marker_addr __stop___marker_addr[] __attribute__((visibility("hidden"))); /* Set to 1 to enable marker debug output */ static const int marker_debug; @@ -53,6 +58,9 @@ static const int marker_debug; */ static DEFINE_MUTEX(markers_mutex); +static LIST_HEAD(libs); + + void lock_markers(void) { mutex_lock(&markers_mutex); @@ -84,7 +92,7 @@ struct marker_entry { char *format; char *name; /* Probe wrapper */ - void (*call)(const struct marker *mdata, void *call_private, ...); + void (*call)(const struct marker *mdata, void *call_private, struct registers *regs, ...); struct marker_probe_closure single; struct marker_probe_closure *multi; int refcount; /* Number of times armed. 0 if disarmed. */ @@ -120,7 +128,7 @@ static void marker_update_processes(void) * operations that modifies the execution flow of preemptible code. */ notrace void __mark_empty_function(const struct marker *mdata, - void *probe_private, void *call_private, const char *fmt, va_list *args) + void *probe_private, struct registers *regs, void *call_private, const char *fmt, va_list *args) { } //ust// EXPORT_SYMBOL_GPL(__mark_empty_function); @@ -136,7 +144,7 @@ notrace void __mark_empty_function(const struct marker *mdata, * rcu_dereference() for the pointer read. */ notrace void marker_probe_cb(const struct marker *mdata, - void *call_private, ...) + void *call_private, struct registers *regs, ...) { va_list args; char ptype; @@ -157,8 +165,8 @@ notrace void marker_probe_cb(const struct marker *mdata, /* Must read the ptr before private data. They are not data * dependant, so we put an explicit smp_rmb() here. */ smp_rmb(); - va_start(args, call_private); - func(mdata, mdata->single.probe_private, call_private, + va_start(args, regs); + func(mdata, mdata->single.probe_private, regs, call_private, mdata->format, &args); va_end(args); } else { @@ -178,9 +186,9 @@ notrace void marker_probe_cb(const struct marker *mdata, */ smp_read_barrier_depends(); for (i = 0; multi[i].func; i++) { - va_start(args, call_private); + va_start(args, regs); multi[i].func(mdata, multi[i].probe_private, - call_private, mdata->format, &args); + regs, call_private, mdata->format, &args); va_end(args); } } @@ -197,7 +205,7 @@ notrace void marker_probe_cb(const struct marker *mdata, * Should be connected to markers "MARK_NOARGS". */ static notrace void marker_probe_cb_noarg(const struct marker *mdata, - void *call_private, ...) + void *call_private, struct registers *regs, ...) { va_list args; /* not initialized */ char ptype; @@ -213,7 +221,7 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, /* Must read the ptr before private data. They are not data * dependant, so we put an explicit smp_rmb() here. */ smp_rmb(); - func(mdata, mdata->single.probe_private, call_private, + func(mdata, mdata->single.probe_private, regs, call_private, mdata->format, &args); } else { struct marker_probe_closure *multi; @@ -232,7 +240,7 @@ static notrace void marker_probe_cb_noarg(const struct marker *mdata, */ smp_read_barrier_depends(); for (i = 0; multi[i].func; i++) - multi[i].func(mdata, multi[i].probe_private, + multi[i].func(mdata, multi[i].probe_private, regs, call_private, mdata->format, &args); } //ust// rcu_read_unlock_sched_notrace(); @@ -631,9 +639,9 @@ static int set_marker(struct marker_entry *entry, struct marker *elem, */ static void disable_marker(struct marker *elem) { - int ret; - - /* leave "call" as is. It is known statically. */ +//ust// int ret; +//ust// +//ust// /* leave "call" as is. It is known statically. */ //ust// if (elem->tp_name && _imv_read(elem->state)) { //ust// WARN_ON(!elem->tp_cb); //ust// /* @@ -703,6 +711,18 @@ void marker_update_probe_range(struct marker *begin, mutex_unlock(&markers_mutex); } +static void lib_update_markers(void) +{ + struct lib *lib; + + /* FIXME: we should probably take a mutex here on libs */ +//ust// mutex_lock(&module_mutex); + list_for_each_entry(lib, &libs, list) + marker_update_probe_range(lib->markers_start, + lib->markers_start + lib->markers_count); +//ust// mutex_unlock(&module_mutex); +} + /* * Update probes, removing the faulty probes. * @@ -808,6 +828,7 @@ int marker_probe_register(const char *channel, const char *name, } mutex_unlock(&markers_mutex); + /* Activate marker if necessary */ marker_update_probes(); mutex_lock(&markers_mutex); @@ -1056,6 +1077,33 @@ void *marker_get_private_data(const char *channel, const char *name, //ust//#ifdef CONFIG_MODULES +/* + * Returns 0 if current not found. + * Returns 1 if current found. + */ +int lib_get_iter_markers(struct marker_iter *iter) +{ + struct lib *iter_lib; + int found = 0; + +//ust// mutex_lock(&module_mutex); + list_for_each_entry(iter_lib, &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); + if (found) { + iter->lib = iter_lib; + break; + } + } +//ust// mutex_unlock(&module_mutex); + return found; +} + /** * marker_get_iter_range - Get a next marker iterator given a range. * @marker: current markers (in), next marker (out) @@ -1436,47 +1484,6 @@ void ltt_dump_marker_state(struct ltt_trace_struct *trace) } //ust// EXPORT_SYMBOL_GPL(ltt_dump_marker_state); - -static LIST_HEAD(libs); - -/* - * Returns 0 if current not found. - * Returns 1 if current found. - */ -int lib_get_iter_markers(struct marker_iter *iter) -{ - struct lib *iter_lib; - int found = 0; - -//ust// mutex_lock(&module_mutex); - list_for_each_entry(iter_lib, &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); - if (found) { - iter->lib = iter_lib; - break; - } - } -//ust// mutex_unlock(&module_mutex); - return found; -} - -void lib_update_markers(void) -{ - struct lib *lib; - -//ust// mutex_lock(&module_mutex); - list_for_each_entry(lib, &libs, list) - marker_update_probe_range(lib->markers_start, - lib->markers_start + lib->markers_count); -//ust// mutex_unlock(&module_mutex); -} - static void (*new_marker_cb)(struct marker *) = NULL; void marker_set_new_marker_cb(void (*cb)(struct marker *)) @@ -1494,15 +1501,22 @@ static void new_markers(struct marker *start, struct marker *end) } } -int marker_register_lib(struct marker *markers_start, int markers_count) +int marker_register_lib(struct marker *markers_start, struct marker_addr *marker_addr_start, int markers_count) { struct lib *pl; + struct marker_addr *addr; pl = (struct lib *) malloc(sizeof(struct lib)); pl->markers_start = markers_start; + pl->markers_addr_start = marker_addr_start; pl->markers_count = markers_count; + lock_markers(); + for(addr = marker_addr_start; addr < marker_addr_start + markers_count; addr++) + addr->marker->location = addr->addr; + unlock_markers(); + /* FIXME: maybe protect this with its own mutex? */ lock_markers(); list_add(&pl->list, &libs); @@ -1531,8 +1545,8 @@ static int initialized = 0; void __attribute__((constructor)) init_markers(void) { if(!initialized) { - marker_register_lib(__start___markers, (((long)__stop___markers)-((long)__start___markers))/sizeof(struct marker)); - printf("markers_start: %p, markers_stop: %p\n", __start___markers, __stop___markers); + marker_register_lib(__start___markers, __start___marker_addr, (((long)__stop___markers)-((long)__start___markers))/sizeof(struct marker)); + //DBG("markers_start: %p, markers_stop: %p\n", __start___markers, __stop___markers); initialized = 1; } }