libust/trace_event.c

   1 /*
   2  * Copyright (C) 2010 Nils Carlson
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  17  *
  18  */
  19
  20 #include <errno.h>
  21 #include <ust/tracepoint.h>
  22 #include <ust/core.h>
  23 #include <ust/kcompat/kcompat.h>
  24 #include "usterr_signal_safe.h"
  25
  26 #define _LGPL_SOURCE
  27 #include <urcu-bp.h>
  28
  29 /* libraries that contain trace_events (struct trace_event_lib) */
  30 static CDS_LIST_HEAD(libs);
  31
  32 static DEFINE_MUTEX(trace_events_mutex);
  33
  34 void lock_trace_events(void)
  35 {
  36         pthread_mutex_lock(&trace_events_mutex);
  37 }
  38
  39 void unlock_trace_events(void)
  40 {
  41         pthread_mutex_unlock(&trace_events_mutex);
  42 }
  43
  44
  45 int lib_get_iter_trace_events(struct trace_event_iter *iter)
  46 {
  47         struct trace_event_lib *iter_lib;
  48         int found = 0;
  49
  50         cds_list_for_each_entry(iter_lib, &libs, list) {
  51                 if (iter_lib < iter->lib)
  52                         continue;
  53                 else if (iter_lib > iter->lib)
  54                         iter->trace_event = NULL;
  55                 found = trace_event_get_iter_range(&iter->trace_event,
  56                         iter_lib->trace_events_start,
  57                         iter_lib->trace_events_start + iter_lib->trace_events_count);
  58                 if (found) {
  59                         iter->lib = iter_lib;
  60                         break;
  61                 }
  62         }
  63         return found;
  64 }
  65
  66 /**
  67  * trace_event_get_iter_range - Get a next trace_event iterator given a range.
  68  * @trace_event: current trace_events (in), next trace_event (out)
  69  * @begin: beginning of the range
  70  * @end: end of the range
  71  *
  72  * Returns whether a next trace_event has been found (1) or not (0).
  73  * Will return the first trace_event in the range if the input trace_event is NULL.
  74  */
  75 int trace_event_get_iter_range(struct trace_event * const **trace_event,
  76         struct trace_event * const *begin,
  77         struct trace_event * const *end)
  78 {
  79         if (!*trace_event && begin != end)
  80                 *trace_event = begin;
  81         while (*trace_event >= begin && *trace_event < end) {
  82                 if (!**trace_event)
  83                         (*trace_event)++;       /* skip dummy */
  84                 else
  85                         return 1;
  86         }
  87         return 0;
  88 }
  89
  90 static void trace_event_get_iter(struct trace_event_iter *iter)
  91 {
  92         int found = 0;
  93
  94         found = lib_get_iter_trace_events(iter);
  95
  96         if (!found)
  97                 trace_event_iter_reset(iter);
  98 }
  99
 100 void trace_event_iter_start(struct trace_event_iter *iter)
 101 {
 102         trace_event_get_iter(iter);
 103 }
 104
 105 void trace_event_iter_next(struct trace_event_iter *iter)
 106 {
 107         iter->trace_event++;
 108         /*
 109          * iter->trace_event may be invalid because we blindly incremented it.
 110          * Make sure it is valid by marshalling on the trace_events, getting the
 111          * trace_events from following modules if necessary.
 112          */
 113         trace_event_get_iter(iter);
 114 }
 115
 116 void trace_event_iter_reset(struct trace_event_iter *iter)
 117 {
 118         iter->lib = NULL;
 119         iter->trace_event = NULL;
 120 }
 121
 122 int trace_event_register_lib(struct trace_event * const *trace_events_start,
 123                              int trace_events_count)
 124 {
 125         struct trace_event_lib *pl, *iter;
 126
 127         pl = (struct trace_event_lib *) malloc(sizeof(struct trace_event_lib));
 128
 129         pl->trace_events_start = trace_events_start;
 130         pl->trace_events_count = trace_events_count;
 131
 132         /* FIXME: maybe protect this with its own mutex? */
 133         pthread_mutex_lock(&trace_events_mutex);
 134         /*
 135          * We sort the libs by struct lib pointer address.
 136          */
 137         cds_list_for_each_entry_reverse(iter, &libs, list) {
 138                 BUG_ON(iter == pl);    /* Should never be in the list twice */
 139                 if (iter < pl) {
 140                         /* We belong to the location right after iter. */
 141                         cds_list_add(&pl->list, &iter->list);
 142                         goto lib_added;
 143                 }
 144         }
 145         /* We should be added at the head of the list */
 146         cds_list_add(&pl->list, &libs);
 147 lib_added:
 148         pthread_mutex_unlock(&trace_events_mutex);
 149
 150         /* trace_events_count - 1: skip dummy */
 151         DBG("just registered a trace_events section from %p and having %d trace_events (minus dummy trace_event)", trace_events_start, trace_events_count);
 152
 153         return 0;
 154 }
 155
 156 int trace_event_unregister_lib(struct trace_event * const *trace_events_start)
 157 {
 158         struct trace_event_lib *lib;
 159
 160         pthread_mutex_lock(&trace_events_mutex);
 161
 162         cds_list_for_each_entry(lib, &libs, list) {
 163                 if(lib->trace_events_start == trace_events_start) {
 164                         struct trace_event_lib *lib2free = lib;
 165                         cds_list_del(&lib->list);
 166                         free(lib2free);
 167                         break;
 168                 }
 169         }
 170
 171         pthread_mutex_unlock(&trace_events_mutex);
 172
 173         return 0;
 174 }