linux-patches/backport-tp-2.6.34-tracepoint-data.patch

   1 commit 2c2a566b64b4254c530fb0c2222b30e8a739bac9
   2 Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   3 Date:   Sat Sep 1 17:45:09 2012 -0700
   4
   5     tracing: Let tracepoints have data passed to tracepoint callbacks (backport)
   6
   7     Backport of commit 38516ab59fbc5b3bb278cf5e1fe2867c70cff32e for
   8     2.6.34.x. Keeping kABI compatibility.
   9
  10     Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  11
  12 ---
  13  include/linux/tracepoint.h |  149 ++++++++++++++++++++++++++++++++++-----------
  14  kernel/tracepoint.c        |  144 +++++++++++++++++++++++++++++++------------
  15  2 files changed, 219 insertions(+), 74 deletions(-)
  16
  17 Index: linux/include/linux/tracepoint.h
  18 ===================================================================
  19 --- linux.orig/include/linux/tracepoint.h
  20 +++ linux/include/linux/tracepoint.h
  21 @@ -20,12 +20,20 @@
  22  struct module;
  23  struct tracepoint;
  24
  25 +#define HAVE_KABI_2635_TRACEPOINT
  26 +
  27 +struct tracepoint_func {
  28 +       void *func;
  29 +       void *data;
  30 +       bool kabi_2635;
  31 +};
  32 +
  33  struct tracepoint {
  34         const char *name;               /* Tracepoint name */
  35         int state;                      /* State. */
  36         void (*regfunc)(void);
  37         void (*unregfunc)(void);
  38 -       void **funcs;
  39 +       struct tracepoint_func *funcs;
  40  } __attribute__((aligned(32)));                /*
  41                                          * Aligned on 32 bytes because it is
  42                                          * globally visible and gcc happily
  43 @@ -43,17 +51,33 @@ struct tracepoint {
  44  /*
  45   * it_func[0] is never NULL because there is at least one element in the array
  46   * when the array itself is non NULL.
  47 - */
  48 -#define __DO_TRACE(tp, proto, args)                                    \
  49 -       do {                                                            \
  50 -               void **it_func;                                         \
  51 + *
  52 + * Note, the proto and args passed in includes "__data" as the first parameter.
  53 + * The reason for this is to handle the "void" prototype. If a tracepoint
  54 + * has a "void" prototype, then it is invalid to declare a function
  55 + * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
  56 + * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
  57 +  */
  58 +#define __DO_TRACE(tp, data_proto, data_args, proto, args)             \
  59 +       do {                                                            \
  60 +               struct tracepoint_func *it_func_ptr;                    \
  61 +               void *it_func;                                          \
  62 +                                                                       \
  63 +               rcu_read_lock_sched_notrace();                          \
  64 +               it_func_ptr = rcu_dereference_sched((tp)->funcs);       \
  65 +               if (it_func_ptr) {                                      \
  66 +                       do {                                            \
  67 +                               if (it_func_ptr->kabi_2635) {           \
  68 +                                       void *__data;                   \
  69                                                                         \
  70 -               rcu_read_lock_sched_notrace();                          \
  71 -               it_func = rcu_dereference_sched((tp)->funcs);           \
  72 -               if (it_func) {                                          \
  73 -                       do {                                            \
  74 -                               ((void(*)(proto))(*it_func))(args);     \
  75 -                       } while (*(++it_func));                         \
  76 +                                       it_func = (it_func_ptr)->func;  \
  77 +                                       __data = (it_func_ptr)->data;   \
  78 +                                       ((void(*)(data_proto))(it_func))(data_args); \
  79 +                               } else {                                \
  80 +                                       it_func = (it_func_ptr)->func;  \
  81 +                                       ((void(*)(proto))(it_func))(args); \
  82 +                               }                                       \
  83 +                       } while ((++it_func_ptr)->func);                \
  84                 }                                                       \
  85                 rcu_read_unlock_sched_notrace();                        \
  86         } while (0)
  87 @@ -63,22 +87,39 @@ struct tracepoint {
  88   * not add unwanted padding between the beginning of the section and the
  89   * structure. Force alignment to the same alignment as the section start.
  90   */
  91 -#define DECLARE_TRACE(name, proto, args)                               \
  92 +#define __DECLARE_TRACE(name, proto, args, data_proto, data_args)      \
  93         extern struct tracepoint __tracepoint_##name;                   \
  94         static inline void trace_##name(proto)                          \
  95         {                                                               \
  96                 if (unlikely(__tracepoint_##name.state))                \
  97                         __DO_TRACE(&__tracepoint_##name,                \
  98 -                               TP_PROTO(proto), TP_ARGS(args));        \
  99 +                               TP_PROTO(data_proto),                   \
 100 +                               TP_ARGS(data_args),                     \
 101 +                               TP_PROTO(proto),                        \
 102 +                               TP_ARGS(args));                         \
 103         }                                                               \
 104 -       static inline int register_trace_##name(void (*probe)(proto))   \
 105 -       {                                                               \
 106 +       static inline int                                               \
 107 +       register_trace_##name(void (*probe)(proto))                     \
 108 +       {                                                               \
 109                 return tracepoint_probe_register(#name, (void *)probe); \
 110 -       }                                                               \
 111 -       static inline int unregister_trace_##name(void (*probe)(proto)) \
 112 -       {                                                               \
 113 -               return tracepoint_probe_unregister(#name, (void *)probe);\
 114 -       }
 115 +       }                                                               \
 116 +       static inline int                                               \
 117 +       unregister_trace_##name(void (*probe)(proto))                   \
 118 +       {                                                               \
 119 +               return tracepoint_probe_unregister(#name, (void *)probe); \
 120 +       }                                                               \
 121 +       static inline int                                               \
 122 +       kabi_2635_register_trace_##name(void (*probe)(data_proto), void *data) \
 123 +       {                                                               \
 124 +               return kabi_2635_tracepoint_probe_register(#name, (void *)probe,        \
 125 +                                                data);                 \
 126 +       }                                                               \
 127 +       static inline int                                               \
 128 +       kabi_2635_unregister_trace_##name(void (*probe)(data_proto), void *data) \
 129 +       {                                                               \
 130 +               return kabi_2635_tracepoint_probe_unregister(#name, (void *)probe, \
 131 +                                                  data);               \
 132 +       }
 133
 134
 135  #define DEFINE_TRACE_FN(name, reg, unreg)                              \
 136 @@ -100,19 +141,29 @@ extern void tracepoint_update_probe_rang
 137         struct tracepoint *end);
 138
 139  #else /* !CONFIG_TRACEPOINTS */
 140 -#define DECLARE_TRACE(name, proto, args)                               \
 141 -       static inline void _do_trace_##name(struct tracepoint *tp, proto) \
 142 -       { }                                                             \
 143 -       static inline void trace_##name(proto)                          \
 144 -       { }                                                             \
 145 -       static inline int register_trace_##name(void (*probe)(proto))   \
 146 -       {                                                               \
 147 -               return -ENOSYS;                                         \
 148 -       }                                                               \
 149 -       static inline int unregister_trace_##name(void (*probe)(proto)) \
 150 -       {                                                               \
 151 -               return -ENOSYS;                                         \
 152 -       }
 153 +#define __DECLARE_TRACE(name, proto, args, data_proto, data_args)      \
 154 +       static inline void trace_##name(proto)                          \
 155 +       { }                                                             \
 156 +       static inline int                                               \
 157 +       register_trace_##name(void (*probe)(proto))                     \
 158 +       {                                                               \
 159 +               return -ENOSYS;                                         \
 160 +       }                                                               \
 161 +       static inline int                                               \
 162 +       unregister_trace_##name(void (*probe)(proto))                   \
 163 +       {                                                               \
 164 +               return -ENOSYS;                                         \
 165 +       }                                                               \
 166 +       static inline int                                               \
 167 +       kabi_2635_register_trace_##name(void (*probe)(data_proto), void *data) \
 168 +       {                                                               \
 169 +               return -ENOSYS;                                         \
 170 +       }                                                               \
 171 +       static inline int                                               \
 172 +       kabi_2635_unregister_trace_##name(void (*probe)(data_proto), void *data) \
 173 +       {                                                               \
 174 +               return -ENOSYS;                                         \
 175 +       }
 176
 177  #define DEFINE_TRACE_FN(name, reg, unreg)
 178  #define DEFINE_TRACE(name)
 179 @@ -123,6 +174,28 @@ static inline void tracepoint_update_pro
 180         struct tracepoint *end)
 181  { }
 182  #endif /* CONFIG_TRACEPOINTS */
 183 +
 184 +/*
 185 + * The need for the DECLARE_TRACE_NOARGS() is to handle the prototype
 186 + * (void). "void" is a special value in a function prototype and can
 187 + * not be combined with other arguments. Since the DECLARE_TRACE()
 188 + * macro adds a data element at the beginning of the prototype,
 189 + * we need a way to differentiate "(void *data, proto)" from
 190 + * "(void *data, void)". The second prototype is invalid.
 191 + *
 192 + * DECLARE_TRACE_NOARGS() passes "void" as the tracepoint prototype
 193 + * and "void *__data" as the callback prototype.
 194 + *
 195 + * DECLARE_TRACE() passes "proto" as the tracepoint protoype and
 196 + * "void *__data, proto" as the callback prototype.
 197 + */
 198 +#define DECLARE_TRACE_NOARGS(name)                                     \
 199 +       __DECLARE_TRACE(name, void, , void *__data, __data)
 200 +#define DECLARE_TRACE(name, proto, args)                               \
 201 +       __DECLARE_TRACE(name, PARAMS(proto), PARAMS(args),              \
 202 +                       PARAMS(void *__data, proto),                    \
 203 +                       PARAMS(__data, args))
 204 +
 205  #endif /* DECLARE_TRACE */
 206
 207  /*
 208 @@ -130,15 +203,23 @@ static inline void tracepoint_update_pro
 209   * Internal API, should not be used directly.
 210   */
 211  extern int tracepoint_probe_register(const char *name, void *probe);
 212 +extern int kabi_2635_tracepoint_probe_register(const char *name, void *probe, void *data);
 213
 214  /*
 215   * Disconnect a probe from a tracepoint.
 216   * Internal API, should not be used directly.
 217   */
 218 -extern int tracepoint_probe_unregister(const char *name, void *probe);
 219 +extern int
 220 +tracepoint_probe_unregister(const char *name, void *probe);
 221 +extern int
 222 +kabi_2635_tracepoint_probe_unregister(const char *name, void *probe, void *data);
 223
 224  extern int tracepoint_probe_register_noupdate(const char *name, void *probe);
 225 +extern int kabi_2635_tracepoint_probe_register_noupdate(const char *name, void *probe,
 226 +                                             void *data);
 227  extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe);
 228 +extern int kabi_2635_tracepoint_probe_unregister_noupdate(const char *name, void *probe,
 229 +                                               void *data);
 230  extern void tracepoint_probe_update_all(void);
 231
 232  struct tracepoint_iter {
 233 Index: linux/kernel/tracepoint.c
 234 ===================================================================
 235 --- linux.orig/kernel/tracepoint.c
 236 +++ linux/kernel/tracepoint.c
 237 @@ -54,7 +54,7 @@ static struct hlist_head tracepoint_tabl
 238   */
 239  struct tracepoint_entry {
 240         struct hlist_node hlist;
 241 -       void **funcs;
 242 +       struct tracepoint_func *funcs;
 243         int refcount;   /* Number of times armed. 0 if disarmed. */
 244         char name[0];
 245  };
 246 @@ -64,12 +64,12 @@ struct tp_probes {
 247                 struct rcu_head rcu;
 248                 struct list_head list;
 249         } u;
 250 -       void *probes[0];
 251 +       struct tracepoint_func probes[0];
 252  };
 253
 254  static inline void *allocate_probes(int count)
 255  {
 256 -       struct tp_probes *p  = kmalloc(count * sizeof(void *)
 257 +       struct tp_probes *p  = kmalloc(count * sizeof(struct tracepoint_func)
 258                         + sizeof(struct tp_probes), GFP_KERNEL);
 259         return p == NULL ? NULL : p->probes;
 260  }
 261 @@ -79,7 +79,7 @@ static void rcu_free_old_probes(struct r
 262         kfree(container_of(head, struct tp_probes, u.rcu));
 263  }
 264
 265 -static inline void release_probes(void *old)
 266 +static inline void release_probes(struct tracepoint_func *old)
 267  {
 268         if (old) {
 269                 struct tp_probes *tp_probes = container_of(old,
 270 @@ -95,15 +95,16 @@ static void debug_print_probes(struct tr
 271         if (!tracepoint_debug || !entry->funcs)
 272                 return;
 273
 274 -       for (i = 0; entry->funcs[i]; i++)
 275 -               printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i]);
 276 +       for (i = 0; entry->funcs[i].func; i++)
 277 +               printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i].func);
 278  }
 279
 280 -static void *
 281 -tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
 282 +static struct tracepoint_func *
 283 +tracepoint_entry_add_probe(struct tracepoint_entry *entry,
 284 +                          void *probe, void *data, bool kabi_2635)
 285  {
 286         int nr_probes = 0;
 287 -       void **old, **new;
 288 +       struct tracepoint_func *old, *new;
 289
 290         WARN_ON(!probe);
 291
 292 @@ -111,8 +112,9 @@ tracepoint_entry_add_probe(struct tracep
 293         old = entry->funcs;
 294         if (old) {
 295                 /* (N -> N+1), (N != 0, 1) probes */
 296 -               for (nr_probes = 0; old[nr_probes]; nr_probes++)
 297 -                       if (old[nr_probes] == probe)
 298 +               for (nr_probes = 0; old[nr_probes].func; nr_probes++)
 299 +                       if (old[nr_probes].func == probe &&
 300 +                           old[nr_probes].data == data)
 301                                 return ERR_PTR(-EEXIST);
 302         }
 303         /* + 2 : one for new probe, one for NULL func */
 304 @@ -120,9 +122,11 @@ tracepoint_entry_add_probe(struct tracep
 305         if (new == NULL)
 306                 return ERR_PTR(-ENOMEM);
 307         if (old)
 308 -               memcpy(new, old, nr_probes * sizeof(void *));
 309 -       new[nr_probes] = probe;
 310 -       new[nr_probes + 1] = NULL;
 311 +               memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
 312 +       new[nr_probes].func = probe;
 313 +       new[nr_probes].data = data;
 314 +       new[nr_probes].kabi_2635 = kabi_2635;
 315 +       new[nr_probes + 1].func = NULL;
 316         entry->refcount = nr_probes + 1;
 317         entry->funcs = new;
 318         debug_print_probes(entry);
 319 @@ -130,10 +134,11 @@ tracepoint_entry_add_probe(struct tracep
 320  }
 321
 322  static void *
 323 -tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
 324 +tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 325 +                             void *probe, void *data)
 326  {
 327         int nr_probes = 0, nr_del = 0, i;
 328 -       void **old, **new;
 329 +       struct tracepoint_func *old, *new;
 330
 331         old = entry->funcs;
 332
 333 @@ -142,8 +147,10 @@ tracepoint_entry_remove_probe(struct tra
 334
 335         debug_print_probes(entry);
 336         /* (N -> M), (N > 1, M >= 0) probes */
 337 -       for (nr_probes = 0; old[nr_probes]; nr_probes++) {
 338 -               if ((!probe || old[nr_probes] == probe))
 339 +       for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
 340 +               if (!probe ||
 341 +                   (old[nr_probes].func == probe &&
 342 +                    old[nr_probes].data == data))
 343                         nr_del++;
 344         }
 345
 346 @@ -160,10 +167,11 @@ tracepoint_entry_remove_probe(struct tra
 347                 new = allocate_probes(nr_probes - nr_del + 1);
 348                 if (new == NULL)
 349                         return ERR_PTR(-ENOMEM);
 350 -               for (i = 0; old[i]; i++)
 351 -                       if ((probe && old[i] != probe))
 352 +               for (i = 0; old[i].func; i++)
 353 +                       if (probe &&
 354 +                           (old[i].func != probe || old[i].data != data))
 355                                 new[j++] = old[i];
 356 -               new[nr_probes - nr_del] = NULL;
 357 +               new[nr_probes - nr_del].func = NULL;
 358                 entry->refcount = nr_probes - nr_del;
 359                 entry->funcs = new;
 360         }
 361 @@ -315,18 +323,19 @@ static void tracepoint_update_probes(voi
 362         module_update_tracepoints();
 363  }
 364
 365 -static void *tracepoint_add_probe(const char *name, void *probe)
 366 +static struct tracepoint_func *
 367 +tracepoint_add_probe(const char *name, void *probe, void *data, bool kabi_2635)
 368  {
 369         struct tracepoint_entry *entry;
 370 -       void *old;
 371 +       struct tracepoint_func *old;
 372
 373         entry = get_tracepoint(name);
 374         if (!entry) {
 375                 entry = add_tracepoint(name);
 376                 if (IS_ERR(entry))
 377 -                       return entry;
 378 +                       return (struct tracepoint_func *)entry;
 379         }
 380 -       old = tracepoint_entry_add_probe(entry, probe);
 381 +       old = tracepoint_entry_add_probe(entry, probe, data, kabi_2635);
 382         if (IS_ERR(old) && !entry->refcount)
 383                 remove_tracepoint(entry);
 384         return old;
 385 @@ -340,12 +349,14 @@ static void *tracepoint_add_probe(const
 386   * Returns 0 if ok, error value on error.
 387   * The probe address must at least be aligned on the architecture pointer size.
 388   */
 389 -int tracepoint_probe_register(const char *name, void *probe)
 390 +static
 391 +int ___tracepoint_probe_register(const char *name, void *probe, void *data,
 392 +                       bool kabi_2635)
 393  {
 394 -       void *old;
 395 +       struct tracepoint_func *old;
 396
 397         mutex_lock(&tracepoints_mutex);
 398 -       old = tracepoint_add_probe(name, probe);
 399 +       old = tracepoint_add_probe(name, probe, data, kabi_2635);
 400         mutex_unlock(&tracepoints_mutex);
 401         if (IS_ERR(old))
 402                 return PTR_ERR(old);
 403 @@ -354,17 +365,30 @@ int tracepoint_probe_register(const char
 404         release_probes(old);
 405         return 0;
 406  }
 407 +
 408 +int kabi_2635_tracepoint_probe_register(const char *name, void *probe, void *data)
 409 +{
 410 +       return ___tracepoint_probe_register(name, probe, data, 1);
 411 +}
 412 +EXPORT_SYMBOL_GPL(kabi_2635_tracepoint_probe_register);
 413 +
 414 +
 415 +int tracepoint_probe_register(const char *name, void *probe)
 416 +{
 417 +       return ___tracepoint_probe_register(name, probe, NULL, 0);
 418 +}
 419  EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 420
 421 -static void *tracepoint_remove_probe(const char *name, void *probe)
 422 +static struct tracepoint_func *
 423 +tracepoint_remove_probe(const char *name, void *probe, void *data)
 424  {
 425         struct tracepoint_entry *entry;
 426 -       void *old;
 427 +       struct tracepoint_func *old;
 428
 429         entry = get_tracepoint(name);
 430         if (!entry)
 431                 return ERR_PTR(-ENOENT);
 432 -       old = tracepoint_entry_remove_probe(entry, probe);
 433 +       old = tracepoint_entry_remove_probe(entry, probe, data);
 434         if (IS_ERR(old))
 435                 return old;
 436         if (!entry->refcount)
 437 @@ -382,12 +406,13 @@ static void *tracepoint_remove_probe(con
 438   * itself uses stop_machine(), which insures that every preempt disabled section
 439   * have finished.
 440   */
 441 -int tracepoint_probe_unregister(const char *name, void *probe)
 442 +static
 443 +int ___tracepoint_probe_unregister(const char *name, void *probe, void *data)
 444  {
 445 -       void *old;
 446 +       struct tracepoint_func *old;
 447
 448         mutex_lock(&tracepoints_mutex);
 449 -       old = tracepoint_remove_probe(name, probe);
 450 +       old = tracepoint_remove_probe(name, probe, data);
 451         mutex_unlock(&tracepoints_mutex);
 452         if (IS_ERR(old))
 453                 return PTR_ERR(old);
 454 @@ -396,6 +421,17 @@ int tracepoint_probe_unregister(const ch
 455         release_probes(old);
 456         return 0;
 457  }
 458 +
 459 +int kabi_2635_tracepoint_probe_unregister(const char *name, void *probe, void *data)
 460 +{
 461 +       return ___tracepoint_probe_unregister(name, probe, data);
 462 +}
 463 +EXPORT_SYMBOL_GPL(kabi_2635_tracepoint_probe_unregister);
 464 +
 465 +int tracepoint_probe_unregister(const char *name, void *probe)
 466 +{
 467 +       return ___tracepoint_probe_unregister(name, probe, NULL);
 468 +}
 469  EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
 470
 471  static LIST_HEAD(old_probes);
 472 @@ -418,12 +454,14 @@ static void tracepoint_add_old_probes(vo
 473   *
 474   * caller must call tracepoint_probe_update_all()
 475   */
 476 -int tracepoint_probe_register_noupdate(const char *name, void *probe)
 477 +static
 478 +int ___tracepoint_probe_register_noupdate(const char *name, void *probe,
 479 +                                      void *data, bool kabi_2635)
 480  {
 481 -       void *old;
 482 +       struct tracepoint_func *old;
 483
 484         mutex_lock(&tracepoints_mutex);
 485 -       old = tracepoint_add_probe(name, probe);
 486 +       old = tracepoint_add_probe(name, probe, data, kabi_2635);
 487         if (IS_ERR(old)) {
 488                 mutex_unlock(&tracepoints_mutex);
 489                 return PTR_ERR(old);
 490 @@ -432,6 +470,18 @@ int tracepoint_probe_register_noupdate(c
 491         mutex_unlock(&tracepoints_mutex);
 492         return 0;
 493  }
 494 +
 495 +int kabi_2635_tracepoint_probe_register_noupdate(const char *name, void *probe,
 496 +                                      void *data)
 497 +{
 498 +       return ___tracepoint_probe_register_noupdate(name, probe, data, 1);
 499 +}
 500 +EXPORT_SYMBOL_GPL(kabi_2635_tracepoint_probe_register_noupdate);
 501 +
 502 +int tracepoint_probe_register_noupdate(const char *name, void *probe)
 503 +{
 504 +       return ___tracepoint_probe_register_noupdate(name, probe, NULL, 0);
 505 +}
 506  EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
 507
 508  /**
 509 @@ -441,12 +491,14 @@ EXPORT_SYMBOL_GPL(tracepoint_probe_regis
 510   *
 511   * caller must call tracepoint_probe_update_all()
 512   */
 513 -int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
 514 +static
 515 +int ___tracepoint_probe_unregister_noupdate(const char *name, void *probe,
 516 +                                        void *data)
 517  {
 518 -       void *old;
 519 +       struct tracepoint_func *old;
 520
 521         mutex_lock(&tracepoints_mutex);
 522 -       old = tracepoint_remove_probe(name, probe);
 523 +       old = tracepoint_remove_probe(name, probe, data);
 524         if (IS_ERR(old)) {
 525                 mutex_unlock(&tracepoints_mutex);
 526                 return PTR_ERR(old);
 527 @@ -455,6 +507,18 @@ int tracepoint_probe_unregister_noupdate
 528         mutex_unlock(&tracepoints_mutex);
 529         return 0;
 530  }
 531 +
 532 +int kabi_2635_tracepoint_probe_unregister_noupdate(const char *name, void *probe,
 533 +                                        void *data)
 534 +{
 535 +       return ___tracepoint_probe_unregister_noupdate(name, probe, data);
 536 +}
 537 +EXPORT_SYMBOL_GPL(kabi_2635_tracepoint_probe_unregister_noupdate);
 538 +
 539 +int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
 540 +{
 541 +       return ___tracepoint_probe_unregister_noupdate(name, probe, NULL);
 542 +}
 543  EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
 544
 545  /**