liblttng-ust/ltt-probes.c

   1 /*
   2  * ltt-probes.c
   3  *
   4  * Holds LTTng probes registry.
   5  *
   6  * Copyright 2010-2012 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; only
  11  * version 2.1 of the License.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <urcu/list.h>
  26 #include <urcu/hlist.h>
  27 #include <lttng/ust-events.h>
  28 #include <lttng/tracepoint.h>
  29 #include "tracepoint-internal.h"
  30 #include <assert.h>
  31 #include <helper.h>
  32 #include <ctype.h>
  33
  34 #include "ltt-tracer-core.h"
  35 #include "jhash.h"
  36 #include "error.h"
  37
  38 /*
  39  * probe list is protected by ust_lock()/ust_unlock().
  40  */
  41 static CDS_LIST_HEAD(probe_list);
  42
  43 static
  44 const struct lttng_probe_desc *find_provider(const char *provider)
  45 {
  46         struct lttng_probe_desc *iter;
  47
  48         cds_list_for_each_entry(iter, &probe_list, head) {
  49                 if (!strcmp(iter->provider, provider))
  50                         return iter;
  51         }
  52         return NULL;
  53 }
  54
  55 static
  56 const struct lttng_event_desc *find_event(const char *name)
  57 {
  58         struct lttng_probe_desc *probe_desc;
  59         int i;
  60
  61         cds_list_for_each_entry(probe_desc, &probe_list, head) {
  62                 for (i = 0; i < probe_desc->nr_events; i++) {
  63                         if (!strncmp(probe_desc->event_desc[i]->name, name,
  64                                         LTTNG_UST_SYM_NAME_LEN - 1))
  65                                 return probe_desc->event_desc[i];
  66                 }
  67         }
  68         return NULL;
  69 }
  70
  71 int ltt_probe_register(struct lttng_probe_desc *desc)
  72 {
  73         struct lttng_probe_desc *iter;
  74         int ret = 0;
  75         int i;
  76
  77         ust_lock();
  78         if (find_provider(desc->provider)) {
  79                 ret = -EEXIST;
  80                 goto end;
  81         }
  82         /*
  83          * TODO: This is O(N^2). Turn into a hash table when probe registration
  84          * overhead becomes an issue.
  85          */
  86         for (i = 0; i < desc->nr_events; i++) {
  87                 if (find_event(desc->event_desc[i]->name)) {
  88                         ret = -EEXIST;
  89                         goto end;
  90                 }
  91         }
  92
  93         /*
  94          * We sort the providers by struct lttng_probe_desc pointer
  95          * address.
  96          */
  97         cds_list_for_each_entry_reverse(iter, &probe_list, head) {
  98                 BUG_ON(iter == desc); /* Should never be in the list twice */
  99                 if (iter < desc) {
 100                         /* We belong to the location right after iter. */
 101                         cds_list_add(&desc->head, &iter->head);
 102                         goto desc_added;
 103                 }
 104         }
 105         /* We should be added at the head of the list */
 106         cds_list_add(&desc->head, &probe_list);
 107 desc_added:
 108         DBG("just registered probe %s containing %u events",
 109                 desc->provider, desc->nr_events);
 110         /*
 111          * fix the events awaiting probe load.
 112          */
 113         for (i = 0; i < desc->nr_events; i++) {
 114                 const struct lttng_event_desc *ed;
 115
 116                 ed = desc->event_desc[i];
 117                 DBG("Registered event probe \"%s\" with signature \"%s\"",
 118                         ed->name, ed->signature);
 119                 ret = pending_probe_fix_events(ed);
 120                 assert(!ret);
 121         }
 122 end:
 123         ust_unlock();
 124         return ret;
 125 }
 126
 127 void ltt_probe_unregister(struct lttng_probe_desc *desc)
 128 {
 129         ust_lock();
 130         cds_list_del(&desc->head);
 131         DBG("just unregistered probe %s", desc->provider);
 132         ust_unlock();
 133 }
 134
 135 /*
 136  * called with UST lock held.
 137  */
 138 const struct lttng_event_desc *ltt_event_get(const char *name)
 139 {
 140         const struct lttng_event_desc *event;
 141
 142         event = find_event(name);
 143         if (!event)
 144                 return NULL;
 145         return event;
 146 }
 147
 148 void ltt_event_put(const struct lttng_event_desc *event)
 149 {
 150 }
 151
 152 void ltt_probes_prune_event_list(struct lttng_ust_tracepoint_list *list)
 153 {
 154         struct tp_list_entry *list_entry, *tmp;
 155
 156         cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
 157                 cds_list_del(&list_entry->head);
 158                 free(list_entry);
 159         }
 160 }
 161
 162 /*
 163  * called with UST lock held.
 164  */
 165 int ltt_probes_get_event_list(struct lttng_ust_tracepoint_list *list)
 166 {
 167         struct lttng_probe_desc *probe_desc;
 168         int i;
 169
 170         CDS_INIT_LIST_HEAD(&list->head);
 171         cds_list_for_each_entry(probe_desc, &probe_list, head) {
 172                 for (i = 0; i < probe_desc->nr_events; i++) {
 173                         struct tp_list_entry *list_entry;
 174
 175                         list_entry = zmalloc(sizeof(*list_entry));
 176                         if (!list_entry)
 177                                 goto err_nomem;
 178                         cds_list_add(&list_entry->head, &list->head);
 179                         strncpy(list_entry->tp.name,
 180                                 probe_desc->event_desc[i]->name,
 181                                 LTTNG_UST_SYM_NAME_LEN);
 182                         list_entry->tp.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 183                         if (!probe_desc->event_desc[i]->loglevel) {
 184                                 list_entry->tp.loglevel = TRACE_DEFAULT;
 185                         } else {
 186                                 list_entry->tp.loglevel = *(*probe_desc->event_desc[i]->loglevel);
 187                         }
 188                 }
 189         }
 190         if (cds_list_empty(&list->head))
 191                 list->iter = NULL;
 192         else
 193                 list->iter =
 194                         cds_list_first_entry(&list->head, struct tp_list_entry, head);
 195         return 0;
 196
 197 err_nomem:
 198         ltt_probes_prune_event_list(list);
 199         return -ENOMEM;
 200 }
 201
 202 /*
 203  * Return current iteration position, advance internal iterator to next.
 204  * Return NULL if end of list.
 205  */
 206 struct lttng_ust_tracepoint_iter *
 207         lttng_ust_tracepoint_list_get_iter_next(struct lttng_ust_tracepoint_list *list)
 208 {
 209         struct tp_list_entry *entry;
 210
 211         if (!list->iter)
 212                 return NULL;
 213         entry = list->iter;
 214         if (entry->head.next == &list->head)
 215                 list->iter = NULL;
 216         else
 217                 list->iter = cds_list_entry(entry->head.next,
 218                                 struct tp_list_entry, head);
 219         return &entry->tp;
 220 }
 221
 222 void ltt_probes_prune_field_list(struct lttng_ust_field_list *list)
 223 {
 224         struct tp_field_list_entry *list_entry, *tmp;
 225
 226         cds_list_for_each_entry_safe(list_entry, tmp, &list->head, head) {
 227                 cds_list_del(&list_entry->head);
 228                 free(list_entry);
 229         }
 230 }
 231
 232 /*
 233  * called with UST lock held.
 234  */
 235 int ltt_probes_get_field_list(struct lttng_ust_field_list *list)
 236 {
 237         struct lttng_probe_desc *probe_desc;
 238         int i;
 239
 240         CDS_INIT_LIST_HEAD(&list->head);
 241         cds_list_for_each_entry(probe_desc, &probe_list, head) {
 242                 for (i = 0; i < probe_desc->nr_events; i++) {
 243                         const struct lttng_event_desc *event_desc =
 244                                 probe_desc->event_desc[i];
 245                         int j;
 246
 247                         for (j = 0; j < event_desc->nr_fields; j++) {
 248                                 const struct lttng_event_field *event_field =
 249                                         &event_desc->fields[j];
 250                                 struct tp_field_list_entry *list_entry;
 251
 252                                 list_entry = zmalloc(sizeof(*list_entry));
 253                                 if (!list_entry)
 254                                         goto err_nomem;
 255                                 cds_list_add(&list_entry->head, &list->head);
 256                                 strncpy(list_entry->field.event_name,
 257                                         event_desc->name,
 258                                         LTTNG_UST_SYM_NAME_LEN);
 259                                 list_entry->field.event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 260                                 strncpy(list_entry->field.field_name,
 261                                         event_field->name,
 262                                         LTTNG_UST_SYM_NAME_LEN);
 263                                 list_entry->field.field_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 264                                 switch (event_field->type.atype) {
 265                                 case atype_integer:
 266                                         list_entry->field.type = LTTNG_UST_FIELD_INTEGER;
 267                                         break;
 268                                 case atype_string:
 269                                         list_entry->field.type = LTTNG_UST_FIELD_STRING;
 270                                         break;
 271                                 case atype_array:
 272                                         if (event_field->type.u.array.elem_type.atype != atype_integer
 273                                                 || event_field->type.u.array.elem_type.u.basic.integer.encoding == lttng_encode_none)
 274                                                 list_entry->field.type = LTTNG_UST_FIELD_OTHER;
 275                                         else
 276                                                 list_entry->field.type = LTTNG_UST_FIELD_STRING;
 277                                         break;
 278                                 case atype_sequence:
 279                                         if (event_field->type.u.sequence.elem_type.atype != atype_integer
 280                                                 || event_field->type.u.sequence.elem_type.u.basic.integer.encoding == lttng_encode_none)
 281                                                 list_entry->field.type = LTTNG_UST_FIELD_OTHER;
 282                                         else
 283                                                 list_entry->field.type = LTTNG_UST_FIELD_STRING;
 284                                         break;
 285                                 case atype_float:
 286                                         list_entry->field.type = LTTNG_UST_FIELD_FLOAT;
 287                                         break;
 288                                 case atype_enum:
 289                                         list_entry->field.type = LTTNG_UST_FIELD_ENUM;
 290                                         break;
 291                                 default:
 292                                         list_entry->field.type = LTTNG_UST_FIELD_OTHER;
 293                                 }
 294                                 if (!event_desc->loglevel) {
 295                                         list_entry->field.loglevel = TRACE_DEFAULT;
 296                                 } else {
 297                                         list_entry->field.loglevel = *(*event_desc->loglevel);
 298                                 }
 299                         }
 300                 }
 301         }
 302         if (cds_list_empty(&list->head))
 303                 list->iter = NULL;
 304         else
 305                 list->iter =
 306                         cds_list_first_entry(&list->head,
 307                                 struct tp_field_list_entry, head);
 308         return 0;
 309
 310 err_nomem:
 311         ltt_probes_prune_field_list(list);
 312         return -ENOMEM;
 313 }
 314
 315 /*
 316  * Return current iteration position, advance internal iterator to next.
 317  * Return NULL if end of list.
 318  */
 319 struct lttng_ust_field_iter *
 320         lttng_ust_field_list_get_iter_next(struct lttng_ust_field_list *list)
 321 {
 322         struct tp_field_list_entry *entry;
 323
 324         if (!list->iter)
 325                 return NULL;
 326         entry = list->iter;
 327         if (entry->head.next == &list->head)
 328                 list->iter = NULL;
 329         else
 330                 list->iter = cds_list_entry(entry->head.next,
 331                                 struct tp_field_list_entry, head);
 332         return &entry->field;
 333 }
 334
 335 /*
 336  * marshall all probes/all events and create those that fit the
 337  * wildcard. Add them to the events list as created.
 338  */
 339 void ltt_probes_create_wildcard_events(struct wildcard_entry *entry,
 340                                 struct session_wildcard *wildcard)
 341 {
 342         struct lttng_probe_desc *probe_desc;
 343         struct lttng_ust_event event_param;
 344         int i;
 345
 346         cds_list_for_each_entry(probe_desc, &probe_list, head) {
 347                 for (i = 0; i < probe_desc->nr_events; i++) {
 348                         const struct lttng_event_desc *event_desc;
 349                         int match = 0;
 350
 351                         event_desc = probe_desc->event_desc[i];
 352                         /* compare excluding final '*' */
 353                         assert(strlen(entry->name) > 0);
 354                         if (strcmp(event_desc->name, "lttng_ust:metadata")
 355                                         && (strlen(entry->name) == 1
 356                                                 || !strncmp(event_desc->name, entry->name,
 357                                                         strlen(entry->name) - 1))) {
 358                                 if (ltt_loglevel_match(event_desc,
 359                                         entry->loglevel_type,
 360                                                 entry->loglevel)) {
 361                                         match = 1;
 362                                 }
 363                         }
 364                         if (match) {
 365                                 struct ltt_event *ev;
 366                                 int ret;
 367
 368                                 memcpy(&event_param, &wildcard->event_param,
 369                                                 sizeof(event_param));
 370                                 memcpy(event_param.name,
 371                                         event_desc->name,
 372                                         sizeof(event_param.name));
 373                                 /* create event */
 374                                 ret = ltt_event_create(wildcard->chan,
 375                                         &event_param, &ev);
 376                                 if (ret) {
 377                                         DBG("Error creating event");
 378                                         continue;
 379                                 }
 380                                 cds_list_add(&ev->wildcard_list,
 381                                         &wildcard->events);
 382                         }
 383                 }
 384         }
 385         lttng_filter_wildcard_link_bytecode(wildcard);
 386 }
 387