libust/tracepoint.c

   1 /*
   2  * Copyright (C) 2008 Mathieu Desnoyers
   3  * Copyright (C) 2009 Pierre-Marc Fournier
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  18  *
  19  * Ported to userspace by Pierre-Marc Fournier.
  20  */
  21
  22 #include <errno.h>
  23 #include <ust/tracepoint.h>
  24 #include <ust/core.h>
  25 #include <ust/kcompat/kcompat.h>
  26 #include "usterr_signal_safe.h"
  27
  28 #define _LGPL_SOURCE
  29 #include <urcu-bp.h>
  30 #include <urcu/hlist.h>
  31
  32 //extern struct tracepoint __start___tracepoints[] __attribute__((visibility("hidden")));
  33 //extern struct tracepoint __stop___tracepoints[] __attribute__((visibility("hidden")));
  34
  35 /* Set to 1 to enable tracepoint debug output */
  36 static const int tracepoint_debug;
  37
  38 /* libraries that contain tracepoints (struct tracepoint_lib) */
  39 static CDS_LIST_HEAD(libs);
  40
  41 /*
  42  * tracepoints_mutex nests inside module_mutex. Tracepoints mutex protects the
  43  * builtin and module tracepoints and the hash table.
  44  */
  45 static DEFINE_MUTEX(tracepoints_mutex);
  46
  47 /*
  48  * Tracepoint hash table, containing the active tracepoints.
  49  * Protected by tracepoints_mutex.
  50  */
  51 #define TRACEPOINT_HASH_BITS 6
  52 #define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
  53 static struct cds_hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
  54
  55 /*
  56  * Note about RCU :
  57  * It is used to to delay the free of multiple probes array until a quiescent
  58  * state is reached.
  59  * Tracepoint entries modifications are protected by the tracepoints_mutex.
  60  */
  61 struct tracepoint_entry {
  62         struct cds_hlist_node hlist;
  63         struct probe *probes;
  64         int refcount;   /* Number of times armed. 0 if disarmed. */
  65         char name[0];
  66 };
  67
  68 struct tp_probes {
  69         union {
  70 //ust//         struct rcu_head rcu;
  71                 struct cds_list_head list;
  72         } u;
  73         struct probe probes[0];
  74 };
  75
  76 static inline void *allocate_probes(int count)
  77 {
  78         struct tp_probes *p  = zmalloc(count * sizeof(struct probe)
  79                         + sizeof(struct tp_probes));
  80         return p == NULL ? NULL : p->probes;
  81 }
  82
  83 //ust// static void rcu_free_old_probes(struct rcu_head *head)
  84 //ust// {
  85 //ust//         kfree(container_of(head, struct tp_probes, u.rcu));
  86 //ust// }
  87
  88 static inline void release_probes(void *old)
  89 {
  90         if (old) {
  91                 struct tp_probes *tp_probes = _ust_container_of(old,
  92                         struct tp_probes, probes[0]);
  93 //ust//         call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
  94                 synchronize_rcu();
  95                 free(tp_probes);
  96         }
  97 }
  98
  99 static void debug_print_probes(struct tracepoint_entry *entry)
 100 {
 101         int i;
 102
 103         if (!tracepoint_debug || !entry->probes)
 104                 return;
 105
 106         for (i = 0; entry->probes[i].func; i++)
 107                 DBG("Probe %d : %p", i, entry->probes[i].func);
 108 }
 109
 110 static void *
 111 tracepoint_entry_add_probe(struct tracepoint_entry *entry,
 112                            void *probe, void *data)
 113 {
 114         int nr_probes = 0;
 115         struct probe *old, *new;
 116
 117         WARN_ON(!probe);
 118
 119         debug_print_probes(entry);
 120         old = entry->probes;
 121         if (old) {
 122                 /* (N -> N+1), (N != 0, 1) probes */
 123                 for (nr_probes = 0; old[nr_probes].func; nr_probes++)
 124                         if (old[nr_probes].func == probe &&
 125                             old[nr_probes].data == data)
 126                                 return ERR_PTR(-EEXIST);
 127         }
 128         /* + 2 : one for new probe, one for NULL func */
 129         new = allocate_probes(nr_probes + 2);
 130         if (new == NULL)
 131                 return ERR_PTR(-ENOMEM);
 132         if (old)
 133                 memcpy(new, old, nr_probes * sizeof(struct probe));
 134         new[nr_probes].func = probe;
 135         new[nr_probes].data = data;
 136         new[nr_probes + 1].func = NULL;
 137         entry->refcount = nr_probes + 1;
 138         entry->probes = new;
 139         debug_print_probes(entry);
 140         return old;
 141 }
 142
 143 static void *
 144 tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe,
 145                               void *data)
 146 {
 147         int nr_probes = 0, nr_del = 0, i;
 148         struct probe *old, *new;
 149
 150         old = entry->probes;
 151
 152         if (!old)
 153                 return ERR_PTR(-ENOENT);
 154
 155         debug_print_probes(entry);
 156         /* (N -> M), (N > 1, M >= 0) probes */
 157         for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
 158                 if (!probe ||
 159                      (old[nr_probes].func == probe &&
 160                      old[nr_probes].data == data))
 161                         nr_del++;
 162         }
 163
 164         if (nr_probes - nr_del == 0) {
 165                 /* N -> 0, (N > 1) */
 166                 entry->probes = NULL;
 167                 entry->refcount = 0;
 168                 debug_print_probes(entry);
 169                 return old;
 170         } else {
 171                 int j = 0;
 172                 /* N -> M, (N > 1, M > 0) */
 173                 /* + 1 for NULL */
 174                 new = allocate_probes(nr_probes - nr_del + 1);
 175                 if (new == NULL)
 176                         return ERR_PTR(-ENOMEM);
 177                 for (i = 0; old[i].func; i++)
 178                         if (probe &&
 179                             (old[i].func != probe || old[i].data != data))
 180                                 new[j++] = old[i];
 181                 new[nr_probes - nr_del].func = NULL;
 182                 entry->refcount = nr_probes - nr_del;
 183                 entry->probes = new;
 184         }
 185         debug_print_probes(entry);
 186         return old;
 187 }
 188
 189 /*
 190  * Get tracepoint if the tracepoint is present in the tracepoint hash table.
 191  * Must be called with tracepoints_mutex held.
 192  * Returns NULL if not present.
 193  */
 194 static struct tracepoint_entry *get_tracepoint(const char *name)
 195 {
 196         struct cds_hlist_head *head;
 197         struct cds_hlist_node *node;
 198         struct tracepoint_entry *e;
 199         u32 hash = jhash(name, strlen(name), 0);
 200
 201         head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
 202         cds_hlist_for_each_entry(e, node, head, hlist) {
 203                 if (!strcmp(name, e->name))
 204                         return e;
 205         }
 206         return NULL;
 207 }
 208
 209 /*
 210  * Add the tracepoint to the tracepoint hash table. Must be called with
 211  * tracepoints_mutex held.
 212  */
 213 static struct tracepoint_entry *add_tracepoint(const char *name)
 214 {
 215         struct cds_hlist_head *head;
 216         struct cds_hlist_node *node;
 217         struct tracepoint_entry *e;
 218         size_t name_len = strlen(name) + 1;
 219         u32 hash = jhash(name, name_len-1, 0);
 220
 221         head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
 222         cds_hlist_for_each_entry(e, node, head, hlist) {
 223                 if (!strcmp(name, e->name)) {
 224                         DBG("tracepoint %s busy", name);
 225                         return ERR_PTR(-EEXIST);        /* Already there */
 226                 }
 227         }
 228         /*
 229          * Using zmalloc here to allocate a variable length element. Could
 230          * cause some memory fragmentation if overused.
 231          */
 232         e = zmalloc(sizeof(struct tracepoint_entry) + name_len);
 233         if (!e)
 234                 return ERR_PTR(-ENOMEM);
 235         memcpy(&e->name[0], name, name_len);
 236         e->probes = NULL;
 237         e->refcount = 0;
 238         cds_hlist_add_head(&e->hlist, head);
 239         return e;
 240 }
 241
 242 /*
 243  * Remove the tracepoint from the tracepoint hash table. Must be called with
 244  * mutex_lock held.
 245  */
 246 static inline void remove_tracepoint(struct tracepoint_entry *e)
 247 {
 248         cds_hlist_del(&e->hlist);
 249         free(e);
 250 }
 251
 252 /*
 253  * Sets the probe callback corresponding to one tracepoint.
 254  */
 255 static void set_tracepoint(struct tracepoint_entry **entry,
 256         struct tracepoint *elem, int active)
 257 {
 258         WARN_ON(strcmp((*entry)->name, elem->name) != 0);
 259
 260         /*
 261          * rcu_assign_pointer has a cmm_smp_wmb() which makes sure that the new
 262          * probe callbacks array is consistent before setting a pointer to it.
 263          * This array is referenced by __DO_TRACE from
 264          * include/linux/tracepoints.h. A matching cmm_smp_read_barrier_depends()
 265          * is used.
 266          */
 267         rcu_assign_pointer(elem->probes, (*entry)->probes);
 268         elem->state = active;
 269 }
 270
 271 /*
 272  * Disable a tracepoint and its probe callback.
 273  * Note: only waiting an RCU period after setting elem->call to the empty
 274  * function insures that the original callback is not used anymore. This insured
 275  * by preempt_disable around the call site.
 276  */
 277 static void disable_tracepoint(struct tracepoint *elem)
 278 {
 279         elem->state = 0;
 280         rcu_assign_pointer(elem->probes, NULL);
 281 }
 282
 283 /**
 284  * tracepoint_update_probe_range - Update a probe range
 285  * @begin: beginning of the range
 286  * @end: end of the range
 287  *
 288  * Updates the probe callback corresponding to a range of tracepoints.
 289  */
 290 void tracepoint_update_probe_range(struct tracepoint * const *begin,
 291                                    struct tracepoint * const *end)
 292 {
 293         struct tracepoint * const *iter;
 294         struct tracepoint_entry *mark_entry;
 295
 296         pthread_mutex_lock(&tracepoints_mutex);
 297         for (iter = begin; iter < end; iter++) {
 298                 if (!*iter)
 299                         continue;       /* skip dummy */
 300                 if (!(*iter)->name) {
 301                         disable_tracepoint(*iter);
 302                         continue;
 303                 }
 304                 mark_entry = get_tracepoint((*iter)->name);
 305                 if (mark_entry) {
 306                         set_tracepoint(&mark_entry, *iter,
 307                                         !!mark_entry->refcount);
 308                 } else {
 309                         disable_tracepoint(*iter);
 310                 }
 311         }
 312         pthread_mutex_unlock(&tracepoints_mutex);
 313 }
 314
 315 static void lib_update_tracepoints(void)
 316 {
 317         struct tracepoint_lib *lib;
 318
 319 //ust// pthread_mutex_lock(&module_mutex);
 320         cds_list_for_each_entry(lib, &libs, list)
 321                 tracepoint_update_probe_range(lib->tracepoints_start,
 322                                 lib->tracepoints_start + lib->tracepoints_count);
 323 //ust// pthread_mutex_unlock(&module_mutex);
 324 }
 325
 326 /*
 327  * Update probes, removing the faulty probes.
 328  */
 329 static void tracepoint_update_probes(void)
 330 {
 331         /* Core kernel tracepoints */
 332 //ust// tracepoint_update_probe_range(__start___tracepoints,
 333 //ust//         __stop___tracepoints);
 334         /* tracepoints in modules. */
 335         lib_update_tracepoints();
 336 }
 337
 338 static struct probe *
 339 tracepoint_add_probe(const char *name, void *probe, void *data)
 340 {
 341         struct tracepoint_entry *entry;
 342         struct probe *old;
 343
 344         entry = get_tracepoint(name);
 345         if (!entry) {
 346                 entry = add_tracepoint(name);
 347                 if (IS_ERR(entry))
 348                         return (struct probe *)entry;
 349         }
 350         old = tracepoint_entry_add_probe(entry, probe, data);
 351         if (IS_ERR(old) && !entry->refcount)
 352                 remove_tracepoint(entry);
 353         return old;
 354 }
 355
 356 /**
 357  * tracepoint_probe_register -  Connect a probe to a tracepoint
 358  * @name: tracepoint name
 359  * @probe: probe handler
 360  *
 361  * Returns 0 if ok, error value on error.
 362  * The probe address must at least be aligned on the architecture pointer size.
 363  */
 364 int tracepoint_probe_register(const char *name, void *probe, void *data)
 365 {
 366         void *old;
 367
 368         pthread_mutex_lock(&tracepoints_mutex);
 369         old = tracepoint_add_probe(name, probe, data);
 370         pthread_mutex_unlock(&tracepoints_mutex);
 371         if (IS_ERR(old))
 372                 return PTR_ERR(old);
 373
 374         tracepoint_update_probes();             /* may update entry */
 375         release_probes(old);
 376         return 0;
 377 }
 378 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 379
 380 static void *tracepoint_remove_probe(const char *name, void *probe, void *data)
 381 {
 382         struct tracepoint_entry *entry;
 383         void *old;
 384
 385         entry = get_tracepoint(name);
 386         if (!entry)
 387                 return ERR_PTR(-ENOENT);
 388         old = tracepoint_entry_remove_probe(entry, probe, data);
 389         if (IS_ERR(old))
 390                 return old;
 391         if (!entry->refcount)
 392                 remove_tracepoint(entry);
 393         return old;
 394 }
 395
 396 /**
 397  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
 398  * @name: tracepoint name
 399  * @probe: probe function pointer
 400  * @probe: probe data pointer
 401  *
 402  * We do not need to call a synchronize_sched to make sure the probes have
 403  * finished running before doing a module unload, because the module unload
 404  * itself uses stop_machine(), which insures that every preempt disabled section
 405  * have finished.
 406  */
 407 int tracepoint_probe_unregister(const char *name, void *probe, void *data)
 408 {
 409         void *old;
 410
 411         pthread_mutex_lock(&tracepoints_mutex);
 412         old = tracepoint_remove_probe(name, probe, data);
 413         pthread_mutex_unlock(&tracepoints_mutex);
 414         if (IS_ERR(old))
 415                 return PTR_ERR(old);
 416
 417         tracepoint_update_probes();             /* may update entry */
 418         release_probes(old);
 419         return 0;
 420 }
 421 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
 422
 423 static CDS_LIST_HEAD(old_probes);
 424 static int need_update;
 425
 426 static void tracepoint_add_old_probes(void *old)
 427 {
 428         need_update = 1;
 429         if (old) {
 430                 struct tp_probes *tp_probes = _ust_container_of(old,
 431                         struct tp_probes, probes[0]);
 432                 cds_list_add(&tp_probes->u.list, &old_probes);
 433         }
 434 }
 435
 436 /**
 437  * tracepoint_probe_register_noupdate -  register a probe but not connect
 438  * @name: tracepoint name
 439  * @probe: probe handler
 440  *
 441  * caller must call tracepoint_probe_update_all()
 442  */
 443 int tracepoint_probe_register_noupdate(const char *name, void *probe,
 444                                        void *data)
 445 {
 446         void *old;
 447
 448         pthread_mutex_lock(&tracepoints_mutex);
 449         old = tracepoint_add_probe(name, probe, data);
 450         if (IS_ERR(old)) {
 451                 pthread_mutex_unlock(&tracepoints_mutex);
 452                 return PTR_ERR(old);
 453         }
 454         tracepoint_add_old_probes(old);
 455         pthread_mutex_unlock(&tracepoints_mutex);
 456         return 0;
 457 }
 458 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
 459
 460 /**
 461  * tracepoint_probe_unregister_noupdate -  remove a probe but not disconnect
 462  * @name: tracepoint name
 463  * @probe: probe function pointer
 464  *
 465  * caller must call tracepoint_probe_update_all()
 466  */
 467 int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
 468                                          void *data)
 469 {
 470         void *old;
 471
 472         pthread_mutex_lock(&tracepoints_mutex);
 473         old = tracepoint_remove_probe(name, probe, data);
 474         if (IS_ERR(old)) {
 475                 pthread_mutex_unlock(&tracepoints_mutex);
 476                 return PTR_ERR(old);
 477         }
 478         tracepoint_add_old_probes(old);
 479         pthread_mutex_unlock(&tracepoints_mutex);
 480         return 0;
 481 }
 482 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
 483
 484 /**
 485  * tracepoint_probe_update_all -  update tracepoints
 486  */
 487 void tracepoint_probe_update_all(void)
 488 {
 489         CDS_LIST_HEAD(release_probes);
 490         struct tp_probes *pos, *next;
 491
 492         pthread_mutex_lock(&tracepoints_mutex);
 493         if (!need_update) {
 494                 pthread_mutex_unlock(&tracepoints_mutex);
 495                 return;
 496         }
 497         if (!cds_list_empty(&old_probes))
 498                 cds_list_replace_init(&old_probes, &release_probes);
 499         need_update = 0;
 500         pthread_mutex_unlock(&tracepoints_mutex);
 501
 502         tracepoint_update_probes();
 503         cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) {
 504                 cds_list_del(&pos->u.list);
 505 //ust//         call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
 506                 synchronize_rcu();
 507                 free(pos);
 508         }
 509 }
 510 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
 511
 512 /*
 513  * Returns 0 if current not found.
 514  * Returns 1 if current found.
 515  */
 516 int lib_get_iter_tracepoints(struct tracepoint_iter *iter)
 517 {
 518         struct tracepoint_lib *iter_lib;
 519         int found = 0;
 520
 521 //ust// pthread_mutex_lock(&module_mutex);
 522         cds_list_for_each_entry(iter_lib, &libs, list) {
 523                 if (iter_lib < iter->lib)
 524                         continue;
 525                 else if (iter_lib > iter->lib)
 526                         iter->tracepoint = NULL;
 527                 found = tracepoint_get_iter_range(&iter->tracepoint,
 528                         iter_lib->tracepoints_start,
 529                         iter_lib->tracepoints_start + iter_lib->tracepoints_count);
 530                 if (found) {
 531                         iter->lib = iter_lib;
 532                         break;
 533                 }
 534         }
 535 //ust// pthread_mutex_unlock(&module_mutex);
 536         return found;
 537 }
 538
 539 /**
 540  * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
 541  * @tracepoint: current tracepoints (in), next tracepoint (out)
 542  * @begin: beginning of the range
 543  * @end: end of the range
 544  *
 545  * Returns whether a next tracepoint has been found (1) or not (0).
 546  * Will return the first tracepoint in the range if the input tracepoint is
 547  * NULL.
 548  */
 549 int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
 550         struct tracepoint * const *begin, struct tracepoint * const *end)
 551 {
 552         if (!*tracepoint && begin != end)
 553                 *tracepoint = begin;
 554         while (*tracepoint >= begin && *tracepoint < end) {
 555                 if (!**tracepoint)
 556                         (*tracepoint)++;        /* skip dummy */
 557                 else
 558                         return 1;
 559         }
 560         return 0;
 561 }
 562 //ust// EXPORT_SYMBOL_GPL(tracepoint_get_iter_range);
 563
 564 static void tracepoint_get_iter(struct tracepoint_iter *iter)
 565 {
 566         int found = 0;
 567
 568 //ust// /* Core kernel tracepoints */
 569 //ust// if (!iter->module) {
 570 //ust//         found = tracepoint_get_iter_range(&iter->tracepoint,
 571 //ust//                         __start___tracepoints, __stop___tracepoints);
 572 //ust//         if (found)
 573 //ust//                 goto end;
 574 //ust// }
 575         /* tracepoints in libs. */
 576         found = lib_get_iter_tracepoints(iter);
 577 //ust// end:
 578         if (!found)
 579                 tracepoint_iter_reset(iter);
 580 }
 581
 582 void tracepoint_iter_start(struct tracepoint_iter *iter)
 583 {
 584         tracepoint_get_iter(iter);
 585 }
 586 //ust// EXPORT_SYMBOL_GPL(tracepoint_iter_start);
 587
 588 void tracepoint_iter_next(struct tracepoint_iter *iter)
 589 {
 590         iter->tracepoint++;
 591         /*
 592          * iter->tracepoint may be invalid because we blindly incremented it.
 593          * Make sure it is valid by marshalling on the tracepoints, getting the
 594          * tracepoints from following modules if necessary.
 595          */
 596         tracepoint_get_iter(iter);
 597 }
 598 //ust// EXPORT_SYMBOL_GPL(tracepoint_iter_next);
 599
 600 void tracepoint_iter_stop(struct tracepoint_iter *iter)
 601 {
 602 }
 603 //ust// EXPORT_SYMBOL_GPL(tracepoint_iter_stop);
 604
 605 void tracepoint_iter_reset(struct tracepoint_iter *iter)
 606 {
 607 //ust// iter->module = NULL;
 608         iter->tracepoint = NULL;
 609 }
 610 //ust// EXPORT_SYMBOL_GPL(tracepoint_iter_reset);
 611
 612 //ust// #ifdef CONFIG_MODULES
 613
 614 //ust// int tracepoint_module_notify(struct notifier_block *self,
 615 //ust//                              unsigned long val, void *data)
 616 //ust// {
 617 //ust//         struct module *mod = data;
 618 //ust//
 619 //ust//         switch (val) {
 620 //ust//         case MODULE_STATE_COMING:
 621 //ust//                 tracepoint_update_probe_range(mod->tracepoints,
 622 //ust//                         mod->tracepoints + mod->num_tracepoints);
 623 //ust//                 break;
 624 //ust//         case MODULE_STATE_GOING:
 625 //ust//                 tracepoint_update_probe_range(mod->tracepoints,
 626 //ust//                         mod->tracepoints + mod->num_tracepoints);
 627 //ust//                 break;
 628 //ust//         }
 629 //ust//         return 0;
 630 //ust// }
 631
 632 //ust// struct notifier_block tracepoint_module_nb = {
 633 //ust//         .notifier_call = tracepoint_module_notify,
 634 //ust//         .priority = 0,
 635 //ust// };
 636
 637 //ust// static int init_tracepoints(void)
 638 //ust// {
 639 //ust//         return register_module_notifier(&tracepoint_module_nb);
 640 //ust// }
 641 //ust// __initcall(init_tracepoints);
 642
 643 //ust// #endif /* CONFIG_MODULES */
 644
 645 static void (*new_tracepoint_cb)(struct tracepoint *) = NULL;
 646
 647 void tracepoint_set_new_tracepoint_cb(void (*cb)(struct tracepoint *))
 648 {
 649         new_tracepoint_cb = cb;
 650 }
 651
 652 static void new_tracepoints(struct tracepoint * const *start, struct tracepoint * const *end)
 653 {
 654         if (new_tracepoint_cb) {
 655                 struct tracepoint * const *t;
 656
 657                 for(t = start; t < end; t++) {
 658                         if (*t)
 659                                 new_tracepoint_cb(*t);
 660                 }
 661         }
 662 }
 663
 664 int tracepoint_register_lib(struct tracepoint * const *tracepoints_start, int tracepoints_count)
 665 {
 666         struct tracepoint_lib *pl, *iter;
 667
 668         pl = (struct tracepoint_lib *) zmalloc(sizeof(struct tracepoint_lib));
 669
 670         pl->tracepoints_start = tracepoints_start;
 671         pl->tracepoints_count = tracepoints_count;
 672
 673         /* FIXME: maybe protect this with its own mutex? */
 674         pthread_mutex_lock(&tracepoints_mutex);
 675         /*
 676          * We sort the libs by struct lib pointer address.
 677          */
 678         cds_list_for_each_entry_reverse(iter, &libs, list) {
 679                 BUG_ON(iter == pl);    /* Should never be in the list twice */
 680                 if (iter < pl) {
 681                         /* We belong to the location right after iter. */
 682                         cds_list_add(&pl->list, &iter->list);
 683                         goto lib_added;
 684                 }
 685         }
 686         /* We should be added at the head of the list */
 687         cds_list_add(&pl->list, &libs);
 688 lib_added:
 689         pthread_mutex_unlock(&tracepoints_mutex);
 690
 691         new_tracepoints(tracepoints_start, tracepoints_start + tracepoints_count);
 692
 693         /* FIXME: update just the loaded lib */
 694         lib_update_tracepoints();
 695
 696         /* tracepoints_count - 1: skip dummy */
 697         DBG("just registered a tracepoints section from %p and having %d tracepoints (minus dummy tracepoints)", tracepoints_start, tracepoints_count);
 698
 699         return 0;
 700 }
 701
 702 int tracepoint_unregister_lib(struct tracepoint * const *tracepoints_start)
 703 {
 704         struct tracepoint_lib *lib;
 705
 706         pthread_mutex_lock(&tracepoints_mutex);
 707
 708         cds_list_for_each_entry(lib, &libs, list) {
 709                 if (lib->tracepoints_start == tracepoints_start) {
 710                         struct tracepoint_lib *lib2free = lib;
 711                         cds_list_del(&lib->list);
 712                         free(lib2free);
 713                         break;
 714                 }
 715         }
 716
 717         pthread_mutex_unlock(&tracepoints_mutex);
 718
 719         return 0;
 720 }