liblttng-ust/ltt-probes.c

   1 /*
   2  * ltt-probes.c
   3  *
   4  * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * Holds LTTng probes registry.
   7  *
   8  * Dual LGPL v2.1/GPL v2 license.
   9  */
  10
  11 #include <string.h>
  12 #include <errno.h>
  13 #include <urcu/list.h>
  14 #include <lttng/ust-events.h>
  15 #include <assert.h>
  16
  17 #include "ltt-tracer-core.h"
  18
  19 /*
  20  * probe list is protected by ust_lock()/ust_unlock().
  21  */
  22 static CDS_LIST_HEAD(probe_list);
  23
  24 static
  25 const struct lttng_probe_desc *find_provider(const char *provider)
  26 {
  27         struct lttng_probe_desc *iter;
  28
  29         cds_list_for_each_entry(iter, &probe_list, head) {
  30                 if (!strcmp(iter->provider, provider))
  31                         return iter;
  32         }
  33         return NULL;
  34 }
  35
  36 static
  37 const struct lttng_event_desc *find_event(const char *name)
  38 {
  39         struct lttng_probe_desc *probe_desc;
  40         int i;
  41
  42         cds_list_for_each_entry(probe_desc, &probe_list, head) {
  43                 for (i = 0; i < probe_desc->nr_events; i++) {
  44                         if (!strcmp(probe_desc->event_desc[i]->name, name))
  45                                 return probe_desc->event_desc[i];
  46                 }
  47         }
  48         return NULL;
  49 }
  50
  51 int ltt_probe_register(struct lttng_probe_desc *desc)
  52 {
  53         struct lttng_probe_desc *iter;
  54         int ret = 0;
  55         int i;
  56
  57         ust_lock();
  58         if (find_provider(desc->provider)) {
  59                 ret = -EEXIST;
  60                 goto end;
  61         }
  62         /*
  63          * TODO: This is O(N^2). Turn into a hash table when probe registration
  64          * overhead becomes an issue.
  65          */
  66         for (i = 0; i < desc->nr_events; i++) {
  67                 if (find_event(desc->event_desc[i]->name)) {
  68                         ret = -EEXIST;
  69                         goto end;
  70                 }
  71         }
  72
  73         /*
  74          * We sort the providers by struct lttng_probe_desc pointer
  75          * address.
  76          */
  77         cds_list_for_each_entry_reverse(iter, &probe_list, head) {
  78                 BUG_ON(iter == desc); /* Should never be in the list twice */
  79                 if (iter < desc) {
  80                         /* We belong to the location right after iter. */
  81                         cds_list_add(&desc->head, &iter->head);
  82                         goto desc_added;
  83                 }
  84         }
  85         /* We should be added at the head of the list */
  86         cds_list_add(&desc->head, &probe_list);
  87 desc_added:
  88
  89         /*
  90          * fix the events awaiting probe load.
  91          */
  92         for (i = 0; i < desc->nr_events; i++) {
  93                 ret = pending_probe_fix_events(desc->event_desc[i]);
  94                 assert(!ret);
  95         }
  96 end:
  97         ust_unlock();
  98         return ret;
  99 }
 100
 101 void ltt_probe_unregister(struct lttng_probe_desc *desc)
 102 {
 103         ust_lock();
 104         cds_list_del(&desc->head);
 105         ust_unlock();
 106 }
 107
 108 /*
 109  * called with UST lock held.
 110  */
 111 const struct lttng_event_desc *ltt_event_get(const char *name)
 112 {
 113         const struct lttng_event_desc *event;
 114
 115         event = find_event(name);
 116         if (!event)
 117                 return NULL;
 118         return event;
 119 }
 120
 121 void ltt_event_put(const struct lttng_event_desc *event)
 122 {
 123 }