src/lttng-probes.c

   1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
   2  *
   3  * lttng-probes.c
   4  *
   5  * Holds LTTng probes registry.
   6  *
   7  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/list.h>
  12 #include <linux/mutex.h>
  13 #include <linux/seq_file.h>
  14
  15 #include <lttng/events.h>
  16
  17 /*
  18  * probe list is protected by sessions lock.
  19  */
  20 static LIST_HEAD(_probe_list);
  21
  22 /*
  23  * List of probes registered by not yet processed.
  24  */
  25 static LIST_HEAD(lazy_probe_init);
  26
  27 /*
  28  * lazy_nesting counter ensures we don't notify lazy probe registration
  29  * fixup while we are performing the fixup. It is protected by the
  30  * sessions lock.
  31  */
  32 static int lazy_nesting;
  33
  34 DEFINE_PER_CPU(struct lttng_dynamic_len_stack, lttng_dynamic_len_stack);
  35
  36 EXPORT_PER_CPU_SYMBOL_GPL(lttng_dynamic_len_stack);
  37
  38 /*
  39  * Called under sessions lock.
  40  */
  41 static
  42 int check_event_provider(struct lttng_kernel_probe_desc *desc)
  43 {
  44         int i, mismatch = 0;
  45         size_t provider_name_len;
  46
  47         provider_name_len = strnlen(desc->provider_name,
  48                                 LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1);
  49         for (i = 0; i < desc->nr_events; i++) {
  50                 /*
  51                  * The event name needs to start with provider name + _ +
  52                  * one or more letter.
  53                  */
  54                 if (strncmp(desc->event_desc[i]->event_name, desc->provider_name, provider_name_len))
  55                         mismatch = 1;
  56                 else if (strlen(desc->event_desc[i]->event_name) <= provider_name_len + 1)
  57                         mismatch = 1;
  58                 else if (desc->event_desc[i]->event_name[provider_name_len] != '_')
  59                         mismatch = 1;
  60
  61                 if (mismatch) {
  62                         printk(KERN_WARNING "LTTng: event provider mismatch: "
  63                                 "The event name needs to start with provider "
  64                                 "name + _ + one or more letter, "
  65                                 "provider: %s, event name: %s\n",
  66                                 desc->provider_name, desc->event_desc[i]->event_name);
  67                         return 0;
  68                 }
  69         }
  70         return 1;
  71 }
  72
  73 /*
  74  * Called under sessions lock.
  75  */
  76 static
  77 void lttng_lazy_probe_register(struct lttng_kernel_probe_desc *desc)
  78 {
  79         struct lttng_kernel_probe_desc *iter;
  80         struct list_head *probe_list;
  81
  82         /*
  83          * Each provider enforce that every event name begins with the
  84          * provider name. Check this in an assertion for extra
  85          * carefulness. This ensures we cannot have duplicate event
  86          * names across providers.
  87          */
  88         WARN_ON_ONCE(!check_event_provider(desc));
  89
  90         /*
  91          * The provider ensures there are no duplicate event names.
  92          * Duplicated TRACEPOINT_EVENT event names would generate a
  93          * compile-time error due to duplicated symbol names.
  94          */
  95
  96         /*
  97          * We sort the providers by struct lttng_kernel_probe_desc pointer
  98          * address.
  99          */
 100         probe_list = &_probe_list;
 101         list_for_each_entry_reverse(iter, probe_list, head) {
 102                 BUG_ON(iter == desc); /* Should never be in the list twice */
 103                 if (iter < desc) {
 104                         /* We belong to the location right after iter. */
 105                         list_add(&desc->head, &iter->head);
 106                         goto desc_added;
 107                 }
 108         }
 109         /* We should be added at the head of the list */
 110         list_add(&desc->head, probe_list);
 111 desc_added:
 112         pr_debug("LTTng: just registered probe %s containing %u events\n",
 113                 desc->provider_name, desc->nr_events);
 114 }
 115
 116 /*
 117  * Called under sessions lock.
 118  */
 119 static
 120 void fixup_lazy_probes(void)
 121 {
 122         struct lttng_kernel_probe_desc *iter, *tmp;
 123         int ret;
 124
 125         lazy_nesting++;
 126         list_for_each_entry_safe(iter, tmp,
 127                         &lazy_probe_init, lazy_init_head) {
 128                 lttng_lazy_probe_register(iter);
 129                 iter->lazy = 0;
 130                 list_del(&iter->lazy_init_head);
 131         }
 132         ret = lttng_fix_pending_events();
 133         WARN_ON_ONCE(ret);
 134         ret = lttng_fix_pending_event_notifiers();
 135         WARN_ON_ONCE(ret);
 136         lazy_nesting--;
 137 }
 138
 139 /*
 140  * Called under sessions lock.
 141  */
 142 struct list_head *lttng_get_probe_list_head(void)
 143 {
 144         if (!lazy_nesting && !list_empty(&lazy_probe_init))
 145                 fixup_lazy_probes();
 146         return &_probe_list;
 147 }
 148
 149 static
 150 const struct lttng_kernel_probe_desc *find_provider(const char *provider)
 151 {
 152         struct lttng_kernel_probe_desc *iter;
 153         struct list_head *probe_list;
 154
 155         probe_list = lttng_get_probe_list_head();
 156         list_for_each_entry(iter, probe_list, head) {
 157                 if (!strcmp(iter->provider_name, provider))
 158                         return iter;
 159         }
 160         return NULL;
 161 }
 162
 163 int lttng_probe_register(struct lttng_kernel_probe_desc *desc)
 164 {
 165         int ret = 0;
 166
 167         lttng_lock_sessions();
 168
 169         /*
 170          * Check if the provider has already been registered.
 171          */
 172         if (find_provider(desc->provider_name)) {
 173                 ret = -EEXIST;
 174                 goto end;
 175         }
 176         list_add(&desc->lazy_init_head, &lazy_probe_init);
 177         desc->lazy = 1;
 178         pr_debug("LTTng: adding probe %s containing %u events to lazy registration list\n",
 179                 desc->provider_name, desc->nr_events);
 180         /*
 181          * If there is at least one active session, we need to register
 182          * the probe immediately, since we cannot delay event
 183          * registration because they are needed ASAP.
 184          */
 185         if (lttng_session_active() || lttng_event_notifier_active())
 186                 fixup_lazy_probes();
 187 end:
 188         lttng_unlock_sessions();
 189         return ret;
 190 }
 191 EXPORT_SYMBOL_GPL(lttng_probe_register);
 192
 193 void lttng_probe_unregister(struct lttng_kernel_probe_desc *desc)
 194 {
 195         lttng_lock_sessions();
 196         if (!desc->lazy)
 197                 list_del(&desc->head);
 198         else
 199                 list_del(&desc->lazy_init_head);
 200         pr_debug("LTTng: just unregistered probe %s\n", desc->provider_name);
 201         lttng_unlock_sessions();
 202 }
 203 EXPORT_SYMBOL_GPL(lttng_probe_unregister);
 204
 205 /*
 206  * TODO: this is O(nr_probes * nb_events), could be faster.
 207  * Called with sessions lock held.
 208  */
 209 static
 210 const struct lttng_kernel_event_desc *find_event_desc(const char *name)
 211 {
 212         struct lttng_kernel_probe_desc *probe_desc;
 213         int i;
 214
 215         list_for_each_entry(probe_desc, &_probe_list, head) {
 216                 for (i = 0; i < probe_desc->nr_events; i++) {
 217                         if (!strcmp(probe_desc->event_desc[i]->event_name, name))
 218                                 return probe_desc->event_desc[i];
 219                         }
 220         }
 221         return NULL;
 222 }
 223
 224 /*
 225  * Called with sessions lock held.
 226  */
 227 const struct lttng_kernel_event_desc *lttng_event_desc_get(const char *name)
 228 {
 229         const struct lttng_kernel_event_desc *event_desc;
 230         int ret;
 231
 232         event_desc = find_event_desc(name);
 233         if (!event_desc)
 234                 return NULL;
 235         ret = try_module_get(event_desc->owner);
 236         WARN_ON_ONCE(!ret);
 237         return event_desc;
 238 }
 239 EXPORT_SYMBOL_GPL(lttng_event_desc_get);
 240
 241 /*
 242  * Called with sessions lock held.
 243  */
 244 void lttng_event_desc_put(const struct lttng_kernel_event_desc *event_desc)
 245 {
 246         module_put(event_desc->owner);
 247 }
 248 EXPORT_SYMBOL_GPL(lttng_event_desc_put);
 249
 250 static
 251 void *tp_list_start(struct seq_file *m, loff_t *pos)
 252 {
 253         struct lttng_kernel_probe_desc *probe_desc;
 254         struct list_head *probe_list;
 255         int iter = 0, i;
 256
 257         lttng_lock_sessions();
 258         probe_list = lttng_get_probe_list_head();
 259         list_for_each_entry(probe_desc, probe_list, head) {
 260                 for (i = 0; i < probe_desc->nr_events; i++) {
 261                         if (iter++ >= *pos)
 262                                 return (void *) probe_desc->event_desc[i];
 263                 }
 264         }
 265         /* End of list */
 266         return NULL;
 267 }
 268
 269 static
 270 void *tp_list_next(struct seq_file *m, void *p, loff_t *ppos)
 271 {
 272         struct lttng_kernel_probe_desc *probe_desc;
 273         struct list_head *probe_list;
 274         int iter = 0, i;
 275
 276         (*ppos)++;
 277         probe_list = lttng_get_probe_list_head();
 278         list_for_each_entry(probe_desc, probe_list, head) {
 279                 for (i = 0; i < probe_desc->nr_events; i++) {
 280                         if (iter++ >= *ppos)
 281                                 return (void *) probe_desc->event_desc[i];
 282                 }
 283         }
 284         /* End of list */
 285         return NULL;
 286 }
 287
 288 static
 289 void tp_list_stop(struct seq_file *m, void *p)
 290 {
 291         lttng_unlock_sessions();
 292 }
 293
 294 static
 295 int tp_list_show(struct seq_file *m, void *p)
 296 {
 297         const struct lttng_kernel_event_desc *probe_desc = p;
 298
 299         seq_printf(m,   "event { name = %s; };\n",
 300                    probe_desc->event_name);
 301         return 0;
 302 }
 303
 304 static
 305 const struct seq_operations lttng_tracepoint_list_seq_ops = {
 306         .start = tp_list_start,
 307         .next = tp_list_next,
 308         .stop = tp_list_stop,
 309         .show = tp_list_show,
 310 };
 311
 312 static
 313 int lttng_tracepoint_list_open(struct inode *inode, struct file *file)
 314 {
 315         return seq_open(file, &lttng_tracepoint_list_seq_ops);
 316 }
 317
 318 const struct file_operations lttng_tracepoint_list_fops = {
 319         .owner = THIS_MODULE,
 320         .open = lttng_tracepoint_list_open,
 321         .read = seq_read,
 322         .llseek = seq_lseek,
 323         .release = seq_release,
 324 };
 325
 326 int lttng_probes_init(void)
 327 {
 328         int cpu;
 329
 330         for_each_possible_cpu(cpu)
 331                 per_cpu_ptr(&lttng_dynamic_len_stack, cpu)->offset = 0;
 332         return 0;
 333 }