ltt-events.c

   1 /*
   2  * ltt-events.c
   3  *
   4  * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * Holds LTTng per-session event registry.
   7  */
   8
   9 #include <linux/module.h>
  10 #include "ltt-events.h"
  11
  12 static LIST_HEAD(sessions);
  13 static DEFINE_MUTEX(sessions_mutex);
  14 static struct kmem_cache *event_cache;
  15
  16 static void synchronize_trace(void)
  17 {
  18         synchronize_sched();
  19 #ifdef CONFIG_PREEMPT_RT
  20         synchronize_rcu();
  21 #endif
  22 }
  23
  24 struct ltt_session *ltt_session_create(char *name)
  25 {
  26         struct ltt_session *session;
  27
  28         mutex_lock(&sessions_mutex);
  29         list_for_each_entry(session, &sessions, list)
  30                 if (!strcmp(session->name, name))
  31                         goto exist;
  32         session = kmalloc(sizeof(struct ltt_session) + strlen(name) + 1);
  33         if (!session)
  34                 return NULL;
  35         strcpy(session->name, name);
  36         INIT_LIST_HEAD(&session->chan);
  37         list_add(&session->list, &sessions);
  38         mutex_unlock(&sessions_mutex);
  39         return session;
  40
  41 exist:
  42         mutex_unlock(&sessions_mutex);
  43         return NULL;
  44 }
  45
  46 int ltt_session_destroy(struct ltt_session *session)
  47 {
  48         struct ltt_channel *chan, *tmpchan;
  49         struct ltt_event *event, *tmpevent;
  50
  51         mutex_lock(&sessions_mutex);
  52         session->active = 0;
  53         synchronize_trace();    /* Wait for in-flight events to complete */
  54         list_for_each_entry_safe(event, tmpevent, &session->events, list)
  55                 _ltt_event_destroy(event);
  56         list_for_each_entry_safe(chan, tmpchan, &session->chan, list)
  57                 _ltt_channel_destroy(chan);
  58         list_del(&session->list);
  59         mutex_unlock(&sessions_mutex);
  60         kfree(session);
  61 }
  62
  63 struct ltt_channel *ltt_channel_create(struct ltt_session *session, char *name,
  64                                        int overwrite, void *buf_addr,
  65                                        size_t subbuf_size, size_t num_subbuf,
  66                                        unsigned int switch_timer_interval,
  67                                        unsigned int read_timer_interval)
  68 {
  69         struct ltt_channel *chan;
  70
  71         mutex_lock(&sessions_mutex);
  72         if (session->active)
  73                 goto active;    /* Refuse to add channel to active session */
  74         list_for_each_entry(chan, &session->chan, list)
  75                 if (!strcmp(chan->name, name))
  76                         goto exist;
  77         chan = kmalloc(sizeof(struct ltt_channel) + strlen(name) + 1, GFP_KERNEL);
  78         if (!chan)
  79                 return NULL;
  80         strcpy(chan->name, name);
  81         chan->session = session;
  82
  83         /* TODO: create rb channel */
  84         list_add(&chan->list, &session->chan);
  85         mutex_unlock(&sessions_mutex);
  86         return chan;
  87
  88 exist:
  89 active:
  90         mutex_unlock(&sessions_mutex);
  91         return NULL;
  92 }
  93
  94 /*
  95  * Only used internally at session destruction.
  96  */
  97 int _ltt_channel_destroy(struct ltt_channel *chan)
  98 {
  99         /* TODO: destroy rb channel */
 100         list_del(&chan->list);
 101         kfree(chan);
 102 }
 103
 104 /*
 105  * Supports event creation while tracing session is active.
 106  */
 107 struct ltt_event *ltt_event_create(struct ltt_channel *chan, char *name,
 108                                    void *filter)
 109 {
 110         struct ltt_event *event;
 111         int ret;
 112
 113         mutex_lock(&sessions_mutex);
 114         if (chan->free_event_id == -1UL)
 115                 goto full;
 116         /*
 117          * This is O(n^2) (for each event loop called at event creation).
 118          * Might require a hash if we have lots of events.
 119          */
 120         list_for_each_entry(event, &chan->session->events, list)
 121                 if (!strcmp(event->name, name))
 122                         goto exist;
 123         event = kmem_cache_zalloc(events_cache, GFP_KERNEL);
 124         if (!event)
 125                 goto cache_error;
 126         event->name = kmalloc(strlen(name) + 1, GFP_KERNEL);
 127         if (!event->name)
 128                 goto error;
 129         strcpy(event->name, name);
 130         event->chan = chan;
 131         event->filter = filter;
 132         event->id = chan->free_event_id++;
 133         mutex_unlock(&sessions_mutex);
 134         /* Populate ltt_event structure before tracepoint registration. */
 135         smp_wmb();
 136         return event;
 137
 138 error:
 139         kmem_cache_free(event);
 140 cache_error:
 141 exist:
 142 full:
 143         mutex_unlock(&sessions_mutex);
 144         return NULL;
 145 }
 146
 147 /*
 148  * Only used internally at session destruction.
 149  */
 150 int _ltt_event_destroy(struct ltt_event *event)
 151 {
 152         /* TODO unregister from tracepoint */
 153         kfree(event->name);
 154         kmem_cache_free(event);
 155 }
 156
 157 static int __init ltt_events_init(void)
 158 {
 159         int ret;
 160
 161         events_cache = KMEM_CACHE(ltt_event, 0);
 162         if (!events_cache)
 163                 return -ENOMEM;
 164
 165         /* TODO: show ABI to userspace */
 166
 167         return 0;
 168 }
 169
 170 static void __exit ltt_events_exit(void)
 171 {
 172         struct ltt_session *session, *tmpsession;
 173
 174         /* TODO: hide ABI from userspace, wait for callers to release refs. */
 175
 176         list_for_each_entry_safe(session, tmpsession, &sessions, list)
 177                 ltt_session_destroy(session);
 178         kmem_cache_destroy(events_cache);
 179 }
 180
 181 MODULE_LICENSE("GPL and additional rights");
 182 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
 183 MODULE_DESCRIPTION("LTTng Events");