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;
   7  * version 2.1 of the License.
   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 #define _LGPL_SOURCE
  21 #include <errno.h>
  22 #include <ust/tracepoint.h>
  23 #include <ust/tracepoint-internal.h>
  24 #include <ust/core.h>
  25 #include <ust/kcompat/kcompat.h>
  26 #include <urcu-bp.h>
  27
  28 #include "usterr_signal_safe.h"
  29
  30 /* libraries that contain trace_events (struct trace_event_lib) */
  31 static CDS_LIST_HEAD(libs);
  32
  33 static DEFINE_MUTEX(trace_events_mutex);
  34
  35 void lock_trace_events(void)
  36 {
  37         pthread_mutex_lock(&trace_events_mutex);
  38 }
  39
  40 void unlock_trace_events(void)
  41 {
  42         pthread_mutex_unlock(&trace_events_mutex);
  43 }
  44
  45
  46 int lib_get_iter_trace_events(struct trace_event_iter *iter)
  47 {
  48         struct trace_event_lib *iter_lib;
  49         int found = 0;
  50
  51         cds_list_for_each_entry(iter_lib, &libs, list) {
  52                 if (iter_lib < iter->lib)
  53                         continue;
  54                 else if (iter_lib > iter->lib)
  55                         iter->trace_event = NULL;
  56                 found = trace_event_get_iter_range(&iter->trace_event,
  57                         iter_lib->trace_events_start,
  58                         iter_lib->trace_events_start + iter_lib->trace_events_count);
  59                 if (found) {
  60                         iter->lib = iter_lib;
  61                         break;
  62                 }
  63         }
  64         return found;
  65 }
  66
  67 /**
  68  * trace_event_get_iter_range - Get a next trace_event iterator given a range.
  69  * @trace_event: current trace_events (in), next trace_event (out)
  70  * @begin: beginning of the range
  71  * @end: end of the range
  72  *
  73  * Returns whether a next trace_event has been found (1) or not (0).
  74  * Will return the first trace_event in the range if the input trace_event is NULL.
  75  */
  76 int trace_event_get_iter_range(struct trace_event * const **trace_event,
  77         struct trace_event * const *begin,
  78         struct trace_event * const *end)
  79 {
  80         if (!*trace_event && begin != end)
  81                 *trace_event = begin;
  82         while (*trace_event >= begin && *trace_event < end) {
  83                 if (!**trace_event)
  84                         (*trace_event)++;       /* skip dummy */
  85                 else
  86                         return 1;
  87         }
  88         return 0;
  89 }
  90
  91 static void trace_event_get_iter(struct trace_event_iter *iter)
  92 {
  93         int found = 0;
  94
  95         found = lib_get_iter_trace_events(iter);
  96
  97         if (!found)
  98                 trace_event_iter_reset(iter);
  99 }
 100
 101 void trace_event_iter_start(struct trace_event_iter *iter)
 102 {
 103         trace_event_get_iter(iter);
 104 }
 105
 106 void trace_event_iter_next(struct trace_event_iter *iter)
 107 {
 108         iter->trace_event++;
 109         /*
 110          * iter->trace_event may be invalid because we blindly incremented it.
 111          * Make sure it is valid by marshalling on the trace_events, getting the
 112          * trace_events from following modules if necessary.
 113          */
 114         trace_event_get_iter(iter);
 115 }
 116
 117 void trace_event_iter_reset(struct trace_event_iter *iter)
 118 {
 119         iter->lib = NULL;
 120         iter->trace_event = NULL;
 121 }
 122
 123 int trace_event_register_lib(struct trace_event * const *trace_events_start,
 124                              int trace_events_count)
 125 {
 126         struct trace_event_lib *pl, *iter;
 127
 128         pl = (struct trace_event_lib *) malloc(sizeof(struct trace_event_lib));
 129
 130         pl->trace_events_start = trace_events_start;
 131         pl->trace_events_count = trace_events_count;
 132
 133         /* FIXME: maybe protect this with its own mutex? */
 134         pthread_mutex_lock(&trace_events_mutex);
 135         /*
 136          * We sort the libs by struct lib pointer address.
 137          */
 138         cds_list_for_each_entry_reverse(iter, &libs, list) {
 139                 BUG_ON(iter == pl);    /* Should never be in the list twice */
 140                 if (iter < pl) {
 141                         /* We belong to the location right after iter. */
 142                         cds_list_add(&pl->list, &iter->list);
 143                         goto lib_added;
 144                 }
 145         }
 146         /* We should be added at the head of the list */
 147         cds_list_add(&pl->list, &libs);
 148 lib_added:
 149         pthread_mutex_unlock(&trace_events_mutex);
 150
 151         /* trace_events_count - 1: skip dummy */
 152         DBG("just registered a trace_events section from %p and having %d trace_events (minus dummy trace_event)", trace_events_start, trace_events_count);
 153
 154         return 0;
 155 }
 156
 157 int trace_event_unregister_lib(struct trace_event * const *trace_events_start)
 158 {
 159         struct trace_event_lib *lib;
 160
 161         pthread_mutex_lock(&trace_events_mutex);
 162
 163         cds_list_for_each_entry(lib, &libs, list) {
 164                 if(lib->trace_events_start == trace_events_start) {
 165                         struct trace_event_lib *lib2free = lib;
 166                         cds_list_del(&lib->list);
 167                         free(lib2free);
 168                         break;
 169                 }
 170         }
 171
 172         pthread_mutex_unlock(&trace_events_mutex);
 173
 174         return 0;
 175 }