X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt-events.c;h=947d772cf37bec3c1a6b1d2557e2aeb2f19dd904;hb=681cc3bb4f00fd63ad65920ea6e201fcaed300c0;hp=d6cb397e6a61d44a83c1e8eaa898e8f18976107f;hpb=c0e31d2eb7b6d446c87cab8b18a8b8257b4ba3e8;p=lttng-modules.git diff --git a/ltt-events.c b/ltt-events.c index d6cb397e..947d772c 100644 --- a/ltt-events.c +++ b/ltt-events.c @@ -10,6 +10,8 @@ #include #include #include +#include +#include /* For vmalloc_sync_all */ #include "ltt-events.h" static LIST_HEAD(sessions); @@ -30,26 +32,28 @@ struct ltt_session *ltt_session_create(void) struct ltt_session *session; mutex_lock(&sessions_mutex); - session = kmalloc(sizeof(struct ltt_session)); + session = kzalloc(sizeof(struct ltt_session), GFP_KERNEL); if (!session) return NULL; INIT_LIST_HEAD(&session->chan); + INIT_LIST_HEAD(&session->events); list_add(&session->list, &sessions); mutex_unlock(&sessions_mutex); return session; - -exist: - mutex_unlock(&sessions_mutex); - return NULL; } -int ltt_session_destroy(struct ltt_session *session) +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); @@ -69,11 +73,11 @@ 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); - return ret + return ret; } int ltt_session_stop(struct ltt_session *session) @@ -85,11 +89,22 @@ 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 + return ret; +} + +static struct ltt_transport *ltt_transport_find(char *name) +{ + struct ltt_transport *transport; + + list_for_each_entry(transport, <t_transport_list, node) { + if (!strcmp(transport->name, name)) + return transport; + } + return NULL; } struct ltt_channel *ltt_channel_create(struct ltt_session *session, @@ -99,33 +114,38 @@ struct ltt_channel *ltt_channel_create(struct ltt_session *session, unsigned int read_timer_interval) { struct ltt_channel *chan; - struct ltt_transport *transport = NULL, *tran_iter; + struct ltt_transport *transport; char *transport_name; mutex_lock(&sessions_mutex); - if (session->active) + 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"; - list_for_each_entry(tran_iter, <t_transport_list, node) { - if (!strcmp(tran_iter->name, transport_name)) { - transport = tran_iter; - break; - } } - if (!transport) + 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; - chan = kmalloc(sizeof(struct ltt_channel), GFP_KERNEL); + } + chan = kzalloc(sizeof(struct ltt_channel), GFP_KERNEL); if (!chan) goto nomem; chan->session = session; init_waitqueue_head(&chan->notify_wait); - transport->ops.channel_create(session, buf_addr, subbuf_size, - num_subbuf, switch_timer_interval, - read_timer_interval); + chan->chan = transport->ops.channel_create("[lttng]", session, buf_addr, + subbuf_size, num_subbuf, switch_timer_interval, + read_timer_interval); + if (!chan->chan) + goto create_error; + chan->ops = &transport->ops; list_add(&chan->list, &session->chan); mutex_unlock(&sessions_mutex); return chan; +create_error: + kfree(chan); nomem: notransport: active: @@ -136,9 +156,9 @@ active: /* * Only used internally at session destruction. */ -int _ltt_channel_destroy(struct ltt_channel *chan) +void _ltt_channel_destroy(struct ltt_channel *chan) { - transport->ops.channel_destroy(chan); + chan->ops->channel_destroy(chan->chan); list_del(&chan->list); kfree(chan); } @@ -157,38 +177,43 @@ 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)) goto exist; - event = kmem_cache_zalloc(events_cache, GFP_KERNEL); + 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 error; + goto name_error; strcpy(event->name, name); event->chan = chan; event->probe = probe; event->filter = filter; event->id = chan->free_event_id++; event->itype = itype; - mutex_unlock(&sessions_mutex); /* Populate ltt_event structure before tracepoint registration. */ smp_wmb(); switch (itype) { case INSTRUM_TRACEPOINTS: ret = tracepoint_probe_register(name, probe, 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; -error: - kmem_cache_free(event); +register_error: + kfree(event->name); +name_error: + kmem_cache_free(event_cache, event); cache_error: exist: full: @@ -199,17 +224,31 @@ 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(name, event->probe, event); + ret = tracepoint_probe_unregister(event->name, event->probe, + event); + if (ret) + return ret; break; default: WARN_ON_ONCE(1); } + return ret; +} + +/* + * Only used internally at session destruction. + */ +void _ltt_event_destroy(struct ltt_event *event) +{ kfree(event->name); - kmem_cache_free(event); + list_del(&event->list); + kmem_cache_free(event_cache, event); } /** @@ -256,21 +295,38 @@ static int __init ltt_events_init(void) { int ret; - events_cache = KMEM_CACHE(ltt_event, 0); - if (!events_cache) + event_cache = KMEM_CACHE(ltt_event, 0); + if (!event_cache) return -ENOMEM; + ret = ltt_probes_init(); + if (ret) + goto error; + ret = ltt_debugfs_abi_init(); + if (ret) + goto error_abi; return 0; +error_abi: + ltt_probes_exit(); +error: + kmem_cache_destroy(event_cache); + return ret; } +module_init(ltt_events_init); + static void __exit ltt_events_exit(void) { struct ltt_session *session, *tmpsession; + ltt_debugfs_abi_exit(); + ltt_probes_exit(); list_for_each_entry_safe(session, tmpsession, &sessions, list) ltt_session_destroy(session); - kmem_cache_destroy(events_cache); + kmem_cache_destroy(event_cache); } +module_exit(ltt_events_exit); + MODULE_LICENSE("GPL and additional rights"); MODULE_AUTHOR("Mathieu Desnoyers "); MODULE_DESCRIPTION("LTTng Events");