X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=ltt-events.c;h=a5ca1abaa798c83489fc604705a0ea966141ffa4;hb=97ca2c5484815a67b70fcf2b1772eb1b2c2e5633;hp=603170682a822dea830830cf0ec155e5651b124b;hpb=f3d01b96c9189afbeb273ad7382eb89ee70a0e61;p=lttng-modules.git diff --git a/ltt-events.c b/ltt-events.c index 60317068..a5ca1aba 100644 --- a/ltt-events.c +++ b/ltt-events.c @@ -11,7 +11,7 @@ #include #include #include -#include /* For vmalloc_sync_all */ +#include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ #include "ltt-events.h" static LIST_HEAD(sessions); @@ -46,9 +46,14 @@ void ltt_session_destroy(struct ltt_session *session) { struct ltt_channel *chan, *tmpchan; struct ltt_event *event, *tmpevent; + int ret; mutex_lock(&sessions_mutex); - session->active = 0; + ACCESS_ONCE(session->active) = 0; + list_for_each_entry(event, &session->events, list) { + ret = _ltt_event_unregister(event); + WARN_ON(ret); + } synchronize_trace(); /* Wait for in-flight events to complete */ list_for_each_entry_safe(event, tmpevent, &session->events, list) _ltt_event_destroy(event); @@ -68,7 +73,7 @@ int ltt_session_start(struct ltt_session *session) ret = -EBUSY; goto end; } - session->active = 1; + ACCESS_ONCE(session->active) = 1; synchronize_trace(); /* Wait for in-flight events to complete */ end: mutex_unlock(&sessions_mutex); @@ -84,14 +89,14 @@ int ltt_session_stop(struct ltt_session *session) ret = -EBUSY; goto end; } - session->active = 0; + ACCESS_ONCE(session->active) = 0; synchronize_trace(); /* Wait for in-flight events to complete */ end: mutex_unlock(&sessions_mutex); return ret; } -static struct ltt_transport *ltt_transport_find(char *name) +static struct ltt_transport *ltt_transport_find(const char *name) { struct ltt_transport *transport; @@ -103,28 +108,26 @@ static struct ltt_transport *ltt_transport_find(char *name) } struct ltt_channel *ltt_channel_create(struct ltt_session *session, - int overwrite, void *buf_addr, + const char *transport_name, + void *buf_addr, size_t subbuf_size, size_t num_subbuf, unsigned int switch_timer_interval, unsigned int read_timer_interval) { struct ltt_channel *chan; struct ltt_transport *transport; - char *transport_name; mutex_lock(&sessions_mutex); if (session->active) { printk(KERN_WARNING "LTTng refusing to add channel to active session\n"); goto active; /* Refuse to add channel to active session */ } - transport_name = overwrite ? "relay-overwrite" : "relay-discard"; transport = ltt_transport_find(transport_name); if (!transport) { printk(KERN_WARNING "LTTng transport %s not found\n", transport_name); goto notransport; } - printk("got transport\n"); chan = kzalloc(sizeof(struct ltt_channel), GFP_KERNEL); if (!chan) goto nomem; @@ -133,7 +136,6 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, chan->chan = transport->ops.channel_create("[lttng]", session, buf_addr, subbuf_size, num_subbuf, switch_timer_interval, read_timer_interval); - printk("chan create %p\n", chan->chan); if (!chan->chan) goto create_error; chan->ops = &transport->ops; @@ -165,7 +167,8 @@ void _ltt_channel_destroy(struct ltt_channel *chan) */ struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name, enum instrum_type itype, - void *probe, void *filter) + const struct lttng_event_desc *event_desc, + void *filter) { struct ltt_event *event; int ret; @@ -174,21 +177,17 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name, if (chan->free_event_id == -1UL) goto full; /* - * This is O(n^2) (for each event loop called at event creation). - * Might require a hash if we have lots of events. + * This is O(n^2) (for each event, the loop is called at event + * creation). Might require a hash if we have lots of events. */ list_for_each_entry(event, &chan->session->events, list) - if (!strcmp(event->name, name)) + if (!strcmp(event->desc->name, name)) goto exist; event = kmem_cache_zalloc(event_cache, GFP_KERNEL); if (!event) goto cache_error; - event->name = kmalloc(strlen(name) + 1, GFP_KERNEL); - if (!event->name) - goto name_error; - strcpy(event->name, name); event->chan = chan; - event->probe = probe; + event->desc = event_desc; event->filter = filter; event->id = chan->free_event_id++; event->itype = itype; @@ -196,19 +195,19 @@ struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name, smp_wmb(); switch (itype) { case INSTRUM_TRACEPOINTS: - ret = tracepoint_probe_register(name, probe, event); + ret = tracepoint_probe_register(name, event_desc->probe_callback, + event); if (ret) goto register_error; break; default: WARN_ON_ONCE(1); } + list_add(&event->list, &chan->session->events); mutex_unlock(&sessions_mutex); return event; register_error: - kfree(event->name); -name_error: kmem_cache_free(event_cache, event); cache_error: exist: @@ -220,13 +219,14 @@ full: /* * Only used internally at session destruction. */ -int _ltt_event_destroy(struct ltt_event *event) +int _ltt_event_unregister(struct ltt_event *event) { int ret = -EINVAL; switch (event->itype) { case INSTRUM_TRACEPOINTS: - ret = tracepoint_probe_unregister(event->name, event->probe, + ret = tracepoint_probe_unregister(event->desc->name, + event->desc->probe_callback, event); if (ret) return ret; @@ -234,11 +234,19 @@ int _ltt_event_destroy(struct ltt_event *event) default: WARN_ON_ONCE(1); } - kfree(event->name); - kmem_cache_free(event_cache, event); return ret; } +/* + * Only used internally at session destruction. + */ +void _ltt_event_destroy(struct ltt_event *event) +{ + ltt_event_put(event->desc); + list_del(&event->list); + kmem_cache_free(event_cache, event); +} + /** * ltt_transport_register - LTT transport registration * @transport: transport structure @@ -258,7 +266,7 @@ void ltt_transport_register(struct ltt_transport *transport) * registered. We deal with this here so we don't have to call * vmalloc_sync_all() in each module's init. */ - vmalloc_sync_all(); + wrapper_vmalloc_sync_all(); mutex_lock(&sessions_mutex); list_add_tail(&transport->node, <t_transport_list); @@ -288,9 +296,9 @@ static int __init ltt_events_init(void) return -ENOMEM; ret = ltt_debugfs_abi_init(); if (ret) - goto error; + goto error_abi; return 0; -error: +error_abi: kmem_cache_destroy(event_cache); return ret; }