From: Pierre-Marc Fournier Date: Wed, 11 Feb 2009 22:48:53 +0000 (-0500) Subject: ust: continue work X-Git-Tag: v1.9.1~1069 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=ba6459ba344b54a4f7775e431447be79fd7790f8;p=lttng-ust.git ust: continue work --- diff --git a/hello/Makefile b/hello/Makefile index 703c97e6..2eee1152 100644 --- a/hello/Makefile +++ b/hello/Makefile @@ -1,7 +1,7 @@ all: hello hello: hello.c - gcc -g -I../libmarkers -I../share -I../libtracing -L../libmarkers -lmarkers -L../libtracectl -ltracectl -L../libtracing -ltracing -o hello hello.c serialize.c + gcc -g -I../libmarkers -I../share -I../libtracing -L../libmarkers -lmarkers -L../libtracectl -ltracectl -L../libtracing -ltracing -o hello hello.c marker-control.c serialize.c clean: rm -rf hello *.o diff --git a/hello/hello.c b/hello/hello.c index 1a00d45f..1c97db93 100644 --- a/hello/hello.c +++ b/hello/hello.c @@ -5,6 +5,7 @@ #include "../libmarkers/marker.h" #include "usterr.h" #include "tracer.h" +#include "marker-control.h" void probe(const struct marker *mdata, void *probe_private, void *call_private, @@ -62,84 +63,84 @@ int init_int_handler(void) return 0; } -DEFINE_MUTEX(probes_mutex); - -static LIST_HEAD(probes_registered_list); - -int ltt_marker_connect(const char *channel, const char *mname, - const char *pname) - -{ - int ret; - struct ltt_active_marker *pdata; - struct ltt_available_probe *probe; - - ltt_lock_traces(); - mutex_lock(&probes_mutex); - probe = get_probe_from_name(pname); - if (!probe) { - ret = -ENOENT; - goto end; - } - pdata = marker_get_private_data(channel, mname, probe->probe_func, 0); - if (pdata && !IS_ERR(pdata)) { - ret = -EEXIST; - goto end; - } - pdata = kmem_cache_zalloc(markers_loaded_cachep, GFP_KERNEL); - if (!pdata) { - ret = -ENOMEM; - goto end; - } - pdata->probe = probe; - /* - * ID has priority over channel in case of conflict. - */ - ret = marker_probe_register(channel, mname, NULL, - probe->probe_func, pdata); - if (ret) - kmem_cache_free(markers_loaded_cachep, pdata); - else - list_add(&pdata->node, &markers_loaded_list); -end: - mutex_unlock(&probes_mutex); - ltt_unlock_traces(); - return ret; -} - - -int ltt_probe_register(struct ltt_available_probe *pdata) -{ - int ret = 0; - int comparison; - struct ltt_available_probe *iter; - - mutex_lock(&probes_mutex); - list_for_each_entry_reverse(iter, &probes_registered_list, node) { - comparison = strcmp(pdata->name, iter->name); - if (!comparison) { - ret = -EBUSY; - goto end; - } else if (comparison > 0) { - /* We belong to the location right after iter. */ - list_add(&pdata->node, &iter->node); - goto end; - } - } - /* Should be added at the head of the list */ - list_add(&pdata->node, &probes_registered_list); -end: - mutex_unlock(&probes_mutex); - return ret; -} - - -struct ltt_available_probe default_probe = { - .name = "default", - .format = NULL, - .probe_func = ltt_vtrace, - .callbacks[0] = ltt_serialize_data, -}; +//ust// DEFINE_MUTEX(probes_mutex); +//ust// +//ust// static LIST_HEAD(probes_registered_list); +//ust// +//ust// int ltt_marker_connect(const char *channel, const char *mname, +//ust// const char *pname) +//ust// +//ust// { +//ust// int ret; +//ust// struct ltt_active_marker *pdata; +//ust// struct ltt_available_probe *probe; +//ust// +//ust// ltt_lock_traces(); +//ust// mutex_lock(&probes_mutex); +//ust// probe = get_probe_from_name(pname); +//ust// if (!probe) { +//ust// ret = -ENOENT; +//ust// goto end; +//ust// } +//ust// pdata = marker_get_private_data(channel, mname, probe->probe_func, 0); +//ust// if (pdata && !IS_ERR(pdata)) { +//ust// ret = -EEXIST; +//ust// goto end; +//ust// } +//ust// pdata = kmem_cache_zalloc(markers_loaded_cachep, GFP_KERNEL); +//ust// if (!pdata) { +//ust// ret = -ENOMEM; +//ust// goto end; +//ust// } +//ust// pdata->probe = probe; +//ust// /* +//ust// * ID has priority over channel in case of conflict. +//ust// */ +//ust// ret = marker_probe_register(channel, mname, NULL, +//ust// probe->probe_func, pdata); +//ust// if (ret) +//ust// kmem_cache_free(markers_loaded_cachep, pdata); +//ust// else +//ust// list_add(&pdata->node, &markers_loaded_list); +//ust// end: +//ust// mutex_unlock(&probes_mutex); +//ust// ltt_unlock_traces(); +//ust// return ret; +//ust// } +//ust// +//ust// +//ust// int ltt_probe_register(struct ltt_available_probe *pdata) +//ust// { +//ust// int ret = 0; +//ust// int comparison; +//ust// struct ltt_available_probe *iter; +//ust// +//ust// mutex_lock(&probes_mutex); +//ust// list_for_each_entry_reverse(iter, &probes_registered_list, node) { +//ust// comparison = strcmp(pdata->name, iter->name); +//ust// if (!comparison) { +//ust// ret = -EBUSY; +//ust// goto end; +//ust// } else if (comparison > 0) { +//ust// /* We belong to the location right after iter. */ +//ust// list_add(&pdata->node, &iter->node); +//ust// goto end; +//ust// } +//ust// } +//ust// /* Should be added at the head of the list */ +//ust// list_add(&pdata->node, &probes_registered_list); +//ust// end: +//ust// mutex_unlock(&probes_mutex); +//ust// return ret; +//ust// } +//ust// +//ust// +//ust// struct ltt_available_probe default_probe = { +//ust// .name = "default", +//ust// .format = NULL, +//ust// .probe_func = ltt_vtrace, +//ust// .callbacks[0] = ltt_serialize_data, +//ust// }; int main() { @@ -154,11 +155,13 @@ int main() char trace_name[] = "theusttrace"; char trace_type[] = "ustrelay"; + marker_control_init(); + marker_probe_register("abc", "testmark", "", probe, NULL); marker_probe_register("metadata", "core_marker_id", "channel %s name %s event_id %hu int #1u%zu long #1u%zu pointer #1u%zu size_t #1u%zu alignment #1u%u", probe, NULL); - result = ltt_probe_register(&default_probe); - if(result) - ERR("ltt_probe_register"); +//ust// result = ltt_probe_register(&default_probe); +//ust// if(result) +//ust// ERR("ltt_probe_register"); result = ltt_marker_connect("abc", "testmark2", "default"); if(result) diff --git a/hello/marker-control.c b/hello/marker-control.c new file mode 100644 index 00000000..419147a4 --- /dev/null +++ b/hello/marker-control.c @@ -0,0 +1,455 @@ +/* + * Copyright (C) 2007 Mathieu Desnoyers + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * LTT marker control module over /proc + */ + +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +//ust// #include +#include "kernelcompat.h" +#include "list.h" +#include "tracer.h" +#include "usterr.h" + +#define DEFAULT_CHANNEL "cpu" +#define DEFAULT_PROBE "default" + +LIST_HEAD(probes_list); + +/* + * Mutex protecting the probe slab cache. + * Nests inside the traces mutex. + */ +DEFINE_MUTEX(probes_mutex); + +struct ltt_available_probe default_probe = { + .name = "default", + .format = NULL, + .probe_func = ltt_vtrace, + .callbacks[0] = ltt_serialize_data, +}; + +//ust//static struct kmem_cache *markers_loaded_cachep; +static LIST_HEAD(markers_loaded_list); +/* + * List sorted by name strcmp order. + */ +static LIST_HEAD(probes_registered_list); + +//ust// static struct proc_dir_entry *pentry; + +//ust// static struct file_operations ltt_fops; + +static struct ltt_available_probe *get_probe_from_name(const char *pname) +{ + struct ltt_available_probe *iter; + int comparison, found = 0; + + if (!pname) + pname = DEFAULT_PROBE; + list_for_each_entry(iter, &probes_registered_list, node) { + comparison = strcmp(pname, iter->name); + if (!comparison) + found = 1; + if (comparison <= 0) + break; + } + if (found) + return iter; + else + return NULL; +} + +static char *skip_spaces(char *buf) +{ + while (*buf != '\0' && isspace(*buf)) + buf++; + return buf; +} + +static char *skip_nonspaces(char *buf) +{ + while (*buf != '\0' && !isspace(*buf)) + buf++; + return buf; +} + +static void get_marker_string(char *buf, char **start, + char **end) +{ + *start = skip_spaces(buf); + *end = skip_nonspaces(*start); + **end = '\0'; +} + +int ltt_probe_register(struct ltt_available_probe *pdata) +{ + int ret = 0; + int comparison; + struct ltt_available_probe *iter; + + mutex_lock(&probes_mutex); + list_for_each_entry_reverse(iter, &probes_registered_list, node) { + comparison = strcmp(pdata->name, iter->name); + if (!comparison) { + ret = -EBUSY; + goto end; + } else if (comparison > 0) { + /* We belong to the location right after iter. */ + list_add(&pdata->node, &iter->node); + goto end; + } + } + /* Should be added at the head of the list */ + list_add(&pdata->node, &probes_registered_list); +end: + mutex_unlock(&probes_mutex); + return ret; +} +EXPORT_SYMBOL_GPL(ltt_probe_register); + +/* + * Called when a probe does not want to be called anymore. + */ +int ltt_probe_unregister(struct ltt_available_probe *pdata) +{ + int ret = 0; + struct ltt_active_marker *amark, *tmp; + + mutex_lock(&probes_mutex); + list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) { + if (amark->probe == pdata) { + ret = marker_probe_unregister_private_data( + pdata->probe_func, amark); + if (ret) + goto end; + list_del(&amark->node); + free(amark); + } + } + list_del(&pdata->node); +end: + mutex_unlock(&probes_mutex); + return ret; +} +EXPORT_SYMBOL_GPL(ltt_probe_unregister); + +/* + * Connect marker "mname" to probe "pname". + * Only allow _only_ probe instance to be connected to a marker. + */ +int ltt_marker_connect(const char *channel, const char *mname, + const char *pname) + +{ + int ret; + struct ltt_active_marker *pdata; + struct ltt_available_probe *probe; + + ltt_lock_traces(); + mutex_lock(&probes_mutex); + probe = get_probe_from_name(pname); + if (!probe) { + ret = -ENOENT; + goto end; + } + pdata = 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)); + if (!pdata) { + ret = -ENOMEM; + goto end; + } + pdata->probe = probe; + /* + * ID has priority over channel in case of conflict. + */ + ret = marker_probe_register(channel, mname, NULL, + probe->probe_func, pdata); + if (ret) + free(pdata); + else + list_add(&pdata->node, &markers_loaded_list); +end: + mutex_unlock(&probes_mutex); + ltt_unlock_traces(); + return ret; +} +EXPORT_SYMBOL_GPL(ltt_marker_connect); + +/* + * Disconnect marker "mname", probe "pname". + */ +int ltt_marker_disconnect(const char *channel, const char *mname, + const char *pname) +{ + struct ltt_active_marker *pdata; + struct ltt_available_probe *probe; + int ret = 0; + + mutex_lock(&probes_mutex); + probe = get_probe_from_name(pname); + if (!probe) { + ret = -ENOENT; + goto end; + } + pdata = marker_get_private_data(channel, mname, probe->probe_func, 0); + if (IS_ERR(pdata)) { + ret = PTR_ERR(pdata); + goto end; + } else if (!pdata) { + /* + * Not registered by us. + */ + ret = -EPERM; + goto end; + } + ret = marker_probe_unregister(channel, mname, probe->probe_func, pdata); + if (ret) + goto end; + else { + list_del(&pdata->node); + free(pdata); + } +end: + mutex_unlock(&probes_mutex); + return ret; +} +EXPORT_SYMBOL_GPL(ltt_marker_disconnect); + +/* + * function handling proc entry write. + * + * 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// ssize_t ret; +//ust// int i; +//ust// +//ust// if (!count) +//ust// return -EINVAL; +//ust// +//ust// kbuf = vmalloc(count + 1); +//ust// kbuf[count] = '\0'; /* Transform into a string */ +//ust// ret = copy_from_user(kbuf, buffer, count); +//ust// if (ret) { +//ust// ret = -EINVAL; +//ust// goto end; +//ust// } +//ust// get_marker_string(kbuf, &marker_action, &iter); +//ust// if (!marker_action || marker_action == iter) { +//ust// ret = -EINVAL; +//ust// goto end; +//ust// } +//ust// for (i = 0; i < 4; i++) { +//ust// arg[i] = NULL; +//ust// if (iter < kbuf + count) { +//ust// iter++; /* skip the added '\0' */ +//ust// get_marker_string(iter, &arg[i], &iter); +//ust// if (arg[i] == iter) +//ust// arg[i] = NULL; +//ust// } +//ust// } +//ust// +//ust// if (!arg[0] || !arg[1]) { +//ust// ret = -EINVAL; +//ust// goto end; +//ust// } +//ust// +//ust// if (!strcmp(marker_action, "connect")) { +//ust// ret = ltt_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// if (ret) +//ust// goto end; +//ust// } +//ust// ret = count; +//ust// end: +//ust// vfree(kbuf); +//ust// return ret; +//ust// } +//ust// +//ust// static void *s_next(struct seq_file *m, void *p, loff_t *pos) +//ust// { +//ust// struct marker_iter *iter = m->private; +//ust// +//ust// marker_iter_next(iter); +//ust// if (!iter->marker) { +//ust// /* +//ust// * Setting the iter module to -1UL will make sure +//ust// * that no module can possibly hold the current marker. +//ust// */ +//ust// iter->module = (void *)-1UL; +//ust// return NULL; +//ust// } +//ust// return iter->marker; +//ust// } +//ust// +//ust// static void *s_start(struct seq_file *m, loff_t *pos) +//ust// { +//ust// struct 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// * Setting the iter module to -1UL will make sure +//ust// * that no module can possibly hold the current marker. +//ust// */ +//ust// iter->module = (void *)-1UL; +//ust// return NULL; +//ust// } +//ust// return iter->marker; +//ust// } +//ust// +//ust// static void s_stop(struct seq_file *m, void *p) +//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// +//ust// seq_printf(m, "channel: %s 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// return 0; +//ust// } +//ust// +//ust// static const struct seq_operations ltt_seq_op = { +//ust// .start = s_start, +//ust// .next = s_next, +//ust// .stop = s_stop, +//ust// .show = s_show, +//ust// }; +//ust// +//ust// static int ltt_open(struct inode *inode, struct file *file) +//ust// { +//ust// /* +//ust// * Iterator kept in m->private. +//ust// * Restart iteration on all modules between reads because we do not lock +//ust// * the module mutex between those. +//ust// */ +//ust// int ret; +//ust// struct marker_iter *iter; +//ust// +//ust// iter = kzalloc(sizeof(*iter), GFP_KERNEL); +//ust// if (!iter) +//ust// return -ENOMEM; +//ust// +//ust// ret = seq_open(file, <t_seq_op); +//ust// if (ret == 0) +//ust// ((struct seq_file *)file->private_data)->private = iter; +//ust// else +//ust// kfree(iter); +//ust// return ret; +//ust// } +//ust// +//ust// static struct file_operations ltt_fops = { +//ust// .write = ltt_write, +//ust// .open = ltt_open, +//ust// .read = seq_read, +//ust// .llseek = seq_lseek, +//ust// .release = seq_release_private, +//ust// }; + +static void disconnect_all_markers(void) +{ + struct ltt_active_marker *pdata, *tmp; + + list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) { + marker_probe_unregister_private_data(pdata->probe->probe_func, + pdata); + list_del(&pdata->node); + free(pdata); + } +} + +int marker_control_init(void) +{ + int ret; + +//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); + + ret = ltt_probe_register(&default_probe); + BUG_ON(ret); + ret = ltt_marker_connect("metadata", "core_marker_format", + DEFAULT_PROBE); + BUG_ON(ret); + ret = ltt_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE); + BUG_ON(ret); +//ust// pentry->proc_fops = <t_fops; + + return 0; +} +//ust// module_init(marker_control_init); + +static void __exit marker_control_exit(void) +{ + int ret; + +//ust// remove_proc_entry("ltt", NULL); + ret = ltt_marker_disconnect("metadata", "core_marker_format", + DEFAULT_PROBE); + BUG_ON(ret); + ret = ltt_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(); +} +//ust// module_exit(marker_control_exit); + +//ust// MODULE_LICENSE("GPL"); +//ust// MODULE_AUTHOR("Mathieu Desnoyers"); +//ust// MODULE_DESCRIPTION("Linux Trace Toolkit Marker Control"); diff --git a/hello/marker-control.h b/hello/marker-control.h new file mode 100644 index 00000000..0b602db9 --- /dev/null +++ b/hello/marker-control.h @@ -0,0 +1,7 @@ +#ifndef MARKER_CONTROL_H +#define MARKER_CONTROL_H + +int marker_control_init(void); +int ltt_probe_register(struct ltt_available_probe *pdata); + +#endif /* MARKER_CONTROL_H */ diff --git a/hello/serialize.c b/hello/serialize.c index dfed899d..bf7cbe9d 100644 --- a/hello/serialize.c +++ b/hello/serialize.c @@ -22,6 +22,7 @@ #include "relay.h" #include "tracer.h" #include "list.h" +#include "usterr.h" enum ltt_type { LTT_TYPE_SIGNED_INT, diff --git a/share/kernelcompat.h b/share/kernelcompat.h index c5512b8d..e322bdba 100644 --- a/share/kernelcompat.h +++ b/share/kernelcompat.h @@ -63,6 +63,7 @@ typedef uint64_t u64; #include #define DEFINE_MUTEX(m) pthread_mutex_t (m) = PTHREAD_MUTEX_INITIALIZER; +#define DECLARE_MUTEX(m) extern pthread_mutex_t (m); #define mutex_lock(m) pthread_mutex_lock(m) @@ -82,10 +83,12 @@ typedef int spinlock_t; #include #define kmalloc(s, t) malloc(s) -#define kzalloc(s, t) malloc(s) +#define kzalloc(s, t) zmalloc(s) #define kfree(p) free((void *)p) #define kstrdup(s, t) strdup(s) +#define zmalloc(s) calloc(1, s) + #define GFP_KERNEL /* PRINTK */ @@ -108,6 +111,8 @@ typedef int spinlock_t; #define rcu_assign_pointer(a, b) do {} while(0) #define call_rcu_sched(a,b) do {} while(0) #define rcu_barrier_sched() do {} while(0) +#define rcu_read_lock_sched_notrace() do{} while (0) +#define rcu_read_unlock_sched_notrace() do{} while (0) /* ATOMICITY */ @@ -302,4 +307,6 @@ static inline u32 trace_clock_freq_scale(void) #define EXPORT_SYMBOL_GPL(a) /*nothing*/ +#define smp_processor_id() (-1) + #endif /* KERNELCOMPAT_H */ diff --git a/share/usterr.h b/share/usterr.h index a2f915bd..366718da 100644 --- a/share/usterr.h +++ b/share/usterr.h @@ -4,6 +4,7 @@ #define DBG(fmt, args...) fprintf(stderr, fmt "\n", ## args) #define WARN(fmt, args...) fprintf(stderr, "usertrace: WARNING: " fmt "\n", ## args) #define ERR(fmt, args...) fprintf(stderr, "usertrace: ERROR: " fmt "\n", ## args) +#define BUG(fmt, args...) fprintf(stderr, "usertrace: BUG: " fmt "\n", ## args) #define PERROR(call) perror("usertrace: ERROR: " call) #define BUG_ON(condition) do { if (unlikely(condition)) ERR("condition not respected (BUG)"); } while(0)