projects / deliverable / lttng-modules.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
SoW-2020-0002: Trace Hit Counters
[deliverable/lttng-modules.git] / src / lttng-events.c
CommitLineData
b7cdc182 1/* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
9f36eaed 2 *
a90917c3 3 * lttng-events.c
4e3c1b9b 4 *
4e3c1b9b 5 * Holds LTTng per-session event registry.
17baffe2 6 *
886d51a3 7 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4e3c1b9b
MD		 8 */
9
389d7070
MD		 10/*
11 * This page_alloc.h wrapper needs to be included before gfpflags.h because it
12 * overrides a function with a define.
13 */
14#include "wrapper/page_alloc.h"
15
4e3c1b9b 16#include <linux/module.h>
c0e31d2e
MD		 17#include <linux/mutex.h>
18#include <linux/sched.h>
11b5a3c2 19#include <linux/slab.h>
c099397a 20#include <linux/jiffies.h>
99dc9597 21#include <linux/utsname.h>
abc0446a 22#include <linux/err.h>
7e6f9ef6
MD		 23#include <linux/seq_file.h>
24#include <linux/file.h>
25#include <linux/anon_inodes.h>
241ae9a8 26#include <wrapper/file.h>
8c6e7f13 27#include <linux/uaccess.h>
a606b6e8 28#include <linux/vmalloc.h>
c88f762e 29#include <linux/dmi.h>
3c997079 30
a7008254 31#include <wrapper/uuid.h>
263b6c88 32#include <wrapper/vmalloc.h> /* for wrapper_vmalloc_sync_mappings() */
241ae9a8
MD		 33#include <wrapper/random.h>
34#include <wrapper/tracepoint.h>
35#include <wrapper/list.h>
cbc19040 36#include <wrapper/types.h>
0c023c01 37#include <wrapper/barrier.h>
2df37e95
MD		 38#include <lttng/kernel-version.h>
39#include <lttng/events.h>
0b365677 40#include <lttng/lttng-bytecode.h>
2df37e95 41#include <lttng/tracer.h>
21f58fb7 42#include <lttng/event-notifier-notification.h>
2df37e95
MD		 43#include <lttng/abi-old.h>
44#include <lttng/endian.h>
45#include <lttng/string-utils.h>
4a11ef1c 46#include <lttng/utils.h>
24591303
MD		 47#include <ringbuffer/backend.h>
48#include <ringbuffer/frontend.h>
0c023c01 49#include <counter/counter.h>
3636085f 50#include <wrapper/time.h>
4e3c1b9b 51
d83004aa
JD		 52#define METADATA_CACHE_DEFAULT_SIZE 4096
53
4e3c1b9b 54static LIST_HEAD(sessions);
750b05f2 55static LIST_HEAD(event_notifier_groups);
a90917c3 56static LIST_HEAD(lttng_transport_list);
a101fa10 57static LIST_HEAD(lttng_counter_transport_list);
d83004aa
JD		 58/*
59 * Protect the sessions and metadata caches.
60 */
4e3c1b9b
MD		 61static DEFINE_MUTEX(sessions_mutex);
62static struct kmem_cache *event_cache;
dffef45d 63static struct kmem_cache *event_notifier_cache;
4e3c1b9b 64
b2bc0bc8
FD		 65static void lttng_session_lazy_sync_event_enablers(struct lttng_session *session);
66static void lttng_session_sync_event_enablers(struct lttng_session *session);
67static void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler);
dffef45d 68static void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler *event_notifier_enabler);
b01155ba 69static void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group);
3c997079 70
a90917c3 71static void _lttng_event_destroy(struct lttng_event *event);
dffef45d 72static void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier);
0c023c01
MD		 73static void _lttng_channel_destroy(struct lttng_channel *channel);
74static void _lttng_session_counter_destroy(struct lttng_counter *counter);
a90917c3 75static int _lttng_event_unregister(struct lttng_event *event);
dffef45d 76static int _lttng_event_notifier_unregister(struct lttng_event_notifier *event_notifier);
c099397a 77static
a90917c3 78int _lttng_event_metadata_statedump(struct lttng_session *session,
a90917c3 79 struct lttng_event *event);
c099397a 80static
a90917c3 81int _lttng_session_metadata_statedump(struct lttng_session *session);
d83004aa
JD		 82static
83void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream);
f513b2bf 84static
ceabb767
MD		 85int _lttng_type_statedump(struct lttng_session *session,
86 const struct lttng_type *type,
87 size_t nesting);
88static
f513b2bf
MD		 89int _lttng_field_statedump(struct lttng_session *session,
90 const struct lttng_event_field *field,
91 size_t nesting);
c099397a 92
0c023c01
MD		 93static bool lttng_event_container_is_metadata_channel(struct lttng_event_container *container)
94{
95 switch (container->type) {
96 case LTTNG_EVENT_CONTAINER_CHANNEL:
97 {
98 struct lttng_channel *chan = lttng_event_container_get_channel(container);
99
100 return chan->channel_type == METADATA_CHANNEL;
101 }
102 case LTTNG_EVENT_CONTAINER_COUNTER:
103 return false;
104 default:
105 return false;
106 }
107}
108
109static bool lttng_event_within_metadata_channel(struct lttng_event *event)
110{
111 return lttng_event_container_is_metadata_channel(event->container);
112}
113
c099397a 114void synchronize_trace(void)
abcca994 115{
5f4c791e 116#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,1,0))
92da05ce
MJ		 117 synchronize_rcu();
118#else
abcca994 119 synchronize_sched();
92da05ce
MJ		 120#endif
121
5f4c791e 122#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0))
b8590f40
MD		 123#ifdef CONFIG_PREEMPT_RT_FULL
124 synchronize_rcu();
125#endif
5f4c791e 126#else /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
abcca994
MD		 127#ifdef CONFIG_PREEMPT_RT
128 synchronize_rcu();
129#endif
5f4c791e 130#endif /* (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(3,4,0)) */
abcca994
MD		 131}
132
3c997079
MD		 133void lttng_lock_sessions(void)
134{
135 mutex_lock(&sessions_mutex);
136}
137
138void lttng_unlock_sessions(void)
139{
140 mutex_unlock(&sessions_mutex);
141}
142
9fe593d2
FD		 143static struct lttng_transport *lttng_transport_find(const char *name)
144{
145 struct lttng_transport *transport;
146
147 list_for_each_entry(transport, &lttng_transport_list, node) {
148 if (!strcmp(transport->name, name))
149 return transport;
150 }
151 return NULL;
152}
153
3c997079
MD		 154/*
155 * Called with sessions lock held.
156 */
157int lttng_session_active(void)
158{
159 struct lttng_session *iter;
160
161 list_for_each_entry(iter, &sessions, list) {
162 if (iter->active)
163 return 1;
164 }
165 return 0;
166}
167
a90917c3 168struct lttng_session *lttng_session_create(void)
4e3c1b9b 169{
a90917c3 170 struct lttng_session *session;
d83004aa 171 struct lttng_metadata_cache *metadata_cache;
3c997079 172 int i;
4e3c1b9b
MD		 173
174 mutex_lock(&sessions_mutex);
48f5e0b5 175 session = lttng_kvzalloc(sizeof(struct lttng_session), GFP_KERNEL);
4e3c1b9b 176 if (!session)
d83004aa 177 goto err;
4e3c1b9b 178 INIT_LIST_HEAD(&session->chan);
f3d01b96 179 INIT_LIST_HEAD(&session->events);
0c023c01 180 INIT_LIST_HEAD(&session->counters);
a7008254 181 lttng_guid_gen(&session->uuid);
d83004aa
JD		 182
183 metadata_cache = kzalloc(sizeof(struct lttng_metadata_cache),
184 GFP_KERNEL);
185 if (!metadata_cache)
186 goto err_free_session;
0ca42eb7 187 metadata_cache->data = vzalloc(METADATA_CACHE_DEFAULT_SIZE);
d83004aa
JD		 188 if (!metadata_cache->data)
189 goto err_free_cache;
190 metadata_cache->cache_alloc = METADATA_CACHE_DEFAULT_SIZE;
191 kref_init(&metadata_cache->refcount);
92d9f5e6 192 mutex_init(&metadata_cache->lock);
d83004aa
JD		 193 session->metadata_cache = metadata_cache;
194 INIT_LIST_HEAD(&metadata_cache->metadata_stream);
a36580d5
MD		 195 memcpy(&metadata_cache->uuid, &session->uuid,
196 sizeof(metadata_cache->uuid));
3c997079
MD		 197 INIT_LIST_HEAD(&session->enablers_head);
198 for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
0c023c01
MD		 199 INIT_HLIST_HEAD(&session->events_name_ht.table[i]);
200 for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
201 INIT_HLIST_HEAD(&session->events_key_ht.table[i]);
4e3c1b9b 202 list_add(&session->list, &sessions);
d1f652f8
MD		 203 session->pid_tracker.session = session;
204 session->pid_tracker.tracker_type = TRACKER_PID;
205 session->vpid_tracker.session = session;
206 session->vpid_tracker.tracker_type = TRACKER_VPID;
207 session->uid_tracker.session = session;
208 session->uid_tracker.tracker_type = TRACKER_UID;
209 session->vuid_tracker.session = session;
210 session->vuid_tracker.tracker_type = TRACKER_VUID;
211 session->gid_tracker.session = session;
212 session->gid_tracker.tracker_type = TRACKER_GID;
213 session->vgid_tracker.session = session;
214 session->vgid_tracker.tracker_type = TRACKER_VGID;
4e3c1b9b
MD		 215 mutex_unlock(&sessions_mutex);
216 return session;
d83004aa
JD		 217
218err_free_cache:
219 kfree(metadata_cache);
220err_free_session:
48f5e0b5 221 lttng_kvfree(session);
d83004aa
JD		 222err:
223 mutex_unlock(&sessions_mutex);
224 return NULL;
225}
226
99f52fcc
FD		 227static
228struct lttng_counter_transport *lttng_counter_transport_find(const char *name)
229{
230 struct lttng_counter_transport *transport;
231
232 list_for_each_entry(transport, &lttng_counter_transport_list, node) {
233 if (!strcmp(transport->name, name))
234 return transport;
235 }
236 return NULL;
237}
238
0c023c01 239static
99f52fcc
FD		 240struct lttng_counter *lttng_kernel_counter_create(
241 const char *counter_transport_name,
0c023c01
MD		 242 size_t number_dimensions, const size_t *dimensions_sizes,
243 bool coalesce_hits)
99f52fcc 244{
99f52fcc 245 struct lttng_counter_transport *counter_transport = NULL;
0c023c01
MD		 246 struct lttng_counter *counter = NULL;
247 struct lttng_event_container *container;
99f52fcc
FD		 248
249 counter_transport = lttng_counter_transport_find(counter_transport_name);
250 if (!counter_transport) {
251 printk(KERN_WARNING "LTTng: counter transport %s not found.\n",
252 counter_transport_name);
253 goto notransport;
254 }
255 if (!try_module_get(counter_transport->owner)) {
256 printk(KERN_WARNING "LTTng: Can't lock counter transport module.\n");
257 goto notransport;
258 }
259
260 counter = lttng_kvzalloc(sizeof(struct lttng_counter), GFP_KERNEL);
261 if (!counter)
262 goto nomem;
0c023c01
MD		 263 container = lttng_counter_get_event_container(counter);
264 container->type = LTTNG_EVENT_CONTAINER_COUNTER;
265 container->coalesce_hits = coalesce_hits;
99f52fcc
FD		 266 /* Create event notifier error counter. */
267 counter->ops = &counter_transport->ops;
268 counter->transport = counter_transport;
0c023c01 269 mutex_init(&counter->map.lock);
99f52fcc
FD		 270
271 counter->counter = counter->ops->counter_create(
272 number_dimensions, dimensions_sizes, 0);
273 if (!counter->counter) {
0c023c01 274 printk(KERN_WARNING "LTTng: Error creating counter");
99f52fcc
FD		 275 goto create_error;
276 }
277
278 return counter;
279
280create_error:
281 lttng_kvfree(counter);
282nomem:
283 if (counter_transport)
284 module_put(counter_transport->owner);
285notransport:
286 return NULL;
287}
288
0c023c01
MD		 289static
290void lttng_kernel_counter_destroy(struct lttng_counter *counter)
291{
292 counter->ops->counter_destroy(counter->counter);
293 module_put(counter->transport->owner);
294 lttng_kvfree(counter->map.descriptors);
295 lttng_kvfree(counter);
296}
297
298int lttng_event_notifier_group_set_error_counter(
299 struct lttng_event_notifier_group *event_notifier_group,
300 const char *counter_transport_name,
301 size_t counter_len)
302{
303 struct lttng_counter *counter;
304 int ret;
305
306 /*
307 * Lock sessions to provide mutual exclusion against concurrent
308 * modification of trigger group, which would result in
309 * overwriting the error counter if set concurrently.
310 */
311 mutex_lock(&sessions_mutex);
312
313 if (event_notifier_group->error_counter) {
314 printk(KERN_ERR "Error counter already set in event notifier group\n");
315 ret = -EBUSY;
316 goto error;
317 }
318
319 counter = lttng_kernel_counter_create(counter_transport_name,
320 1, &counter_len, false);
321 if (!counter) {
322 ret = -EINVAL;
323 goto error;
324 }
325
326 event_notifier_group->error_counter_len = counter_len;
327 /*
328 * store-release to publish error counter matches load-acquire
329 * in record_error. Ensures the counter is created and the
330 * error_counter_len is set before they are used.
331 */
332 lttng_smp_store_release(&event_notifier_group->error_counter,
333 counter);
334
335 mutex_unlock(&sessions_mutex);
336 return 0;
337
338error:
339 mutex_unlock(&sessions_mutex);
340 return ret;
341}
342
750b05f2
FD		 343struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
344{
345 struct lttng_transport *transport = NULL;
346 struct lttng_event_notifier_group *event_notifier_group;
347 const char *transport_name = "relay-event-notifier";
348 size_t subbuf_size = 4096; //TODO
349 size_t num_subbuf = 16; //TODO
350 unsigned int switch_timer_interval = 0;
351 unsigned int read_timer_interval = 0;
dffef45d 352 int i;
750b05f2
FD		 353
354 mutex_lock(&sessions_mutex);
355
356 transport = lttng_transport_find(transport_name);
357 if (!transport) {
358 printk(KERN_WARNING "LTTng: transport %s not found\n",
359 transport_name);
360 goto notransport;
361 }
362 if (!try_module_get(transport->owner)) {
363 printk(KERN_WARNING "LTTng: Can't lock transport %s module.\n",
364 transport_name);
365 goto notransport;
366 }
367
368 event_notifier_group = lttng_kvzalloc(sizeof(struct lttng_event_notifier_group),
369 GFP_KERNEL);
370 if (!event_notifier_group)
371 goto nomem;
372
373 /*
374 * Initialize the ring buffer used to store event notifier
375 * notifications.
376 */
377 event_notifier_group->ops = &transport->ops;
378 event_notifier_group->chan = transport->ops.channel_create(
379 transport_name, event_notifier_group, NULL,
380 subbuf_size, num_subbuf, switch_timer_interval,
381 read_timer_interval);
382 if (!event_notifier_group->chan)
383 goto create_error;
384
385 event_notifier_group->transport = transport;
dffef45d
FD		 386
387 INIT_LIST_HEAD(&event_notifier_group->enablers_head);
388 INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head);
389 for (i = 0; i < LTTNG_EVENT_NOTIFIER_HT_SIZE; i++)
390 INIT_HLIST_HEAD(&event_notifier_group->event_notifiers_ht.table[i]);
391
750b05f2
FD		 392 list_add(&event_notifier_group->node, &event_notifier_groups);
393
394 mutex_unlock(&sessions_mutex);
395
396 return event_notifier_group;
397
398create_error:
399 lttng_kvfree(event_notifier_group);
400nomem:
401 if (transport)
402 module_put(transport->owner);
403notransport:
404 mutex_unlock(&sessions_mutex);
405 return NULL;
406}
407
0c023c01
MD		 408struct lttng_counter *lttng_session_create_counter(
409 struct lttng_session *session,
410 const char *counter_transport_name,
411 size_t number_dimensions, const size_t *dimensions_sizes,
412 bool coalesce_hits)
413{
414 struct lttng_counter *counter;
415 struct lttng_event_container *container;
416
417 counter = lttng_kernel_counter_create(counter_transport_name,
418 number_dimensions, dimensions_sizes,
419 coalesce_hits);
420 if (!counter) {
421 goto counter_error;
422 }
423 container = lttng_counter_get_event_container(counter);
424
425 mutex_lock(&sessions_mutex);
426 container->session = session;
427 list_add(&counter->node, &session->counters);
428 mutex_unlock(&sessions_mutex);
429
430 return counter;
431
432counter_error:
433 return NULL;
434}
435
d83004aa
JD		 436void metadata_cache_destroy(struct kref *kref)
437{
438 struct lttng_metadata_cache *cache =
439 container_of(kref, struct lttng_metadata_cache, refcount);
a606b6e8 440 vfree(cache->data);
d83004aa 441 kfree(cache);
4e3c1b9b
MD		 442}
443
a90917c3 444void lttng_session_destroy(struct lttng_session *session)
4e3c1b9b 445{
a90917c3
MD		 446 struct lttng_channel *chan, *tmpchan;
447 struct lttng_event *event, *tmpevent;
d83004aa 448 struct lttng_metadata_stream *metadata_stream;
b2bc0bc8 449 struct lttng_event_enabler *event_enabler, *tmp_event_enabler;
0c023c01 450 struct lttng_counter *counter, *tmpcounter;
dda6a249 451 int ret;
4e3c1b9b
MD		 452
453 mutex_lock(&sessions_mutex);
a8f2d0c7 454 WRITE_ONCE(session->active, 0);
1ec65de1 455 list_for_each_entry(chan, &session->chan, list) {
0c023c01
MD		 456 ret = lttng_syscalls_unregister_event_container(lttng_channel_get_event_container(chan));
457 WARN_ON(ret);
458 }
459 list_for_each_entry(counter, &session->counters, node) {
460 ret = lttng_syscalls_unregister_event_container(lttng_counter_get_event_container(counter));
1ec65de1
MD		 461 WARN_ON(ret);
462 }
dda6a249 463 list_for_each_entry(event, &session->events, list) {
a90917c3 464 ret = _lttng_event_unregister(event);
dda6a249
MD		 465 WARN_ON(ret);
466 }
abcca994 467 synchronize_trace(); /* Wait for in-flight events to complete */
badfe9f5 468 list_for_each_entry(chan, &session->chan, list) {
0c023c01
MD		 469 ret = lttng_syscalls_destroy_event_container(lttng_channel_get_event_container(chan));
470 WARN_ON(ret);
471 }
472 list_for_each_entry(counter, &session->counters, node) {
473 ret = lttng_syscalls_destroy_event_container(lttng_counter_get_event_container(counter));
badfe9f5
MD		 474 WARN_ON(ret);
475 }
b2bc0bc8 476 list_for_each_entry_safe(event_enabler, tmp_event_enabler,
3c997079 477 &session->enablers_head, node)
b2bc0bc8 478 lttng_event_enabler_destroy(event_enabler);
4e3c1b9b 479 list_for_each_entry_safe(event, tmpevent, &session->events, list)
a90917c3 480 _lttng_event_destroy(event);
d83004aa
JD		 481 list_for_each_entry_safe(chan, tmpchan, &session->chan, list) {
482 BUG_ON(chan->channel_type == METADATA_CHANNEL);
a90917c3 483 _lttng_channel_destroy(chan);
d83004aa 484 }
0c023c01
MD		 485 list_for_each_entry_safe(counter, tmpcounter, &session->counters, node)
486 _lttng_session_counter_destroy(counter);
ab036a63 487 mutex_lock(&session->metadata_cache->lock);
d83004aa
JD		 488 list_for_each_entry(metadata_stream, &session->metadata_cache->metadata_stream, list)
489 _lttng_metadata_channel_hangup(metadata_stream);
ab036a63 490 mutex_unlock(&session->metadata_cache->lock);
d1f652f8
MD		 491 lttng_id_tracker_destroy(&session->pid_tracker, false);
492 lttng_id_tracker_destroy(&session->vpid_tracker, false);
493 lttng_id_tracker_destroy(&session->uid_tracker, false);
494 lttng_id_tracker_destroy(&session->vuid_tracker, false);
495 lttng_id_tracker_destroy(&session->gid_tracker, false);
496 lttng_id_tracker_destroy(&session->vgid_tracker, false);
d83004aa 497 kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
4e3c1b9b
MD		 498 list_del(&session->list);
499 mutex_unlock(&sessions_mutex);
48f5e0b5 500 lttng_kvfree(session);
4e3c1b9b
MD		 501}
502
dffef45d
FD		 503void lttng_event_notifier_group_destroy(
504 struct lttng_event_notifier_group *event_notifier_group)
750b05f2 505{
dffef45d
FD		 506 struct lttng_event_notifier_enabler *event_notifier_enabler, *tmp_event_notifier_enabler;
507 struct lttng_event_notifier *event_notifier, *tmpevent_notifier;
508 int ret;
509
750b05f2
FD		 510 if (!event_notifier_group)
511 return;
512
513 mutex_lock(&sessions_mutex);
dffef45d 514
3b82c4e1 515 ret = lttng_syscalls_unregister_event_notifier_group(event_notifier_group);
8a8ac9a8
FD		 516 WARN_ON(ret);
517
dffef45d
FD		 518 list_for_each_entry_safe(event_notifier, tmpevent_notifier,
519 &event_notifier_group->event_notifiers_head, list) {
520 ret = _lttng_event_notifier_unregister(event_notifier);
521 WARN_ON(ret);
522 }
523
b01155ba
FD		 524 /* Wait for in-flight event notifier to complete */
525 synchronize_trace();
526
21f58fb7
FD		 527 irq_work_sync(&event_notifier_group->wakeup_pending);
528
8a8ac9a8
FD		 529 kfree(event_notifier_group->sc_filter);
530
dffef45d
FD		 531 list_for_each_entry_safe(event_notifier_enabler, tmp_event_notifier_enabler,
532 &event_notifier_group->enablers_head, node)
533 lttng_event_notifier_enabler_destroy(event_notifier_enabler);
534
535 list_for_each_entry_safe(event_notifier, tmpevent_notifier,
536 &event_notifier_group->event_notifiers_head, list)
537 _lttng_event_notifier_destroy(event_notifier);
538
99f52fcc
FD		 539 if (event_notifier_group->error_counter) {
540 struct lttng_counter *error_counter = event_notifier_group->error_counter;
ab04d7b1 541
0c023c01 542 lttng_kernel_counter_destroy(error_counter);
99f52fcc
FD		 543 event_notifier_group->error_counter = NULL;
544 }
545
750b05f2
FD		 546 event_notifier_group->ops->channel_destroy(event_notifier_group->chan);
547 module_put(event_notifier_group->transport->owner);
548 list_del(&event_notifier_group->node);
dffef45d 549
750b05f2
FD		 550 mutex_unlock(&sessions_mutex);
551 lttng_kvfree(event_notifier_group);
552}
553
601252cf
MD		 554int lttng_session_statedump(struct lttng_session *session)
555{
556 int ret;
557
558 mutex_lock(&sessions_mutex);
559 ret = lttng_statedump_start(session);
560 mutex_unlock(&sessions_mutex);
561 return ret;
562}
563
a90917c3 564int lttng_session_enable(struct lttng_session *session)
c0e31d2e
MD		 565{
566 int ret = 0;
a90917c3 567 struct lttng_channel *chan;
c0e31d2e
MD		 568
569 mutex_lock(&sessions_mutex);
570 if (session->active) {
571 ret = -EBUSY;
572 goto end;
573 }
c099397a 574
3c997079
MD		 575 /* Set transient enabler state to "enabled" */
576 session->tstate = 1;
577
4ef81e4a 578 /* We need to sync enablers with session before activation. */
b2bc0bc8 579 lttng_session_sync_event_enablers(session);
4ef81e4a 580
c099397a
MD		 581 /*
582 * Snapshot the number of events per channel to know the type of header
583 * we need to use.
584 */
585 list_for_each_entry(chan, &session->chan, list) {
586 if (chan->header_type)
587 continue; /* don't change it if session stop/restart */
588 if (chan->free_event_id < 31)
589 chan->header_type = 1; /* compact */
590 else
591 chan->header_type = 2; /* large */
592 }
593
64af2437 594 /* Clear each stream's quiescent state. */
09b93db9
MD		 595 list_for_each_entry(chan, &session->chan, list) {
596 if (chan->channel_type != METADATA_CHANNEL)
597 lib_ring_buffer_clear_quiescent_channel(chan->chan);
598 }
64af2437 599
a8f2d0c7
MJ		 600 WRITE_ONCE(session->active, 1);
601 WRITE_ONCE(session->been_active, 1);
a90917c3 602 ret = _lttng_session_metadata_statedump(session);
c337ddc2 603 if (ret) {
a8f2d0c7 604 WRITE_ONCE(session->active, 0);
c337ddc2
MD		 605 goto end;
606 }
607 ret = lttng_statedump_start(session);
360f38ea 608 if (ret)
a8f2d0c7 609 WRITE_ONCE(session->active, 0);
c0e31d2e
MD		 610end:
611 mutex_unlock(&sessions_mutex);
11b5a3c2 612 return ret;
c0e31d2e
MD		 613}
614
a90917c3 615int lttng_session_disable(struct lttng_session *session)
c0e31d2e
MD		 616{
617 int ret = 0;
64af2437 618 struct lttng_channel *chan;
c0e31d2e
MD		 619
620 mutex_lock(&sessions_mutex);
621 if (!session->active) {
622 ret = -EBUSY;
623 goto end;
624 }
a8f2d0c7 625 WRITE_ONCE(session->active, 0);
3c997079
MD		 626
627 /* Set transient enabler state to "disabled" */
628 session->tstate = 0;
b2bc0bc8 629 lttng_session_sync_event_enablers(session);
64af2437
MD		 630
631 /* Set each stream's quiescent state. */
09b93db9
MD		 632 list_for_each_entry(chan, &session->chan, list) {
633 if (chan->channel_type != METADATA_CHANNEL)
634 lib_ring_buffer_set_quiescent_channel(chan->chan);
635 }
c0e31d2e
MD		 636end:
637 mutex_unlock(&sessions_mutex);
11b5a3c2 638 return ret;
c0e31d2e
MD		 639}
640
9616f0bf
JD		 641int lttng_session_metadata_regenerate(struct lttng_session *session)
642{
643 int ret = 0;
644 struct lttng_channel *chan;
645 struct lttng_event *event;
646 struct lttng_metadata_cache *cache = session->metadata_cache;
647 struct lttng_metadata_stream *stream;
648
649 mutex_lock(&sessions_mutex);
650 if (!session->active) {
651 ret = -EBUSY;
652 goto end;
653 }
654
655 mutex_lock(&cache->lock);
656 memset(cache->data, 0, cache->cache_alloc);
657 cache->metadata_written = 0;
658 cache->version++;
659 list_for_each_entry(stream, &session->metadata_cache->metadata_stream, list) {
660 stream->metadata_out = 0;
661 stream->metadata_in = 0;
662 }
663 mutex_unlock(&cache->lock);
664
665 session->metadata_dumped = 0;
666 list_for_each_entry(chan, &session->chan, list) {
667 chan->metadata_dumped = 0;
668 }
669
670 list_for_each_entry(event, &session->events, list) {
671 event->metadata_dumped = 0;
672 }
673
674 ret = _lttng_session_metadata_statedump(session);
675
676end:
677 mutex_unlock(&sessions_mutex);
678 return ret;
679}
680
0c023c01 681int lttng_event_container_enable(struct lttng_event_container *container)
e64957da 682{
3c997079 683 int ret = 0;
e64957da 684
3c997079 685 mutex_lock(&sessions_mutex);
0c023c01 686 if (lttng_event_container_is_metadata_channel(container)) {
3c997079
MD		 687 ret = -EPERM;
688 goto end;
689 }
0c023c01 690 if (container->enabled) {
3c997079
MD		 691 ret = -EEXIST;
692 goto end;
693 }
694 /* Set transient enabler state to "enabled" */
0c023c01
MD		 695 container->tstate = 1;
696 lttng_session_sync_event_enablers(container->session);
3c997079 697 /* Set atomically the state to "enabled" */
0c023c01 698 WRITE_ONCE(container->enabled, 1);
3c997079
MD		 699end:
700 mutex_unlock(&sessions_mutex);
701 return ret;
e64957da
MD		 702}
703
0c023c01 704int lttng_event_container_disable(struct lttng_event_container *container)
e64957da 705{
3c997079 706 int ret = 0;
e64957da 707
3c997079 708 mutex_lock(&sessions_mutex);
0c023c01 709 if (lttng_event_container_is_metadata_channel(container)) {
3c997079
MD		 710 ret = -EPERM;
711 goto end;
712 }
0c023c01 713 if (!container->enabled) {
3c997079
MD		 714 ret = -EEXIST;
715 goto end;
716 }
717 /* Set atomically the state to "disabled" */
0c023c01 718 WRITE_ONCE(container->enabled, 0);
3c997079 719 /* Set transient enabler state to "enabled" */
0c023c01
MD		 720 container->tstate = 0;
721 lttng_session_sync_event_enablers(container->session);
3c997079
MD		 722end:
723 mutex_unlock(&sessions_mutex);
724 return ret;
e64957da
MD		 725}
726
a90917c3 727int lttng_event_enable(struct lttng_event *event)
e64957da 728{
3c997079 729 int ret = 0;
e64957da 730
3c997079 731 mutex_lock(&sessions_mutex);
0c023c01 732 if (lttng_event_within_metadata_channel(event)) {
3c997079
MD		 733 ret = -EPERM;
734 goto end;
735 }
736 if (event->enabled) {
737 ret = -EEXIST;
738 goto end;
739 }
a0493bef
MD		 740 switch (event->instrumentation) {
741 case LTTNG_KERNEL_TRACEPOINT:
742 case LTTNG_KERNEL_SYSCALL:
743 ret = -EINVAL;
744 break;
745 case LTTNG_KERNEL_KPROBE:
149b9a9d 746 case LTTNG_KERNEL_UPROBE:
a0493bef 747 case LTTNG_KERNEL_NOOP:
a8f2d0c7 748 WRITE_ONCE(event->enabled, 1);
a0493bef
MD		 749 break;
750 case LTTNG_KERNEL_KRETPROBE:
751 ret = lttng_kretprobes_event_enable_state(event, 1);
752 break;
e884017c 753 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
a0493bef
MD		 754 default:
755 WARN_ON_ONCE(1);
756 ret = -EINVAL;
757 }
3c997079
MD		 758end:
759 mutex_unlock(&sessions_mutex);
760 return ret;
e64957da
MD		 761}
762
a90917c3 763int lttng_event_disable(struct lttng_event *event)
e64957da 764{
3c997079 765 int ret = 0;
e64957da 766
3c997079 767 mutex_lock(&sessions_mutex);
0c023c01 768 if (lttng_event_within_metadata_channel(event)) {
3c997079
MD		 769 ret = -EPERM;
770 goto end;
771 }
772 if (!event->enabled) {
773 ret = -EEXIST;
774 goto end;
775 }
a0493bef
MD		 776 switch (event->instrumentation) {
777 case LTTNG_KERNEL_TRACEPOINT:
778 case LTTNG_KERNEL_SYSCALL:
779 ret = -EINVAL;
780 break;
781 case LTTNG_KERNEL_KPROBE:
149b9a9d 782 case LTTNG_KERNEL_UPROBE:
a0493bef 783 case LTTNG_KERNEL_NOOP:
a8f2d0c7 784 WRITE_ONCE(event->enabled, 0);
a0493bef
MD		 785 break;
786 case LTTNG_KERNEL_KRETPROBE:
787 ret = lttng_kretprobes_event_enable_state(event, 0);
788 break;
e884017c 789 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
a0493bef
MD		 790 default:
791 WARN_ON_ONCE(1);
792 ret = -EINVAL;
793 }
3c997079
MD		 794end:
795 mutex_unlock(&sessions_mutex);
796 return ret;
e64957da
MD		 797}
798
dffef45d
FD		 799int lttng_event_notifier_enable(struct lttng_event_notifier *event_notifier)
800{
801 int ret = 0;
802
803 mutex_lock(&sessions_mutex);
804 if (event_notifier->enabled) {
805 ret = -EEXIST;
806 goto end;
807 }
808 switch (event_notifier->instrumentation) {
809 case LTTNG_KERNEL_TRACEPOINT:
8a8ac9a8 810 case LTTNG_KERNEL_SYSCALL:
b01155ba
FD		 811 ret = -EINVAL;
812 break;
dffef45d 813 case LTTNG_KERNEL_KPROBE:
9de67196 814 case LTTNG_KERNEL_UPROBE:
2b16f0c9
FD		 815 WRITE_ONCE(event_notifier->enabled, 1);
816 break;
dffef45d 817 case LTTNG_KERNEL_FUNCTION:
dffef45d
FD		 818 case LTTNG_KERNEL_NOOP:
819 case LTTNG_KERNEL_KRETPROBE:
820 default:
821 WARN_ON_ONCE(1);
822 ret = -EINVAL;
823 }
824end:
825 mutex_unlock(&sessions_mutex);
826 return ret;
827}
828
829int lttng_event_notifier_disable(struct lttng_event_notifier *event_notifier)
830{
831 int ret = 0;
832
833 mutex_lock(&sessions_mutex);
834 if (!event_notifier->enabled) {
835 ret = -EEXIST;
836 goto end;
837 }
838 switch (event_notifier->instrumentation) {
839 case LTTNG_KERNEL_TRACEPOINT:
8a8ac9a8 840 case LTTNG_KERNEL_SYSCALL:
b01155ba
FD		 841 ret = -EINVAL;
842 break;
dffef45d 843 case LTTNG_KERNEL_KPROBE:
9de67196 844 case LTTNG_KERNEL_UPROBE:
2b16f0c9
FD		 845 WRITE_ONCE(event_notifier->enabled, 0);
846 break;
dffef45d 847 case LTTNG_KERNEL_FUNCTION:
dffef45d
FD		 848 case LTTNG_KERNEL_NOOP:
849 case LTTNG_KERNEL_KRETPROBE:
850 default:
851 WARN_ON_ONCE(1);
852 ret = -EINVAL;
853 }
854end:
855 mutex_unlock(&sessions_mutex);
856 return ret;
857}
858
a90917c3 859struct lttng_channel *lttng_channel_create(struct lttng_session *session,
5dbbdb43
MD		 860 const char *transport_name,
861 void *buf_addr,
4e3c1b9b
MD		 862 size_t subbuf_size, size_t num_subbuf,
863 unsigned int switch_timer_interval,
d83004aa
JD		 864 unsigned int read_timer_interval,
865 enum channel_type channel_type)
4e3c1b9b 866{
0c023c01
MD		 867 struct lttng_event_container *container;
868 struct lttng_channel *chan = NULL;
a90917c3 869 struct lttng_transport *transport = NULL;
4e3c1b9b
MD		 870
871 mutex_lock(&sessions_mutex);
d83004aa 872 if (session->been_active && channel_type != METADATA_CHANNEL)
e5382b6d 873 goto active; /* Refuse to add channel to active session */
a90917c3 874 transport = lttng_transport_find(transport_name);
f3d01b96 875 if (!transport) {
5a15f70c 876 printk(KERN_WARNING "LTTng: transport %s not found\n",
f3d01b96 877 transport_name);
c0e31d2e 878 goto notransport;
f3d01b96 879 }
a33c9927 880 if (!try_module_get(transport->owner)) {
5a15f70c 881 printk(KERN_WARNING "LTTng: Can't lock transport module.\n");
a33c9927
MD		 882 goto notransport;
883 }
0c023c01 884 chan = lttng_kvzalloc(sizeof(struct lttng_channel), GFP_KERNEL);
4e3c1b9b 885 if (!chan)
c0e31d2e 886 goto nomem;
0c023c01
MD		 887 container = lttng_channel_get_event_container(chan);
888 container->type = LTTNG_EVENT_CONTAINER_CHANNEL;
889 container->session = session;
890 container->tstate = 1;
891 container->enabled = 1;
892 /*
893 * The ring buffer always coalesces hits from various event
894 * enablers matching a given event to a single event record within the
895 * ring buffer.
896 */
897 container->coalesce_hits = true;
898
05d32c64 899 chan->id = session->free_chan_id++;
3b731ab1 900 chan->ops = &transport->ops;
125b4df4
MD		 901 /*
902 * Note: the channel creation op already writes into the packet
903 * headers. Therefore the "chan" information used as input
904 * should be already accessible.
905 */
5f5ddf01 906 chan->chan = transport->ops.channel_create(transport_name,
0c023c01 907 container, buf_addr, subbuf_size, num_subbuf,
5f5ddf01 908 switch_timer_interval, read_timer_interval);
f3d01b96
MD		 909 if (!chan->chan)
910 goto create_error;
a33c9927 911 chan->transport = transport;
d83004aa 912 chan->channel_type = channel_type;
4e3c1b9b
MD		 913 list_add(&chan->list, &session->chan);
914 mutex_unlock(&sessions_mutex);
915 return chan;
916
f3d01b96 917create_error:
0c023c01 918 lttng_kvfree(chan);
c0e31d2e 919nomem:
a33c9927
MD		 920 if (transport)
921 module_put(transport->owner);
c0e31d2e 922notransport:
e5382b6d 923active:
4e3c1b9b
MD		 924 mutex_unlock(&sessions_mutex);
925 return NULL;
926}
927
0c023c01
MD		 928static
929void _lttng_session_counter_destroy(struct lttng_counter *counter)
930{
931 list_del(&counter->node);
932 lttng_kernel_counter_destroy(counter);
933}
934
4e3c1b9b 935/*
d83004aa
JD		 936 * Only used internally at session destruction for per-cpu channels, and
937 * when metadata channel is released.
938 * Needs to be called with sessions mutex held.
4e3c1b9b 939 */
aa7c23a9 940static
a90917c3 941void _lttng_channel_destroy(struct lttng_channel *chan)
4e3c1b9b 942{
11b5a3c2 943 chan->ops->channel_destroy(chan->chan);
a33c9927 944 module_put(chan->transport->owner);
4e3c1b9b 945 list_del(&chan->list);
8070f5c0 946 lttng_destroy_context(chan->ctx);
0c023c01 947 lttng_kvfree(chan);
4e3c1b9b
MD		 948}
949
d83004aa
JD		 950void lttng_metadata_channel_destroy(struct lttng_channel *chan)
951{
952 BUG_ON(chan->channel_type != METADATA_CHANNEL);
d83004aa
JD		 953 /* Protect the metadata cache with the sessions_mutex. */
954 mutex_lock(&sessions_mutex);
955 _lttng_channel_destroy(chan);
956 mutex_unlock(&sessions_mutex);
957}
958EXPORT_SYMBOL_GPL(lttng_metadata_channel_destroy);
959
960static
961void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
962{
963 stream->finalized = 1;
964 wake_up_interruptible(&stream->read_wait);
965}
966
0c023c01
MD		 967static
968bool lttng_event_container_current_id_full(struct lttng_event_container *container)
969{
970 switch (container->type) {
971 case LTTNG_EVENT_CONTAINER_CHANNEL:
972 {
973 struct lttng_channel *channel = lttng_event_container_get_channel(container);
974
975 return channel->free_event_id == -1U;
976 }
977 case LTTNG_EVENT_CONTAINER_COUNTER:
978 {
979 struct lttng_counter *counter = lttng_event_container_get_counter(container);
980 size_t nr_dimensions, max_nr_elem;
981
982 if (lttng_counter_get_nr_dimensions(&counter->counter->config,
983 counter->counter, &nr_dimensions))
984 return true;
985 WARN_ON_ONCE(nr_dimensions != 1);
986 if (nr_dimensions != 1)
987 return true;
988 if (lttng_counter_get_max_nr_elem(&counter->counter->config,
989 counter->counter, &max_nr_elem))
990 return true;
991 return counter->free_index >= max_nr_elem;
992 }
993 default:
994 WARN_ON_ONCE(1);
995 return true;
996 }
997}
998
999
1000static
1001int lttng_event_container_allocate_id(struct lttng_event_container *container,
1002 const char *key_string, size_t *id)
1003{
1004 struct lttng_session *session = container->session;
1005 struct lttng_event *event;
1006
1007 if (key_string[0]) {
1008 struct hlist_head *head;
1009
1010 head = utils_borrow_hash_table_bucket(session->events_key_ht.table,
1011 LTTNG_EVENT_HT_SIZE, key_string);
1012 lttng_hlist_for_each_entry(event, head, key_hlist) {
1013 if (!strcmp(key_string, event->key)) {
1014 /* Same key, use same id. */
1015 *id = event->id;
1016 return 0;
1017 }
1018 }
1019 }
1020
1021 if (lttng_event_container_current_id_full(container)) {
1022 return -EMFILE;
1023 }
1024
1025 switch (container->type) {
1026 case LTTNG_EVENT_CONTAINER_CHANNEL:
1027 {
1028 struct lttng_channel *channel = lttng_event_container_get_channel(container);
1029 *id = channel->free_event_id++;
1030 break;
1031 }
1032 case LTTNG_EVENT_CONTAINER_COUNTER:
1033 {
1034 struct lttng_counter *counter = lttng_event_container_get_counter(container);
1035 *id = counter->free_index++;
1036 break;
1037 }
1038 default:
1039 WARN_ON_ONCE(1);
1040 return 0;
1041 }
1042
1043 return 0;
1044}
1045
1046static
1047int format_event_key(char *key_string, const struct lttng_counter_key *key,
1048 const char *event_name)
1049{
1050 const struct lttng_counter_key_dimension *dim;
1051 size_t i, left = LTTNG_KEY_TOKEN_STRING_LEN_MAX;
1052
1053 key_string[0] = '\0';
1054 if (!key || !key->nr_dimensions)
1055 return 0;
1056 /* Currently event keys can only be specified on a single dimension. */
1057 if (key->nr_dimensions != 1)
1058 return -EINVAL;
1059 dim = &key->key_dimensions[0];
1060 for (i = 0; i < dim->nr_key_tokens; i++) {
1061 const struct lttng_key_token *token = &dim->key_tokens[i];
1062 size_t token_len;
1063 const char *str;
1064
1065 switch (token->type) {
1066 case LTTNG_KEY_TOKEN_STRING:
1067 str = token->arg.string;
1068 break;
1069 case LTTNG_KEY_TOKEN_EVENT_NAME:
1070 str = event_name;
1071 break;
1072 default:
1073 return -EINVAL;
1074 }
1075 token_len = strlen(str);
1076 if (token_len >= left)
1077 return -EINVAL;
1078 strcat(key_string, str);
1079 left -= token_len;
1080 }
1081 return 0;
1082}
1083
1084static
1085bool match_event_token(struct lttng_event_container *container,
1086 struct lttng_event *event, uint64_t token)
1087{
1088 if (container->coalesce_hits)
1089 return true;
1090 if (event->user_token == token)
1091 return true;
1092 return false;
1093}
1094
1095static
1096int lttng_counter_append_descriptor(struct lttng_counter *counter,
1097 uint64_t user_token,
1098 size_t index,
1099 const char *key)
1100{
1101 struct lttng_counter_map *map = &counter->map;
1102 struct lttng_counter_map_descriptor *last;
1103 int ret = 0;
1104
1105 if (strlen(key) >= LTTNG_KERNEL_COUNTER_KEY_LEN) {
1106 WARN_ON_ONCE(1);
1107 return -EOVERFLOW;
1108 }
1109 mutex_lock(&map->lock);
1110 if (map->nr_descriptors == map->alloc_len) {
1111 struct lttng_counter_map_descriptor *new_table, *old_table;
1112 size_t old_len = map->nr_descriptors;
1113 size_t new_len = max_t(size_t, old_len + 1, map->alloc_len * 2);
1114
1115 old_table = map->descriptors;
1116 new_table = lttng_kvzalloc(sizeof(struct lttng_counter_map_descriptor) * new_len,
1117 GFP_KERNEL);
1118 if (!new_table) {
1119 ret = -ENOMEM;
1120 goto unlock;
1121 }
1122
1123 if (old_table)
1124 memcpy(new_table, old_table, old_len * sizeof(struct lttng_counter_map_descriptor));
1125
1126 map->descriptors = new_table;
1127 map->alloc_len = new_len;
1128 lttng_kvfree(old_table);
1129 }
1130 last = &map->descriptors[map->nr_descriptors++];
1131 last->user_token = user_token;
1132 last->array_index = index;
1133 strcpy(last->key, key);
1134unlock:
1135 mutex_unlock(&map->lock);
1136 return ret;
1137}
a101fa10 1138
e5382b6d
MD		 1139/*
1140 * Supports event creation while tracing session is active.
3c997079 1141 * Needs to be called with sessions mutex held.
e5382b6d 1142 */
0c023c01 1143struct lttng_event *_lttng_event_create(struct lttng_event_container *container,
3c997079 1144 struct lttng_kernel_event *event_param,
0c023c01 1145 const struct lttng_counter_key *key,
3c997079
MD		 1146 void *filter,
1147 const struct lttng_event_desc *event_desc,
0c023c01
MD		 1148 enum lttng_kernel_instrumentation itype,
1149 uint64_t token)
4e3c1b9b 1150{
0c023c01 1151 struct lttng_session *session;
a90917c3 1152 struct lttng_event *event;
0c023c01
MD		 1153 char event_name[LTTNG_KERNEL_SYM_NAME_LEN];
1154 struct hlist_head *name_head, *key_head;
1155 char key_string[LTTNG_KEY_TOKEN_STRING_LEN_MAX];
3d084699 1156 int ret;
4e3c1b9b 1157
0c023c01 1158 session = container->session;
3c997079
MD		 1159 switch (itype) {
1160 case LTTNG_KERNEL_TRACEPOINT:
0c023c01
MD		 1161 if (strlen(event_desc->name) >= LTTNG_KERNEL_SYM_NAME_LEN) {
1162 ret = -EINVAL;
1163 goto type_error;
1164 }
1165 strcpy(event_name, event_desc->name);
3c997079
MD		 1166 break;
1167 case LTTNG_KERNEL_KPROBE:
149b9a9d 1168 case LTTNG_KERNEL_UPROBE:
33a39a3c 1169 case LTTNG_KERNEL_SYSCALL:
0c023c01
MD		 1170 if (strlen(event_param->name) >= LTTNG_KERNEL_SYM_NAME_LEN) {
1171 ret = -EINVAL;
1172 goto type_error;
1173 }
1174 strcpy(event_name, event_param->name);
1175 break;
1176 case LTTNG_KERNEL_KRETPROBE:
1177 if (strlen(event_param->name) >= LTTNG_KERNEL_SYM_NAME_LEN) {
1178 ret = -EINVAL;
1179 goto type_error;
1180 }
1181 strcpy(event_name, event_param->name);
1182 if (strlen(event_name) + strlen("_entry") >= LTTNG_KERNEL_SYM_NAME_LEN) {
1183 ret = -EINVAL;
1184 goto type_error;
1185 }
1186 strcat(event_name, "_entry");
3c997079 1187 break;
e884017c 1188 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
0c023c01 1189 case LTTNG_KERNEL_NOOP: /* Fall-through. */
3c997079
MD		 1190 default:
1191 WARN_ON_ONCE(1);
1192 ret = -EINVAL;
1193 goto type_error;
1194 }
4a11ef1c 1195
0c023c01
MD		 1196 if (format_event_key(key_string, key, event_name)) {
1197 ret = -EINVAL;
1198 goto type_error;
1199 }
1200
1201 name_head = utils_borrow_hash_table_bucket(session->events_name_ht.table,
4a11ef1c 1202 LTTNG_EVENT_HT_SIZE, event_name);
0c023c01
MD		 1203 lttng_hlist_for_each_entry(event, name_head, name_hlist) {
1204 bool same_event = false, same_container = false, same_key = false,
1205 same_token = false;
1206
3c997079 1207 WARN_ON_ONCE(!event->desc);
0c023c01
MD		 1208 if (event_desc) {
1209 if (event->desc == event_desc)
1210 same_event = true;
1211 } else {
1212 if (!strcmp(event_name, event->desc->name))
1213 same_event = true;
1214 }
1215 if (container == event->container) {
1216 same_container = true;
1217 if (match_event_token(container, event, token))
1218 same_token = true;
1219 }
1220 if (key_string[0] == '\0' || !strcmp(key_string, event->key))
1221 same_key = true;
1222 if (same_event && same_container && same_key && same_token) {
3c997079
MD		 1223 ret = -EEXIST;
1224 goto exist;
abc0446a
MD		 1225 }
1226 }
3c997079 1227
11b5a3c2 1228 event = kmem_cache_zalloc(event_cache, GFP_KERNEL);
abc0446a 1229 if (!event) {
4cf0bf51 1230 ret = -ENOMEM;
4e3c1b9b 1231 goto cache_error;
abc0446a 1232 }
0c023c01 1233 event->container = container;
4e3c1b9b 1234 event->filter = filter;
3c997079
MD		 1235 event->instrumentation = itype;
1236 event->evtype = LTTNG_TYPE_EVENT;
0c023c01
MD		 1237 if (!container->coalesce_hits)
1238 event->user_token = token;
183e8b3a 1239 INIT_LIST_HEAD(&event->filter_bytecode_runtime_head);
3c997079 1240 INIT_LIST_HEAD(&event->enablers_ref_head);
0c023c01
MD		 1241 if (lttng_event_container_allocate_id(container, key_string,
1242 &event->id)) {
1243 ret = -EMFILE;
1244 goto full;
1245 }
1246 if (key_string[0]) {
1247 key_head = utils_borrow_hash_table_bucket(session->events_key_ht.table,
1248 LTTNG_EVENT_HT_SIZE, key_string);
1249 hlist_add_head(&event->key_hlist, key_head);
1250 }
1251 strcpy(event->key, key_string);
3c997079
MD		 1252
1253 switch (itype) {
ab2277d6 1254 case LTTNG_KERNEL_TRACEPOINT:
3c997079
MD		 1255 /* Event will be enabled by enabler sync. */
1256 event->enabled = 0;
1257 event->registered = 0;
0bcedee9 1258 event->desc = lttng_event_desc_get(event_name);
abc0446a 1259 if (!event->desc) {
4cf0bf51 1260 ret = -ENOENT;
d3dbe23c 1261 goto register_error;
abc0446a 1262 }
3c997079
MD		 1263 /* Populate lttng_event structure before event registration. */
1264 smp_wmb();
baf20995 1265 break;
ab2277d6 1266 case LTTNG_KERNEL_KPROBE:
a0493bef
MD		 1267 /*
1268 * Needs to be explicitly enabled after creation, since
1269 * we may want to apply filters.
1270 */
1271 event->enabled = 0;
3c997079
MD		 1272 event->registered = 1;
1273 /*
1274 * Populate lttng_event structure before event
1275 * registration.
1276 */
1277 smp_wmb();
8bf17deb 1278 ret = lttng_kprobes_register_event(event_name,
f17701fb
MD		 1279 event_param->u.kprobe.symbol_name,
1280 event_param->u.kprobe.offset,
1281 event_param->u.kprobe.addr,
1282 event);
abc0446a 1283 if (ret) {
4cf0bf51 1284 ret = -EINVAL;
d6d808f3 1285 goto register_error;
abc0446a 1286 }
0c023c01 1287 event->u.kprobe.user_token = token;
edeb3137
MD		 1288 ret = try_module_get(event->desc->owner);
1289 WARN_ON_ONCE(!ret);
0c023c01
MD		 1290
1291 /* Append descriptor to counter. */
1292 switch (container->type) {
1293 case LTTNG_EVENT_CONTAINER_COUNTER:
1294 {
1295 struct lttng_counter *counter;
1296 const char *name = "<UNKNOWN>";
1297 int ret;
1298
1299 counter = lttng_event_container_get_counter(container);
1300 if (event->key[0])
1301 name = event->key;
1302 else
1303 name = event_name;
1304 ret = lttng_counter_append_descriptor(counter,
1305 token, event->id,
1306 name);
1307 if (ret) {
1308 WARN_ON_ONCE(1);
1309 }
1310 break;
1311 }
1312 case LTTNG_EVENT_CONTAINER_CHANNEL:
1313 default:
1314 break;
1315 }
d6d808f3 1316 break;
7371f44c
MD		 1317 case LTTNG_KERNEL_KRETPROBE:
1318 {
a90917c3 1319 struct lttng_event *event_return;
7371f44c
MD		 1320
1321 /* kretprobe defines 2 events */
a0493bef
MD		 1322 /*
1323 * Needs to be explicitly enabled after creation, since
1324 * we may want to apply filters.
1325 */
1326 event->enabled = 0;
3c997079 1327 event->registered = 1;
0c023c01
MD		 1328 event->u.kretprobe.user_token = token;
1329
1330 /* Append descriptor to counter. */
1331 switch (container->type) {
1332 case LTTNG_EVENT_CONTAINER_COUNTER:
1333 {
1334 struct lttng_counter *counter;
1335 const char *name = "<UNKNOWN>";
1336 int ret;
1337
1338 counter = lttng_event_container_get_counter(container);
1339 if (event->key[0])
1340 name = event->key;
1341 else
1342 name = event_name;
1343 ret = lttng_counter_append_descriptor(counter,
1344 token, event->id,
1345 name);
1346 if (ret) {
1347 WARN_ON_ONCE(1);
1348 }
1349 break;
1350 }
1351 case LTTNG_EVENT_CONTAINER_CHANNEL:
1352 default:
1353 break;
1354 }
1355
7371f44c
MD		 1356 event_return =
1357 kmem_cache_zalloc(event_cache, GFP_KERNEL);
abc0446a 1358 if (!event_return) {
4cf0bf51 1359 ret = -ENOMEM;
7371f44c 1360 goto register_error;
abc0446a 1361 }
0c023c01 1362 event_return->container = container;
7371f44c 1363 event_return->filter = filter;
0c023c01
MD		 1364
1365 strcpy(event_name, event_param->name);
1366 if (strlen(event_name) + strlen("_return") >= LTTNG_KERNEL_SYM_NAME_LEN) {
1367 ret = -EINVAL;
1368 goto register_error;
1369 }
1370 strcat(event_name, "_return");
1371 if (format_event_key(key_string, key, event_name)) {
1372 ret = -EINVAL;
1373 goto register_error;
1374 }
1375 if (lttng_event_container_allocate_id(container, key_string, &event_return->id)) {
1376 kmem_cache_free(event_cache, event_return);
1377 ret = -EMFILE;
1378 goto register_error;
1379 }
1380 key_head = utils_borrow_hash_table_bucket(session->events_key_ht.table,
1381 LTTNG_EVENT_HT_SIZE, key_string);
1382 hlist_add_head(&event_return->key_hlist, key_head);
a0493bef 1383 event_return->enabled = 0;
3c997079
MD		 1384 event_return->registered = 1;
1385 event_return->instrumentation = itype;
484ec217
FD		 1386 INIT_LIST_HEAD(&event_return->filter_bytecode_runtime_head);
1387 INIT_LIST_HEAD(&event_return->enablers_ref_head);
0c023c01
MD		 1388 event_return->u.kretprobe.user_token = token;
1389 strcpy(event_return->key, key_string);
7371f44c 1390 /*
a90917c3 1391 * Populate lttng_event structure before kretprobe registration.
7371f44c
MD		 1392 */
1393 smp_wmb();
3c997079 1394 ret = lttng_kretprobes_register(event_name,
7371f44c
MD		 1395 event_param->u.kretprobe.symbol_name,
1396 event_param->u.kretprobe.offset,
1397 event_param->u.kretprobe.addr,
1398 event, event_return);
1399 if (ret) {
1400 kmem_cache_free(event_cache, event_return);
4cf0bf51 1401 ret = -EINVAL;
7371f44c
MD		 1402 goto register_error;
1403 }
1404 /* Take 2 refs on the module: one per event. */
1405 ret = try_module_get(event->desc->owner);
1406 WARN_ON_ONCE(!ret);
1407 ret = try_module_get(event->desc->owner);
1408 WARN_ON_ONCE(!ret);
0c023c01
MD		 1409
1410 /* Append exit descriptor to counter. */
1411 switch (container->type) {
1412 case LTTNG_EVENT_CONTAINER_COUNTER:
1413 {
1414 struct lttng_counter *counter;
1415 const char *name = "<UNKNOWN>";
1416 int ret;
1417
1418 counter = lttng_event_container_get_counter(container);
1419 if (event_return->key[0])
1420 name = event_return->key;
1421 else
1422 name = event_name;
1423 ret = lttng_counter_append_descriptor(counter,
1424 token, event_return->id,
1425 name);
1426 if (ret) {
1427 WARN_ON_ONCE(1);
1428 }
1429 break;
1430 }
1431 case LTTNG_EVENT_CONTAINER_CHANNEL:
1432 default:
1433 break;
1434 }
1435 switch (container->type) {
1436 case LTTNG_EVENT_CONTAINER_CHANNEL:
1437 ret = _lttng_event_metadata_statedump(session, event_return);
1438 WARN_ON_ONCE(ret > 0);
1439 if (ret) {
1440 kmem_cache_free(event_cache, event_return);
1441 module_put(event->desc->owner);
1442 module_put(event->desc->owner);
1443 goto statedump_error;
1444 }
1445 break;
1446 case LTTNG_EVENT_CONTAINER_COUNTER:
1447 default:
1448 break;
7371f44c 1449 }
0c023c01 1450 list_add(&event_return->list, &session->events);
7371f44c
MD		 1451 break;
1452 }
33a39a3c 1453 case LTTNG_KERNEL_SYSCALL:
a0493bef
MD		 1454 /*
1455 * Needs to be explicitly enabled after creation, since
1456 * we may want to apply filters.
1457 */
1458 event->enabled = 0;
3c997079
MD		 1459 event->registered = 0;
1460 event->desc = event_desc;
badfe9f5
MD		 1461 switch (event_param->u.syscall.entryexit) {
1462 case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
1463 ret = -EINVAL;
1464 goto register_error;
1465 case LTTNG_KERNEL_SYSCALL_ENTRY:
1466 event->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
1467 break;
1468 case LTTNG_KERNEL_SYSCALL_EXIT:
1469 event->u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
1470 break;
1471 }
1472 switch (event_param->u.syscall.abi) {
1473 case LTTNG_KERNEL_SYSCALL_ABI_ALL:
1474 ret = -EINVAL;
1475 goto register_error;
1476 case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
1477 event->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
1478 break;
1479 case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
1480 event->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
1481 break;
1482 }
abc0446a 1483 if (!event->desc) {
4cf0bf51 1484 ret = -EINVAL;
259b6cb3 1485 goto register_error;
abc0446a 1486 }
1ec65de1 1487 break;
149b9a9d 1488 case LTTNG_KERNEL_UPROBE:
a344f64b
FD		 1489 /*
1490 * Needs to be explicitly enabled after creation, since
1491 * we may want to apply filters.
1492 */
1493 event->enabled = 0;
1494 event->registered = 1;
0c023c01 1495 event->u.uprobe.user_token = token;
3aed4dca 1496
a344f64b
FD		 1497 /*
1498 * Populate lttng_event structure before event
1499 * registration.
1500 */
1501 smp_wmb();
149b9a9d 1502
0c023c01 1503 ret = lttng_uprobes_register_event(event_name,
56377c91 1504 event_param->u.uprobe.fd,
149b9a9d
YB		 1505 event);
1506 if (ret)
1507 goto register_error;
1508 ret = try_module_get(event->desc->owner);
1509 WARN_ON_ONCE(!ret);
0c023c01
MD		 1510
1511 /* Append descriptor to counter. */
1512 switch (container->type) {
1513 case LTTNG_EVENT_CONTAINER_COUNTER:
1514 {
1515 struct lttng_counter *counter;
1516 const char *name = "<UNKNOWN>";
1517 int ret;
1518
1519 counter = lttng_event_container_get_counter(container);
1520 if (event->key[0])
1521 name = event->key;
1522 else
1523 name = event_name;
1524 ret = lttng_counter_append_descriptor(counter,
1525 token, event->id,
1526 name);
1527 if (ret) {
1528 WARN_ON_ONCE(1);
1529 }
1530 break;
1531 }
1532 case LTTNG_EVENT_CONTAINER_CHANNEL:
1533 default:
1534 break;
1535 }
149b9a9d 1536 break;
0c023c01
MD		 1537 case LTTNG_KERNEL_FUNCTION: /* Fall-through. */
1538 case LTTNG_KERNEL_NOOP: /* Fall-through.*/
baf20995
MD		 1539 default:
1540 WARN_ON_ONCE(1);
4cf0bf51 1541 ret = -EINVAL;
df07930b 1542 goto register_error;
baf20995 1543 }
0c023c01
MD		 1544 switch (container->type) {
1545 case LTTNG_EVENT_CONTAINER_CHANNEL:
1546 ret = _lttng_event_metadata_statedump(session, event);
1547 WARN_ON_ONCE(ret > 0);
1548 if (ret) {
1549 goto statedump_error;
1550 }
1551 break;
1552 case LTTNG_EVENT_CONTAINER_COUNTER:
1553 default:
1554 break;
abc0446a 1555 }
0c023c01
MD		 1556 hlist_add_head(&event->name_hlist, name_head);
1557 list_add(&event->list, &session->events);
4e3c1b9b
MD		 1558 return event;
1559
c099397a 1560statedump_error:
259b6cb3 1561 /* If a statedump error occurs, events will not be readable. */
11b5a3c2 1562register_error:
0c023c01 1563full:
11b5a3c2 1564 kmem_cache_free(event_cache, event);
4e3c1b9b
MD		 1565cache_error:
1566exist:
3c997079 1567type_error:
4cf0bf51 1568 return ERR_PTR(ret);
4e3c1b9b
MD		 1569}
1570
dffef45d
FD		 1571struct lttng_event_notifier *_lttng_event_notifier_create(
1572 const struct lttng_event_desc *event_desc,
99f52fcc
FD		 1573 uint64_t token, uint64_t error_counter_index,
1574 struct lttng_event_notifier_group *event_notifier_group,
dffef45d
FD		 1575 struct lttng_kernel_event_notifier *event_notifier_param,
1576 void *filter, enum lttng_kernel_instrumentation itype)
1577{
1578 struct lttng_event_notifier *event_notifier;
ab04d7b1 1579 struct lttng_counter *error_counter;
dffef45d
FD		 1580 const char *event_name;
1581 struct hlist_head *head;
1582 int ret;
1583
1584 switch (itype) {
1585 case LTTNG_KERNEL_TRACEPOINT:
b01155ba
FD		 1586 event_name = event_desc->name;
1587 break;
dffef45d 1588 case LTTNG_KERNEL_KPROBE:
9de67196 1589 case LTTNG_KERNEL_UPROBE:
8a8ac9a8 1590 case LTTNG_KERNEL_SYSCALL:
2b16f0c9
FD		 1591 event_name = event_notifier_param->event.name;
1592 break;
dffef45d
FD		 1593 case LTTNG_KERNEL_KRETPROBE:
1594 case LTTNG_KERNEL_FUNCTION:
1595 case LTTNG_KERNEL_NOOP:
dffef45d
FD		 1596 default:
1597 WARN_ON_ONCE(1);
1598 ret = -EINVAL;
1599 goto type_error;
1600 }
1601
1602 head = utils_borrow_hash_table_bucket(event_notifier_group->event_notifiers_ht.table,
1603 LTTNG_EVENT_NOTIFIER_HT_SIZE, event_name);
1604 lttng_hlist_for_each_entry(event_notifier, head, hlist) {
1605 WARN_ON_ONCE(!event_notifier->desc);
1606 if (!strncmp(event_notifier->desc->name, event_name,
1607 LTTNG_KERNEL_SYM_NAME_LEN - 1)
1608 && event_notifier_group == event_notifier->group
1609 && token == event_notifier->user_token) {
1610 ret = -EEXIST;
1611 goto exist;
1612 }
1613 }
1614
1615 event_notifier = kmem_cache_zalloc(event_notifier_cache, GFP_KERNEL);
1616 if (!event_notifier) {
1617 ret = -ENOMEM;
1618 goto cache_error;
1619 }
21f58fb7 1620
dffef45d
FD		 1621 event_notifier->group = event_notifier_group;
1622 event_notifier->user_token = token;
99f52fcc 1623 event_notifier->error_counter_index = error_counter_index;
99d223ad 1624 event_notifier->num_captures = 0;
dffef45d
FD		 1625 event_notifier->filter = filter;
1626 event_notifier->instrumentation = itype;
1627 event_notifier->evtype = LTTNG_TYPE_EVENT;
21f58fb7 1628 event_notifier->send_notification = lttng_event_notifier_notification_send;
183e8b3a 1629 INIT_LIST_HEAD(&event_notifier->filter_bytecode_runtime_head);
99d223ad 1630 INIT_LIST_HEAD(&event_notifier->capture_bytecode_runtime_head);
dffef45d
FD		 1631 INIT_LIST_HEAD(&event_notifier->enablers_ref_head);
1632
1633 switch (itype) {
1634 case LTTNG_KERNEL_TRACEPOINT:
1635 /* Event will be enabled by enabler sync. */
1636 event_notifier->enabled = 0;
1637 event_notifier->registered = 0;
1638 event_notifier->desc = lttng_event_desc_get(event_name);
1639 if (!event_notifier->desc) {
1640 ret = -ENOENT;
1641 goto register_error;
1642 }
1643 /* Populate lttng_event_notifier structure before event registration. */
1644 smp_wmb();
1645 break;
1646 case LTTNG_KERNEL_KPROBE:
2b16f0c9
FD		 1647 /*
1648 * Needs to be explicitly enabled after creation, since
1649 * we may want to apply filters.
1650 */
1651 event_notifier->enabled = 0;
1652 event_notifier->registered = 1;
1653 /*
1654 * Populate lttng_event_notifier structure before event
1655 * registration.
1656 */
1657 smp_wmb();
1658 ret = lttng_kprobes_register_event_notifier(
1659 event_notifier_param->event.u.kprobe.symbol_name,
1660 event_notifier_param->event.u.kprobe.offset,
1661 event_notifier_param->event.u.kprobe.addr,
1662 event_notifier);
1663 if (ret) {
1664 ret = -EINVAL;
1665 goto register_error;
1666 }
1667 ret = try_module_get(event_notifier->desc->owner);
1668 WARN_ON_ONCE(!ret);
1669 break;
8a8ac9a8
FD		 1670 case LTTNG_KERNEL_NOOP:
1671 case LTTNG_KERNEL_SYSCALL:
1672 /*
1673 * Needs to be explicitly enabled after creation, since
1674 * we may want to apply filters.
1675 */
1676 event_notifier->enabled = 0;
1677 event_notifier->registered = 0;
1678 event_notifier->desc = event_desc;
1679 switch (event_notifier_param->event.u.syscall.entryexit) {
1680 case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
1681 ret = -EINVAL;
1682 goto register_error;
1683 case LTTNG_KERNEL_SYSCALL_ENTRY:
1684 event_notifier->u.syscall.entryexit = LTTNG_SYSCALL_ENTRY;
1685 break;
1686 case LTTNG_KERNEL_SYSCALL_EXIT:
1687 event_notifier->u.syscall.entryexit = LTTNG_SYSCALL_EXIT;
1688 break;
1689 }
1690 switch (event_notifier_param->event.u.syscall.abi) {
1691 case LTTNG_KERNEL_SYSCALL_ABI_ALL:
1692 ret = -EINVAL;
1693 goto register_error;
1694 case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
1695 event_notifier->u.syscall.abi = LTTNG_SYSCALL_ABI_NATIVE;
1696 break;
1697 case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
1698 event_notifier->u.syscall.abi = LTTNG_SYSCALL_ABI_COMPAT;
1699 break;
1700 }
1701
1702 if (!event_notifier->desc) {
1703 ret = -EINVAL;
1704 goto register_error;
1705 }
1706 break;
dffef45d 1707 case LTTNG_KERNEL_UPROBE:
9de67196
FD		 1708 /*
1709 * Needs to be explicitly enabled after creation, since
1710 * we may want to apply filters.
1711 */
1712 event_notifier->enabled = 0;
1713 event_notifier->registered = 1;
1714
1715 /*
1716 * Populate lttng_event_notifier structure before
1717 * event_notifier registration.
1718 */
1719 smp_wmb();
1720
1721 ret = lttng_uprobes_register_event_notifier(
1722 event_notifier_param->event.name,
1723 event_notifier_param->event.u.uprobe.fd,
1724 event_notifier);
1725 if (ret)
1726 goto register_error;
1727 ret = try_module_get(event_notifier->desc->owner);
1728 WARN_ON_ONCE(!ret);
1729 break;
dffef45d
FD		 1730 case LTTNG_KERNEL_KRETPROBE:
1731 case LTTNG_KERNEL_FUNCTION:
dffef45d
FD		 1732 default:
1733 WARN_ON_ONCE(1);
1734 ret = -EINVAL;
1735 goto register_error;
1736 }
1737
1738 list_add(&event_notifier->list, &event_notifier_group->event_notifiers_head);
1739 hlist_add_head(&event_notifier->hlist, head);
99f52fcc
FD		 1740
1741 /*
1742 * Clear the error counter bucket. The sessiond keeps track of which
ab04d7b1
MD		 1743 * bucket is currently in use. We trust it. The session lock
1744 * synchronizes against concurrent creation of the error
1745 * counter.
99f52fcc 1746 */
ab04d7b1
MD		 1747 error_counter = event_notifier_group->error_counter;
1748 if (error_counter) {
99f52fcc
FD		 1749 size_t dimension_index[1];
1750
1751 /*
1752 * Check that the index is within the boundary of the counter.
1753 */
1754 if (event_notifier->error_counter_index >= event_notifier_group->error_counter_len) {
1755 printk(KERN_INFO "LTTng: event_notifier: Error counter index out-of-bound: counter-len=%zu, index=%llu\n",
1756 event_notifier_group->error_counter_len, event_notifier->error_counter_index);
1757 ret = -EINVAL;
1758 goto register_error;
1759 }
1760
1761 dimension_index[0] = event_notifier->error_counter_index;
ab04d7b1 1762 ret = error_counter->ops->counter_clear(error_counter->counter, dimension_index);
99f52fcc
FD		 1763 if (ret) {
1764 printk(KERN_INFO "LTTng: event_notifier: Unable to clear error counter bucket %llu\n",
1765 event_notifier->error_counter_index);
1766 goto register_error;
1767 }
1768 }
1769
dffef45d
FD		 1770 return event_notifier;
1771
1772register_error:
1773 kmem_cache_free(event_notifier_cache, event_notifier);
1774cache_error:
1775exist:
1776type_error:
1777 return ERR_PTR(ret);
1778}
1779
99f52fcc
FD		 1780int lttng_kernel_counter_read(struct lttng_counter *counter,
1781 const size_t *dim_indexes, int32_t cpu,
1782 int64_t *val, bool *overflow, bool *underflow)
1783{
1784 return counter->ops->counter_read(counter->counter, dim_indexes,
1785 cpu, val, overflow, underflow);
1786}
1787
1788int lttng_kernel_counter_aggregate(struct lttng_counter *counter,
1789 const size_t *dim_indexes, int64_t *val,
1790 bool *overflow, bool *underflow)
1791{
1792 return counter->ops->counter_aggregate(counter->counter, dim_indexes,
1793 val, overflow, underflow);
1794}
1795
1796int lttng_kernel_counter_clear(struct lttng_counter *counter,
1797 const size_t *dim_indexes)
1798{
1799 return counter->ops->counter_clear(counter->counter, dim_indexes);
1800}
1801
0c023c01 1802struct lttng_event *lttng_event_create(struct lttng_event_container *container,
3c997079 1803 struct lttng_kernel_event *event_param,
0c023c01 1804 const struct lttng_counter_key *key,
3c997079
MD		 1805 void *filter,
1806 const struct lttng_event_desc *event_desc,
0c023c01
MD		 1807 enum lttng_kernel_instrumentation itype,
1808 uint64_t token)
3c997079
MD		 1809{
1810 struct lttng_event *event;
1811
1812 mutex_lock(&sessions_mutex);
0c023c01
MD		 1813 event = _lttng_event_create(container, event_param, key, filter, event_desc,
1814 itype, token);
3c997079
MD		 1815 mutex_unlock(&sessions_mutex);
1816 return event;
1817}
1818
dffef45d
FD		 1819struct lttng_event_notifier *lttng_event_notifier_create(
1820 const struct lttng_event_desc *event_desc,
99f52fcc
FD		 1821 uint64_t id, uint64_t error_counter_index,
1822 struct lttng_event_notifier_group *event_notifier_group,
dffef45d
FD		 1823 struct lttng_kernel_event_notifier *event_notifier_param,
1824 void *filter, enum lttng_kernel_instrumentation itype)
1825{
1826 struct lttng_event_notifier *event_notifier;
1827
1828 mutex_lock(&sessions_mutex);
1829 event_notifier = _lttng_event_notifier_create(event_desc, id,
99f52fcc
FD		 1830 error_counter_index, event_notifier_group,
1831 event_notifier_param, filter, itype);
dffef45d
FD		 1832 mutex_unlock(&sessions_mutex);
1833 return event_notifier;
1834}
1835
3c997079
MD		 1836/* Only used for tracepoints for now. */
1837static
1838void register_event(struct lttng_event *event)
1839{
1840 const struct lttng_event_desc *desc;
f127e61e 1841 int ret = -EINVAL;
3c997079 1842
3c997079
MD		 1843 if (event->registered)
1844 return;
4ecb5ad5 1845
3c997079 1846 desc = event->desc;
4ecb5ad5
MD		 1847 switch (event->instrumentation) {
1848 case LTTNG_KERNEL_TRACEPOINT:
1849 ret = lttng_wrapper_tracepoint_probe_register(desc->kname,
0c023c01 1850 desc->probe_callback, event);
4ecb5ad5
MD		 1851 break;
1852 case LTTNG_KERNEL_SYSCALL:
0c023c01 1853 ret = lttng_syscall_filter_enable_event(event->container, event);
4ecb5ad5
MD		 1854 break;
1855 case LTTNG_KERNEL_KPROBE:
a344f64b 1856 case LTTNG_KERNEL_UPROBE:
4ecb5ad5 1857 case LTTNG_KERNEL_KRETPROBE:
4ecb5ad5
MD		 1858 case LTTNG_KERNEL_NOOP:
1859 ret = 0;
1860 break;
e884017c 1861 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
4ecb5ad5
MD		 1862 default:
1863 WARN_ON_ONCE(1);
1864 }
3c997079
MD		 1865 if (!ret)
1866 event->registered = 1;
1867}
1868
4e3c1b9b
MD		 1869/*
1870 * Only used internally at session destruction.
1871 */
a90917c3 1872int _lttng_event_unregister(struct lttng_event *event)
4e3c1b9b 1873{
4ecb5ad5 1874 const struct lttng_event_desc *desc;
11b5a3c2
MD		 1875 int ret = -EINVAL;
1876
3c997079
MD		 1877 if (!event->registered)
1878 return 0;
1879
4ecb5ad5 1880 desc = event->desc;
38d024ae 1881 switch (event->instrumentation) {
ab2277d6 1882 case LTTNG_KERNEL_TRACEPOINT:
20591cf7 1883 ret = lttng_wrapper_tracepoint_probe_unregister(event->desc->kname,
0c023c01 1884 event->desc->probe_callback, event);
baf20995 1885 break;
ab2277d6 1886 case LTTNG_KERNEL_KPROBE:
8bf17deb 1887 lttng_kprobes_unregister_event(event);
d6d808f3
MD		 1888 ret = 0;
1889 break;
7371f44c
MD		 1890 case LTTNG_KERNEL_KRETPROBE:
1891 lttng_kretprobes_unregister(event);
1892 ret = 0;
1893 break;
33a39a3c 1894 case LTTNG_KERNEL_SYSCALL:
0c023c01 1895 ret = lttng_syscall_filter_disable_event(event->container, event);
4ecb5ad5
MD		 1896 break;
1897 case LTTNG_KERNEL_NOOP:
259b6cb3
MD		 1898 ret = 0;
1899 break;
149b9a9d 1900 case LTTNG_KERNEL_UPROBE:
83b802dc 1901 lttng_uprobes_unregister_event(event);
149b9a9d
YB		 1902 ret = 0;
1903 break;
e884017c 1904 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
baf20995
MD		 1905 default:
1906 WARN_ON_ONCE(1);
1907 }
3c997079
MD		 1908 if (!ret)
1909 event->registered = 0;
dda6a249
MD		 1910 return ret;
1911}
1912
dffef45d
FD		 1913/* Only used for tracepoints for now. */
1914static
b01155ba 1915void register_event_notifier(struct lttng_event_notifier *event_notifier)
dffef45d
FD		 1916{
1917 const struct lttng_event_desc *desc;
1918 int ret = -EINVAL;
1919
1920 if (event_notifier->registered)
1921 return;
1922
1923 desc = event_notifier->desc;
1924 switch (event_notifier->instrumentation) {
1925 case LTTNG_KERNEL_TRACEPOINT:
b01155ba
FD		 1926 ret = lttng_wrapper_tracepoint_probe_register(desc->kname,
1927 desc->event_notifier_callback,
1928 event_notifier);
1929 break;
8a8ac9a8
FD		 1930 case LTTNG_KERNEL_SYSCALL:
1931 ret = lttng_syscall_filter_enable_event_notifier(event_notifier);
1932 break;
dffef45d 1933 case LTTNG_KERNEL_KPROBE:
9de67196 1934 case LTTNG_KERNEL_UPROBE:
2b16f0c9
FD		 1935 ret = 0;
1936 break;
dffef45d
FD		 1937 case LTTNG_KERNEL_KRETPROBE:
1938 case LTTNG_KERNEL_FUNCTION:
1939 case LTTNG_KERNEL_NOOP:
1940 default:
1941 WARN_ON_ONCE(1);
1942 }
1943 if (!ret)
1944 event_notifier->registered = 1;
1945}
1946
1947static
1948int _lttng_event_notifier_unregister(
1949 struct lttng_event_notifier *event_notifier)
1950{
1951 const struct lttng_event_desc *desc;
1952 int ret = -EINVAL;
1953
1954 if (!event_notifier->registered)
1955 return 0;
1956
1957 desc = event_notifier->desc;
1958 switch (event_notifier->instrumentation) {
1959 case LTTNG_KERNEL_TRACEPOINT:
b01155ba
FD		 1960 ret = lttng_wrapper_tracepoint_probe_unregister(event_notifier->desc->kname,
1961 event_notifier->desc->event_notifier_callback,
1962 event_notifier);
1963 break;
dffef45d 1964 case LTTNG_KERNEL_KPROBE:
2b16f0c9
FD		 1965 lttng_kprobes_unregister_event_notifier(event_notifier);
1966 ret = 0;
1967 break;
9de67196
FD		 1968 case LTTNG_KERNEL_UPROBE:
1969 lttng_uprobes_unregister_event_notifier(event_notifier);
1970 ret = 0;
1971 break;
8a8ac9a8
FD		 1972 case LTTNG_KERNEL_SYSCALL:
1973 ret = lttng_syscall_filter_disable_event_notifier(event_notifier);
1974 break;
dffef45d
FD		 1975 case LTTNG_KERNEL_KRETPROBE:
1976 case LTTNG_KERNEL_FUNCTION:
dffef45d 1977 case LTTNG_KERNEL_NOOP:
dffef45d
FD		 1978 default:
1979 WARN_ON_ONCE(1);
1980 }
1981 if (!ret)
1982 event_notifier->registered = 0;
1983 return ret;
1984}
1985
dda6a249
MD		 1986/*
1987 * Only used internally at session destruction.
1988 */
be066e6c 1989static
a90917c3 1990void _lttng_event_destroy(struct lttng_event *event)
dda6a249 1991{
966ad253
MD		 1992 struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
1993
edeb3137
MD		 1994 switch (event->instrumentation) {
1995 case LTTNG_KERNEL_TRACEPOINT:
0bcedee9 1996 lttng_event_desc_put(event->desc);
edeb3137
MD		 1997 break;
1998 case LTTNG_KERNEL_KPROBE:
1999 module_put(event->desc->owner);
8bf17deb 2000 lttng_kprobes_destroy_event_private(event);
edeb3137 2001 break;
7371f44c
MD		 2002 case LTTNG_KERNEL_KRETPROBE:
2003 module_put(event->desc->owner);
2004 lttng_kretprobes_destroy_private(event);
2005 break;
259b6cb3 2006 case LTTNG_KERNEL_NOOP:
33a39a3c 2007 case LTTNG_KERNEL_SYSCALL:
259b6cb3 2008 break;
149b9a9d
YB		 2009 case LTTNG_KERNEL_UPROBE:
2010 module_put(event->desc->owner);
83b802dc 2011 lttng_uprobes_destroy_event_private(event);
149b9a9d 2012 break;
e884017c 2013 case LTTNG_KERNEL_FUNCTION: /* Fall-through */
edeb3137
MD		 2014 default:
2015 WARN_ON_ONCE(1);
2016 }
dda6a249 2017 list_del(&event->list);
8070f5c0 2018 lttng_destroy_context(event->ctx);
966ad253
MD		 2019 lttng_free_event_filter_runtime(event);
2020 /* Free event enabler refs */
2021 list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
2022 &event->enablers_ref_head, node)
2023 kfree(enabler_ref);
11b5a3c2 2024 kmem_cache_free(event_cache, event);
4e3c1b9b
MD		 2025}
2026
dffef45d
FD		 2027/*
2028 * Only used internally at session destruction.
2029 */
2030static
2031void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier)
2032{
3ef5cc03
MD		 2033 struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
2034
dffef45d
FD		 2035 switch (event_notifier->instrumentation) {
2036 case LTTNG_KERNEL_TRACEPOINT:
b01155ba
FD		 2037 lttng_event_desc_put(event_notifier->desc);
2038 break;
dffef45d 2039 case LTTNG_KERNEL_KPROBE:
2b16f0c9
FD		 2040 module_put(event_notifier->desc->owner);
2041 lttng_kprobes_destroy_event_notifier_private(event_notifier);
2042 break;
8a8ac9a8
FD		 2043 case LTTNG_KERNEL_NOOP:
2044 case LTTNG_KERNEL_SYSCALL:
2045 break;
9de67196
FD		 2046 case LTTNG_KERNEL_UPROBE:
2047 module_put(event_notifier->desc->owner);
2048 lttng_uprobes_destroy_event_notifier_private(event_notifier);
2049 break;
dffef45d
FD		 2050 case LTTNG_KERNEL_KRETPROBE:
2051 case LTTNG_KERNEL_FUNCTION:
dffef45d
FD		 2052 default:
2053 WARN_ON_ONCE(1);
2054 }
2055 list_del(&event_notifier->list);
3ef5cc03
MD		 2056 lttng_free_event_notifier_filter_runtime(event_notifier);
2057 /* Free event enabler refs */
2058 list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
2059 &event_notifier->enablers_ref_head, node)
2060 kfree(enabler_ref);
dffef45d
FD		 2061 kmem_cache_free(event_notifier_cache, event_notifier);
2062}
2063
d1f652f8
MD		 2064struct lttng_id_tracker *get_tracker(struct lttng_session *session,
2065 enum tracker_type tracker_type)
e0130fab 2066{
d1f652f8
MD		 2067 switch (tracker_type) {
2068 case TRACKER_PID:
2069 return &session->pid_tracker;
2070 case TRACKER_VPID:
2071 return &session->vpid_tracker;
2072 case TRACKER_UID:
2073 return &session->uid_tracker;
2074 case TRACKER_VUID:
2075 return &session->vuid_tracker;
2076 case TRACKER_GID:
2077 return &session->gid_tracker;
2078 case TRACKER_VGID:
2079 return &session->vgid_tracker;
2080 default:
2081 WARN_ON_ONCE(1);
2082 return NULL;
2083 }
2084}
2085
2086int lttng_session_track_id(struct lttng_session *session,
2087 enum tracker_type tracker_type, int id)
2088{
2089 struct lttng_id_tracker *tracker;
e0130fab
MD		 2090 int ret;
2091
d1f652f8
MD		 2092 tracker = get_tracker(session, tracker_type);
2093 if (!tracker)
2094 return -EINVAL;
2095 if (id < -1)
e0130fab
MD		 2096 return -EINVAL;
2097 mutex_lock(&sessions_mutex);
d1f652f8
MD		 2098 if (id == -1) {
2099 /* track all ids: destroy tracker. */
2100 lttng_id_tracker_destroy(tracker, true);
e0130fab
MD		 2101 ret = 0;
2102 } else {
d1f652f8 2103 ret = lttng_id_tracker_add(tracker, id);
e0130fab 2104 }
e0130fab
MD		 2105 mutex_unlock(&sessions_mutex);
2106 return ret;
2107}
2108
d1f652f8
MD		 2109int lttng_session_untrack_id(struct lttng_session *session,
2110 enum tracker_type tracker_type, int id)
e0130fab 2111{
d1f652f8 2112 struct lttng_id_tracker *tracker;
e0130fab
MD		 2113 int ret;
2114
d1f652f8
MD		 2115 tracker = get_tracker(session, tracker_type);
2116 if (!tracker)
2117 return -EINVAL;
2118 if (id < -1)
e0130fab
MD		 2119 return -EINVAL;
2120 mutex_lock(&sessions_mutex);
d1f652f8
MD		 2121 if (id == -1) {
2122 /* untrack all ids: replace by empty tracker. */
2123 ret = lttng_id_tracker_empty_set(tracker);
e0130fab 2124 } else {
d1f652f8 2125 ret = lttng_id_tracker_del(tracker, id);
e0130fab 2126 }
e0130fab
MD		 2127 mutex_unlock(&sessions_mutex);
2128 return ret;
2129}
2130
7e6f9ef6 2131static
d1f652f8 2132void *id_list_start(struct seq_file *m, loff_t *pos)
7e6f9ef6 2133{
d1f652f8
MD		 2134 struct lttng_id_tracker *id_tracker = m->private;
2135 struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
2136 struct lttng_id_hash_node *e;
7e6f9ef6
MD		 2137 int iter = 0, i;
2138
2139 mutex_lock(&sessions_mutex);
d1f652f8
MD		 2140 if (id_tracker_p) {
2141 for (i = 0; i < LTTNG_ID_TABLE_SIZE; i++) {
2142 struct hlist_head *head = &id_tracker_p->id_hash[i];
7e6f9ef6 2143
f934e302 2144 lttng_hlist_for_each_entry(e, head, hlist) {
7e6f9ef6
MD		 2145 if (iter++ >= *pos)
2146 return e;
2147 }
2148 }
2149 } else {
d1f652f8 2150 /* ID tracker disabled. */
7e6f9ef6 2151 if (iter >= *pos && iter == 0) {
d1f652f8 2152 return id_tracker_p; /* empty tracker */
7e6f9ef6
MD		 2153 }
2154 iter++;
2155 }
2156 /* End of list */
2157 return NULL;
2158}
2159
2160/* Called with sessions_mutex held. */
2161static
d1f652f8 2162void *id_list_next(struct seq_file *m, void *p, loff_t *ppos)
7e6f9ef6 2163{
d1f652f8
MD		 2164 struct lttng_id_tracker *id_tracker = m->private;
2165 struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
2166 struct lttng_id_hash_node *e;
7e6f9ef6
MD		 2167 int iter = 0, i;
2168
2169 (*ppos)++;
d1f652f8
MD		 2170 if (id_tracker_p) {
2171 for (i = 0; i < LTTNG_ID_TABLE_SIZE; i++) {
2172 struct hlist_head *head = &id_tracker_p->id_hash[i];
7e6f9ef6 2173
f934e302 2174 lttng_hlist_for_each_entry(e, head, hlist) {
7e6f9ef6
MD		 2175 if (iter++ >= *ppos)
2176 return e;
2177 }
2178 }
2179 } else {
d1f652f8 2180 /* ID tracker disabled. */
7e6f9ef6 2181 if (iter >= *ppos && iter == 0)
d1f652f8 2182 return p; /* empty tracker */
7e6f9ef6
MD		 2183 iter++;
2184 }
2185
2186 /* End of list */
2187 return NULL;
2188}
2189
2190static
d1f652f8 2191void id_list_stop(struct seq_file *m, void *p)
7e6f9ef6
MD		 2192{
2193 mutex_unlock(&sessions_mutex);
2194}
2195
2196static
d1f652f8 2197int id_list_show(struct seq_file *m, void *p)
7e6f9ef6 2198{
d1f652f8
MD		 2199 struct lttng_id_tracker *id_tracker = m->private;
2200 struct lttng_id_tracker_rcu *id_tracker_p = id_tracker->p;
2201 int id;
7e6f9ef6 2202
d1f652f8 2203 if (p == id_tracker_p) {
7e6f9ef6 2204 /* Tracker disabled. */
d1f652f8 2205 id = -1;
7e6f9ef6 2206 } else {
d1f652f8 2207 const struct lttng_id_hash_node *e = p;
7e6f9ef6 2208
d1f652f8
MD		 2209 id = lttng_id_tracker_get_node_id(e);
2210 }
2211 switch (id_tracker->tracker_type) {
2212 case TRACKER_PID:
2213 seq_printf(m, "process { pid = %d; };\n", id);
2214 break;
2215 case TRACKER_VPID:
2216 seq_printf(m, "process { vpid = %d; };\n", id);
2217 break;
2218 case TRACKER_UID:
2219 seq_printf(m, "user { uid = %d; };\n", id);
2220 break;
2221 case TRACKER_VUID:
2222 seq_printf(m, "user { vuid = %d; };\n", id);
2223 break;
2224 case TRACKER_GID:
2225 seq_printf(m, "group { gid = %d; };\n", id);
2226 break;
2227 case TRACKER_VGID:
2228 seq_printf(m, "group { vgid = %d; };\n", id);
2229 break;
2230 default:
2231 seq_printf(m, "UNKNOWN { field = %d };\n", id);
7e6f9ef6 2232 }
7e6f9ef6
MD		 2233 return 0;
2234}
2235
2236static
d1f652f8
MD		 2237const struct seq_operations lttng_tracker_ids_list_seq_ops = {
2238 .start = id_list_start,
2239 .next = id_list_next,
2240 .stop = id_list_stop,
2241 .show = id_list_show,
7e6f9ef6
MD		 2242};
2243
2244static
d1f652f8 2245int lttng_tracker_ids_list_open(struct inode *inode, struct file *file)
7e6f9ef6 2246{
d1f652f8 2247 return seq_open(file, &lttng_tracker_ids_list_seq_ops);
7e6f9ef6
MD		 2248}
2249
2250static
d1f652f8 2251int lttng_tracker_ids_list_release(struct inode *inode, struct file *file)
7e6f9ef6
MD		 2252{
2253 struct seq_file *m = file->private_data;
d1f652f8 2254 struct lttng_id_tracker *id_tracker = m->private;
7e6f9ef6
MD		 2255 int ret;
2256
d1f652f8 2257 WARN_ON_ONCE(!id_tracker);
7e6f9ef6 2258 ret = seq_release(inode, file);
d1f652f8
MD		 2259 if (!ret)
2260 fput(id_tracker->session->file);
7e6f9ef6
MD		 2261 return ret;
2262}
2263
d1f652f8 2264const struct file_operations lttng_tracker_ids_list_fops = {
7e6f9ef6 2265 .owner = THIS_MODULE,
d1f652f8 2266 .open = lttng_tracker_ids_list_open,
7e6f9ef6
MD		 2267 .read = seq_read,
2268 .llseek = seq_lseek,
d1f652f8 2269 .release = lttng_tracker_ids_list_release,
7e6f9ef6
MD		 2270};
2271
d1f652f8
MD		 2272int lttng_session_list_tracker_ids(struct lttng_session *session,
2273 enum tracker_type tracker_type)
7e6f9ef6 2274{
d1f652f8 2275 struct file *tracker_ids_list_file;
7e6f9ef6
MD		 2276 struct seq_file *m;
2277 int file_fd, ret;
2278
2279 file_fd = lttng_get_unused_fd();
2280 if (file_fd < 0) {
2281 ret = file_fd;
2282 goto fd_error;
2283 }
2284
d1f652f8
MD		 2285 tracker_ids_list_file = anon_inode_getfile("[lttng_tracker_ids_list]",
2286 &lttng_tracker_ids_list_fops,
7e6f9ef6 2287 NULL, O_RDWR);
d1f652f8
MD		 2288 if (IS_ERR(tracker_ids_list_file)) {
2289 ret = PTR_ERR(tracker_ids_list_file);
7e6f9ef6
MD		 2290 goto file_error;
2291 }
98d7281c
MJ		 2292 if (!atomic_long_add_unless(&session->file->f_count, 1, LONG_MAX)) {
2293 ret = -EOVERFLOW;
9c1f4643
MD		 2294 goto refcount_error;
2295 }
d1f652f8 2296 ret = lttng_tracker_ids_list_fops.open(NULL, tracker_ids_list_file);
7e6f9ef6
MD		 2297 if (ret < 0)
2298 goto open_error;
d1f652f8
MD		 2299 m = tracker_ids_list_file->private_data;
2300
2301 m->private = get_tracker(session, tracker_type);
2302 BUG_ON(!m->private);
2303 fd_install(file_fd, tracker_ids_list_file);
7e6f9ef6
MD		 2304
2305 return file_fd;
2306
2307open_error:
9c1f4643
MD		 2308 atomic_long_dec(&session->file->f_count);
2309refcount_error:
d1f652f8 2310 fput(tracker_ids_list_file);
7e6f9ef6
MD		 2311file_error:
2312 put_unused_fd(file_fd);
2313fd_error:
2314 return ret;
2315}
2316
3c997079
MD		 2317/*
2318 * Enabler management.
2319 */
2320static
4993071a
PP		 2321int lttng_match_enabler_star_glob(const char *desc_name,
2322 const char *pattern)
3c997079 2323{
cbc19040
MD		 2324 if (!strutils_star_glob_match(pattern, LTTNG_SIZE_MAX,
2325 desc_name, LTTNG_SIZE_MAX))
3c997079
MD		 2326 return 0;
2327 return 1;
2328}
2329
2330static
4ecb5ad5
MD		 2331int lttng_match_enabler_name(const char *desc_name,
2332 const char *name)
3c997079 2333{
4ecb5ad5 2334 if (strcmp(desc_name, name))
3c997079
MD		 2335 return 0;
2336 return 1;
2337}
2338
3c997079
MD		 2339int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
2340 struct lttng_enabler *enabler)
2341{
4ecb5ad5 2342 const char *desc_name, *enabler_name;
badfe9f5 2343 bool compat = false, entry = false;
4ecb5ad5
MD		 2344
2345 enabler_name = enabler->event_param.name;
2346 switch (enabler->event_param.instrumentation) {
2347 case LTTNG_KERNEL_TRACEPOINT:
2348 desc_name = desc->name;
3b861b22
FD		 2349 switch (enabler->format_type) {
2350 case LTTNG_ENABLER_FORMAT_STAR_GLOB:
badfe9f5 2351 return lttng_match_enabler_star_glob(desc_name, enabler_name);
3b861b22 2352 case LTTNG_ENABLER_FORMAT_NAME:
badfe9f5
MD		 2353 return lttng_match_enabler_name(desc_name, enabler_name);
2354 default:
2355 return -EINVAL;
2356 }
4ecb5ad5
MD		 2357 break;
2358 case LTTNG_KERNEL_SYSCALL:
2359 desc_name = desc->name;
badfe9f5 2360 if (!strncmp(desc_name, "compat_", strlen("compat_"))) {
4ecb5ad5 2361 desc_name += strlen("compat_");
badfe9f5
MD		 2362 compat = true;
2363 }
4ecb5ad5
MD		 2364 if (!strncmp(desc_name, "syscall_exit_",
2365 strlen("syscall_exit_"))) {
2366 desc_name += strlen("syscall_exit_");
2367 } else if (!strncmp(desc_name, "syscall_entry_",
2368 strlen("syscall_entry_"))) {
2369 desc_name += strlen("syscall_entry_");
badfe9f5 2370 entry = true;
4ecb5ad5
MD		 2371 } else {
2372 WARN_ON_ONCE(1);
2373 return -EINVAL;
2374 }
badfe9f5
MD		 2375 switch (enabler->event_param.u.syscall.entryexit) {
2376 case LTTNG_KERNEL_SYSCALL_ENTRYEXIT:
2377 break;
2378 case LTTNG_KERNEL_SYSCALL_ENTRY:
2379 if (!entry)
2380 return 0;
2381 break;
2382 case LTTNG_KERNEL_SYSCALL_EXIT:
2383 if (entry)
2384 return 0;
2385 break;
2386 default:
2387 return -EINVAL;
2388 }
2389 switch (enabler->event_param.u.syscall.abi) {
2390 case LTTNG_KERNEL_SYSCALL_ABI_ALL:
2391 break;
2392 case LTTNG_KERNEL_SYSCALL_ABI_NATIVE:
2393 if (compat)
2394 return 0;
2395 break;
2396 case LTTNG_KERNEL_SYSCALL_ABI_COMPAT:
2397 if (!compat)
2398 return 0;
2399 break;
2400 default:
2401 return -EINVAL;
2402 }
2403 switch (enabler->event_param.u.syscall.match) {
cff6938b 2404 case LTTNG_KERNEL_SYSCALL_MATCH_NAME:
3b861b22
FD		 2405 switch (enabler->format_type) {
2406 case LTTNG_ENABLER_FORMAT_STAR_GLOB:
badfe9f5 2407 return lttng_match_enabler_star_glob(desc_name, enabler_name);
3b861b22 2408 case LTTNG_ENABLER_FORMAT_NAME:
badfe9f5
MD		 2409 return lttng_match_enabler_name(desc_name, enabler_name);
2410 default:
2411 return -EINVAL;
2412 }
2413 break;
cff6938b 2414 case LTTNG_KERNEL_SYSCALL_MATCH_NR:
badfe9f5
MD		 2415 return -EINVAL; /* Not implemented. */
2416 default:
2417 return -EINVAL;
2418 }
4ecb5ad5
MD		 2419 break;
2420 default:
2421 WARN_ON_ONCE(1);
2422 return -EINVAL;
2423 }
3c997079
MD		 2424}
2425
2426static
0c023c01 2427bool lttng_event_enabler_match_event(struct lttng_event_enabler *event_enabler,
b2bc0bc8 2428 struct lttng_event *event)
3c997079 2429{
b2bc0bc8
FD		 2430 struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler(
2431 event_enabler);
2432
0c023c01
MD		 2433 if (base_enabler->event_param.instrumentation == event->instrumentation
2434 && lttng_desc_match_enabler(event->desc, base_enabler) > 0
2435 && event->container == event_enabler->container
2436 && match_event_token(event->container, event, event_enabler->base.user_token))
2437 return true;
3c997079 2438 else
0c023c01 2439 return false;
3c997079
MD		 2440}
2441
b01155ba
FD		 2442static
2443int lttng_event_notifier_enabler_match_event_notifier(struct lttng_event_notifier_enabler *event_notifier_enabler,
2444 struct lttng_event_notifier *event_notifier)
2445{
2446 struct lttng_enabler *base_enabler = lttng_event_notifier_enabler_as_enabler(
2447 event_notifier_enabler);
2448
2449 if (base_enabler->event_param.instrumentation != event_notifier->instrumentation)
2450 return 0;
0c023c01 2451 if (lttng_desc_match_enabler(event_notifier->desc, base_enabler) > 0
b01155ba
FD		 2452 && event_notifier->group == event_notifier_enabler->group
2453 && event_notifier->user_token == event_notifier_enabler->base.user_token)
2454 return 1;
2455 else
2456 return 0;
2457}
2458
3c997079 2459static
b2bc0bc8
FD		 2460struct lttng_enabler_ref *lttng_enabler_ref(
2461 struct list_head *enablers_ref_list,
3c997079
MD		 2462 struct lttng_enabler *enabler)
2463{
2464 struct lttng_enabler_ref *enabler_ref;
2465
b2bc0bc8 2466 list_for_each_entry(enabler_ref, enablers_ref_list, node) {
3c997079
MD		 2467 if (enabler_ref->ref == enabler)
2468 return enabler_ref;
2469 }
2470 return NULL;
2471}
2472
3c997079 2473static
1b917d6b 2474void lttng_create_tracepoint_event_if_missing(struct lttng_event_enabler *event_enabler)
3c997079 2475{
3c997079
MD		 2476 struct lttng_probe_desc *probe_desc;
2477 const struct lttng_event_desc *desc;
2478 int i;
2479 struct list_head *probe_list;
2480
2481 probe_list = lttng_get_probe_list_head();
2482 /*
2483 * For each probe event, if we find that a probe event matches
2484 * our enabler, create an associated lttng_event if not
2485 * already present.
2486 */
2487 list_for_each_entry(probe_desc, probe_list, head) {
2488 for (i = 0; i < probe_desc->nr_events; i++) {
3c997079
MD		 2489 struct lttng_event *event;
2490
2491 desc = probe_desc->event_desc[i];
0c023c01
MD		 2492 if (lttng_desc_match_enabler(desc,
2493 lttng_event_enabler_as_enabler(event_enabler)) <= 0)
3c997079 2494 continue;
3c997079 2495
0c023c01
MD		 2496 /* Try to create an event for this event probe. */
2497 event = _lttng_event_create(event_enabler->container,
2498 NULL, &event_enabler->key, NULL, desc,
2499 LTTNG_KERNEL_TRACEPOINT,
2500 event_enabler->base.user_token);
2501 /* Skip if event is already found. */
2502 if (IS_ERR(event) && PTR_ERR(event) == -EEXIST)
3c997079 2503 continue;
0c023c01 2504 if (IS_ERR(event)) {
5a15f70c 2505 printk(KERN_INFO "LTTng: Unable to create event %s\n",
3c997079
MD		 2506 probe_desc->event_desc[i]->name);
2507 }
2508 }
2509 }
2510}
2511
b01155ba
FD		 2512static
2513void lttng_create_tracepoint_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler)
2514{
2515 struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
2516 struct lttng_probe_desc *probe_desc;
2517 const struct lttng_event_desc *desc;
2518 int i;
2519 struct list_head *probe_list;
2520
2521 probe_list = lttng_get_probe_list_head();
2522 /*
2523 * For each probe event, if we find that a probe event matches
2524 * our enabler, create an associated lttng_event_notifier if not
2525 * already present.
2526 */
2527 list_for_each_entry(probe_desc, probe_list, head) {
2528 for (i = 0; i < probe_desc->nr_events; i++) {
2529 int found = 0;
2530 struct hlist_head *head;
2531 struct lttng_event_notifier *event_notifier;
2532
2533 desc = probe_desc->event_desc[i];
0c023c01
MD		 2534 if (lttng_desc_match_enabler(desc,
2535 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)) <= 0)
b01155ba
FD		 2536 continue;
2537
2538 /*
2539 * Check if already created.
2540 */
2541 head = utils_borrow_hash_table_bucket(
2542 event_notifier_group->event_notifiers_ht.table,
2543 LTTNG_EVENT_NOTIFIER_HT_SIZE, desc->name);
2544 lttng_hlist_for_each_entry(event_notifier, head, hlist) {
2545 if (event_notifier->desc == desc
2546 && event_notifier->user_token == event_notifier_enabler->base.user_token)
2547 found = 1;
2548 }
2549 if (found)
2550 continue;
2551
2552 /*
2553 * We need to create a event_notifier for this event probe.
2554 */
2555 event_notifier = _lttng_event_notifier_create(desc,
2556 event_notifier_enabler->base.user_token,
99f52fcc 2557 event_notifier_enabler->error_counter_index,
b01155ba
FD		 2558 event_notifier_group, NULL, NULL,
2559 LTTNG_KERNEL_TRACEPOINT);
2560 if (IS_ERR(event_notifier)) {
2561 printk(KERN_INFO "Unable to create event_notifier %s\n",
2562 probe_desc->event_desc[i]->name);
2563 }
2564 }
2565 }
2566}
2567
33a39a3c 2568static
1b917d6b 2569void lttng_create_syscall_event_if_missing(struct lttng_event_enabler *event_enabler)
33a39a3c
MD		 2570{
2571 int ret;
2572
3b82c4e1 2573 ret = lttng_syscalls_register_event(event_enabler, NULL);
33a39a3c
MD		 2574 WARN_ON_ONCE(ret);
2575}
2576
8a8ac9a8
FD		 2577static
2578void lttng_create_syscall_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler)
2579{
2580 int ret;
2581
2582 ret = lttng_syscalls_register_event_notifier(event_notifier_enabler, NULL);
2583 WARN_ON_ONCE(ret);
2584 ret = lttng_syscals_create_matching_event_notifiers(event_notifier_enabler, NULL);
2585 WARN_ON_ONCE(ret);
2586}
2587
33a39a3c
MD		 2588/*
2589 * Create struct lttng_event if it is missing and present in the list of
2590 * tracepoint probes.
2591 * Should be called with sessions mutex held.
2592 */
2593static
b2bc0bc8 2594void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler)
33a39a3c 2595{
b2bc0bc8 2596 switch (event_enabler->base.event_param.instrumentation) {
33a39a3c 2597 case LTTNG_KERNEL_TRACEPOINT:
1b917d6b 2598 lttng_create_tracepoint_event_if_missing(event_enabler);
33a39a3c
MD		 2599 break;
2600 case LTTNG_KERNEL_SYSCALL:
1b917d6b 2601 lttng_create_syscall_event_if_missing(event_enabler);
33a39a3c
MD		 2602 break;
2603 default:
2604 WARN_ON_ONCE(1);
2605 break;
2606 }
2607}
2608
3c997079 2609/*
b2bc0bc8 2610 * Create events associated with an event_enabler (if not already present),
3c997079
MD		 2611 * and add backward reference from the event to the enabler.
2612 * Should be called with sessions mutex held.
2613 */
2614static
b2bc0bc8 2615int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
3c997079 2616{
0c023c01
MD		 2617 struct lttng_event_container *container = event_enabler->container;
2618 struct lttng_session *session = container->session;
b2bc0bc8 2619 struct lttng_enabler *base_enabler = lttng_event_enabler_as_enabler(event_enabler);
3c997079
MD		 2620 struct lttng_event *event;
2621
b2bc0bc8 2622 if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL &&
b2bc0bc8 2623 base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL &&
cff6938b 2624 base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_SYSCALL_MATCH_NAME &&
b2bc0bc8 2625 !strcmp(base_enabler->event_param.name, "*")) {
3b82c4e1
MD		 2626 int enabled = base_enabler->enabled;
2627 enum lttng_kernel_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit;
2628
2629 if (entryexit == LTTNG_KERNEL_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT)
0c023c01 2630 WRITE_ONCE(container->syscall_all_entry, enabled);
3b82c4e1
MD		 2631
2632 if (entryexit == LTTNG_KERNEL_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT)
0c023c01 2633 WRITE_ONCE(container->syscall_all_exit, enabled);
badfe9f5
MD		 2634 }
2635
3c997079 2636 /* First ensure that probe events are created for this enabler. */
b2bc0bc8 2637 lttng_create_event_if_missing(event_enabler);
3c997079 2638
b2bc0bc8 2639 /* For each event matching event_enabler in session event list. */
3c997079
MD		 2640 list_for_each_entry(event, &session->events, list) {
2641 struct lttng_enabler_ref *enabler_ref;
2642
b2bc0bc8 2643 if (!lttng_event_enabler_match_event(event_enabler, event))
3c997079 2644 continue;
b2bc0bc8
FD		 2645 enabler_ref = lttng_enabler_ref(&event->enablers_ref_head,
2646 lttng_event_enabler_as_enabler(event_enabler));
3c997079
MD		 2647 if (!enabler_ref) {
2648 /*
2649 * If no backward ref, create it.
b2bc0bc8 2650 * Add backward ref from event to event_enabler.
3c997079
MD		 2651 */
2652 enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
2653 if (!enabler_ref)
2654 return -ENOMEM;
b2bc0bc8 2655 enabler_ref->ref = lttng_event_enabler_as_enabler(event_enabler);
3c997079
MD		 2656 list_add(&enabler_ref->node,
2657 &event->enablers_ref_head);
0c023c01
MD		 2658 /* Append descriptor to counter. */
2659 switch (container->type) {
2660 case LTTNG_EVENT_CONTAINER_COUNTER:
2661 {
2662 struct lttng_counter *counter;
2663 const char *name = "<UNKNOWN>";
2664 int ret;
2665
2666 counter = lttng_event_container_get_counter(container);
2667 if (event->key[0])
2668 name = event->key;
2669 else if (event->desc && event->desc->name)
2670 name = event->desc->name;
2671 ret = lttng_counter_append_descriptor(counter,
2672 event_enabler->base.user_token, event->id,
2673 name);
2674 if (ret) {
2675 WARN_ON_ONCE(1);
2676 return ret;
2677 }
2678 break;
2679 }
2680 case LTTNG_EVENT_CONTAINER_CHANNEL:
2681 default:
2682 break;
2683 }
3c997079
MD		 2684 }
2685
f127e61e
MD		 2686 /*
2687 * Link filter bytecodes if not linked yet.
2688 */
2dfda770
FD		 2689 lttng_enabler_link_bytecode(event->desc,
2690 lttng_static_ctx,
183e8b3a 2691 &event->filter_bytecode_runtime_head,
60206944 2692 &lttng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head);
f127e61e 2693
3c997079
MD		 2694 /* TODO: merge event context. */
2695 }
2696 return 0;
2697}
2698
b01155ba
FD		 2699/*
2700 * Create struct lttng_event_notifier if it is missing and present in the list of
2701 * tracepoint probes.
2702 * Should be called with sessions mutex held.
2703 */
2704static
2705void lttng_create_event_notifier_if_missing(struct lttng_event_notifier_enabler *event_notifier_enabler)
2706{
2707 switch (event_notifier_enabler->base.event_param.instrumentation) {
2708 case LTTNG_KERNEL_TRACEPOINT:
2709 lttng_create_tracepoint_event_notifier_if_missing(event_notifier_enabler);
2710 break;
8a8ac9a8
FD		 2711 case LTTNG_KERNEL_SYSCALL:
2712 lttng_create_syscall_event_notifier_if_missing(event_notifier_enabler);
2713 break;
b01155ba
FD		 2714 default:
2715 WARN_ON_ONCE(1);
2716 break;
2717 }
2718}
2719
2720/*
2721 * Create event_notifiers associated with a event_notifier enabler (if not already present).
2722 */
2723static
8a8ac9a8
FD		 2724int lttng_event_notifier_enabler_ref_event_notifiers(
2725 struct lttng_event_notifier_enabler *event_notifier_enabler)
b01155ba
FD		 2726{
2727 struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
8a8ac9a8 2728 struct lttng_enabler *base_enabler = lttng_event_notifier_enabler_as_enabler(event_notifier_enabler);
b01155ba
FD		 2729 struct lttng_event_notifier *event_notifier;
2730
8a8ac9a8
FD		 2731 if (base_enabler->event_param.instrumentation == LTTNG_KERNEL_SYSCALL &&
2732 base_enabler->event_param.u.syscall.abi == LTTNG_KERNEL_SYSCALL_ABI_ALL &&
2733 base_enabler->event_param.u.syscall.match == LTTNG_KERNEL_SYSCALL_MATCH_NAME &&
2734 !strcmp(base_enabler->event_param.name, "*")) {
2735
2736 int enabled = base_enabler->enabled;
2737 enum lttng_kernel_syscall_entryexit entryexit = base_enabler->event_param.u.syscall.entryexit;
2738
2739 if (entryexit == LTTNG_KERNEL_SYSCALL_ENTRY || entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT)
2740 WRITE_ONCE(event_notifier_group->syscall_all_entry, enabled);
2741
2742 if (entryexit == LTTNG_KERNEL_SYSCALL_EXIT || entryexit == LTTNG_KERNEL_SYSCALL_ENTRYEXIT)
2743 WRITE_ONCE(event_notifier_group->syscall_all_exit, enabled);
2744
2745 }
2746
b01155ba
FD		 2747 /* First ensure that probe event_notifiers are created for this enabler. */
2748 lttng_create_event_notifier_if_missing(event_notifier_enabler);
2749
2750 /* Link the created event_notifier with its associated enabler. */
2751 list_for_each_entry(event_notifier, &event_notifier_group->event_notifiers_head, list) {
2752 struct lttng_enabler_ref *enabler_ref;
2753
2754 if (!lttng_event_notifier_enabler_match_event_notifier(event_notifier_enabler, event_notifier))
2755 continue;
2756
2757 enabler_ref = lttng_enabler_ref(&event_notifier->enablers_ref_head,
2758 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
2759 if (!enabler_ref) {
2760 /*
2761 * If no backward ref, create it.
2762 * Add backward ref from event_notifier to enabler.
2763 */
2764 enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
2765 if (!enabler_ref)
2766 return -ENOMEM;
2767
2768 enabler_ref->ref = lttng_event_notifier_enabler_as_enabler(
2769 event_notifier_enabler);
2770 list_add(&enabler_ref->node,
2771 &event_notifier->enablers_ref_head);
2772 }
2773
2774 /*
2775 * Link filter bytecodes if not linked yet.
2776 */
2777 lttng_enabler_link_bytecode(event_notifier->desc,
183e8b3a 2778 lttng_static_ctx, &event_notifier->filter_bytecode_runtime_head,
60206944 2779 &lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head);
99d223ad
FD		 2780
2781 /* Link capture bytecodes if not linked yet. */
2782 lttng_enabler_link_bytecode(event_notifier->desc,
2783 lttng_static_ctx, &event_notifier->capture_bytecode_runtime_head,
2784 &event_notifier_enabler->capture_bytecode_head);
2785
2786 event_notifier->num_captures = event_notifier_enabler->num_captures;
b01155ba
FD		 2787 }
2788 return 0;
2789}
2790
3c997079
MD		 2791/*
2792 * Called at module load: connect the probe on all enablers matching
2793 * this event.
2794 * Called with sessions lock held.
2795 */
2796int lttng_fix_pending_events(void)
2797{
2798 struct lttng_session *session;
2799
2800 list_for_each_entry(session, &sessions, list)
b2bc0bc8 2801 lttng_session_lazy_sync_event_enablers(session);
3c997079
MD		 2802 return 0;
2803}
2804
b01155ba
FD		 2805static bool lttng_event_notifier_group_has_active_event_notifiers(
2806 struct lttng_event_notifier_group *event_notifier_group)
2807{
2808 struct lttng_event_notifier_enabler *event_notifier_enabler;
2809
2810 list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head,
2811 node) {
2812 if (event_notifier_enabler->base.enabled)
2813 return true;
2814 }
2815 return false;
2816}
2817
2818bool lttng_event_notifier_active(void)
2819{
2820 struct lttng_event_notifier_group *event_notifier_group;
2821
2822 list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
2823 if (lttng_event_notifier_group_has_active_event_notifiers(event_notifier_group))
2824 return true;
2825 }
2826 return false;
2827}
2828
2829int lttng_fix_pending_event_notifiers(void)
2830{
2831 struct lttng_event_notifier_group *event_notifier_group;
2832
2833 list_for_each_entry(event_notifier_group, &event_notifier_groups, node)
2834 lttng_event_notifier_group_sync_enablers(event_notifier_group);
2835 return 0;
2836}
2837
b2bc0bc8
FD		 2838struct lttng_event_enabler *lttng_event_enabler_create(
2839 enum lttng_enabler_format_type format_type,
3c997079 2840 struct lttng_kernel_event *event_param,
0c023c01
MD		 2841 const struct lttng_counter_key *key,
2842 struct lttng_event_container *container)
3c997079 2843{
b2bc0bc8 2844 struct lttng_event_enabler *event_enabler;
3c997079 2845
b2bc0bc8
FD		 2846 event_enabler = kzalloc(sizeof(*event_enabler), GFP_KERNEL);
2847 if (!event_enabler)
3c997079 2848 return NULL;
b2bc0bc8
FD		 2849 event_enabler->base.format_type = format_type;
2850 INIT_LIST_HEAD(&event_enabler->base.filter_bytecode_head);
2851 memcpy(&event_enabler->base.event_param, event_param,
2852 sizeof(event_enabler->base.event_param));
0c023c01 2853 event_enabler->container = container;
3c997079 2854 /* ctx left NULL */
b2bc0bc8
FD		 2855 event_enabler->base.enabled = 0;
2856 event_enabler->base.evtype = LTTNG_TYPE_ENABLER;
0c023c01
MD		 2857 event_enabler->base.user_token = event_param->token;
2858 if (key)
2859 event_enabler->key = *key;
3c997079 2860 mutex_lock(&sessions_mutex);
0c023c01
MD		 2861 list_add(&event_enabler->node, &event_enabler->container->session->enablers_head);
2862 lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
3c997079 2863 mutex_unlock(&sessions_mutex);
b2bc0bc8 2864 return event_enabler;
3c997079
MD		 2865}
2866
b2bc0bc8 2867int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler)
3c997079
MD		 2868{
2869 mutex_lock(&sessions_mutex);
b2bc0bc8 2870 lttng_event_enabler_as_enabler(event_enabler)->enabled = 1;
0c023c01 2871 lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
3c997079
MD		 2872 mutex_unlock(&sessions_mutex);
2873 return 0;
2874}
2875
b2bc0bc8 2876int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler)
3c997079
MD		 2877{
2878 mutex_lock(&sessions_mutex);
b2bc0bc8 2879 lttng_event_enabler_as_enabler(event_enabler)->enabled = 0;
0c023c01 2880 lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
3c997079
MD		 2881 mutex_unlock(&sessions_mutex);
2882 return 0;
2883}
2884
b2bc0bc8 2885static
183e8b3a 2886int lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler,
07dfc1d0
MD		 2887 struct lttng_kernel_filter_bytecode __user *bytecode)
2888{
89ec2b91 2889 struct lttng_bytecode_node *bytecode_node;
07dfc1d0
MD		 2890 uint32_t bytecode_len;
2891 int ret;
2892
2893 ret = get_user(bytecode_len, &bytecode->len);
2894 if (ret)
2895 return ret;
52cfcdf3 2896 bytecode_node = lttng_kvzalloc(sizeof(*bytecode_node) + bytecode_len,
07dfc1d0
MD		 2897 GFP_KERNEL);
2898 if (!bytecode_node)
2899 return -ENOMEM;
2900 ret = copy_from_user(&bytecode_node->bc, bytecode,
2901 sizeof(*bytecode) + bytecode_len);
2902 if (ret)
2903 goto error_free;
b2bc0bc8 2904
89ec2b91 2905 bytecode_node->type = LTTNG_BYTECODE_NODE_TYPE_FILTER;
07dfc1d0
MD		 2906 bytecode_node->enabler = enabler;
2907 /* Enforce length based on allocated size */
2908 bytecode_node->bc.len = bytecode_len;
2909 list_add_tail(&bytecode_node->node, &enabler->filter_bytecode_head);
b2bc0bc8 2910
07dfc1d0
MD		 2911 return 0;
2912
2913error_free:
52cfcdf3 2914 lttng_kvfree(bytecode_node);
07dfc1d0
MD		 2915 return ret;
2916}
2917
183e8b3a 2918int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler,
b2bc0bc8
FD		 2919 struct lttng_kernel_filter_bytecode __user *bytecode)
2920{
2921 int ret;
183e8b3a 2922 ret = lttng_enabler_attach_filter_bytecode(
b2bc0bc8
FD		 2923 lttng_event_enabler_as_enabler(event_enabler), bytecode);
2924 if (ret)
2925 goto error;
2926
0c023c01 2927 lttng_session_lazy_sync_event_enablers(event_enabler->container->session);
b2bc0bc8
FD		 2928 return 0;
2929
2930error:
2931 return ret;
2932}
2933
3aed4dca
FD		 2934int lttng_event_add_callsite(struct lttng_event *event,
2935 struct lttng_kernel_event_callsite __user *callsite)
2936{
2937
2938 switch (event->instrumentation) {
2939 case LTTNG_KERNEL_UPROBE:
83b802dc 2940 return lttng_uprobes_event_add_callsite(event, callsite);
3aed4dca
FD		 2941 default:
2942 return -EINVAL;
2943 }
2944}
2945
b2bc0bc8 2946int lttng_event_enabler_attach_context(struct lttng_event_enabler *event_enabler,
3c997079
MD		 2947 struct lttng_kernel_context *context_param)
2948{
2949 return -ENOSYS;
2950}
2951
2952static
2953void lttng_enabler_destroy(struct lttng_enabler *enabler)
2954{
89ec2b91 2955 struct lttng_bytecode_node *filter_node, *tmp_filter_node;
07dfc1d0
MD		 2956
2957 /* Destroy filter bytecode */
2958 list_for_each_entry_safe(filter_node, tmp_filter_node,
2959 &enabler->filter_bytecode_head, node) {
52cfcdf3 2960 lttng_kvfree(filter_node);
07dfc1d0 2961 }
b2bc0bc8
FD		 2962}
2963
2964static
2965void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler)
2966{
2967 lttng_enabler_destroy(lttng_event_enabler_as_enabler(event_enabler));
07dfc1d0 2968
3c997079 2969 /* Destroy contexts */
b2bc0bc8 2970 lttng_destroy_context(event_enabler->ctx);
3c997079 2971
b2bc0bc8
FD		 2972 list_del(&event_enabler->node);
2973 kfree(event_enabler);
3c997079
MD		 2974}
2975
dffef45d
FD		 2976struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
2977 struct lttng_event_notifier_group *event_notifier_group,
2978 enum lttng_enabler_format_type format_type,
2979 struct lttng_kernel_event_notifier *event_notifier_param)
2980{
2981 struct lttng_event_notifier_enabler *event_notifier_enabler;
2982
2983 event_notifier_enabler = kzalloc(sizeof(*event_notifier_enabler), GFP_KERNEL);
2984 if (!event_notifier_enabler)
2985 return NULL;
2986
2987 event_notifier_enabler->base.format_type = format_type;
2988 INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head);
99d223ad
FD		 2989 INIT_LIST_HEAD(&event_notifier_enabler->capture_bytecode_head);
2990
99f52fcc 2991 event_notifier_enabler->error_counter_index = event_notifier_param->error_counter_index;
99d223ad 2992 event_notifier_enabler->num_captures = 0;
dffef45d 2993
8a8ac9a8
FD		 2994 memcpy(&event_notifier_enabler->base.event_param, &event_notifier_param->event,
2995 sizeof(event_notifier_enabler->base.event_param));
dffef45d
FD		 2996 event_notifier_enabler->base.evtype = LTTNG_TYPE_ENABLER;
2997
2998 event_notifier_enabler->base.enabled = 0;
2999 event_notifier_enabler->base.user_token = event_notifier_param->event.token;
3000 event_notifier_enabler->group = event_notifier_group;
3001
3002 mutex_lock(&sessions_mutex);
3003 list_add(&event_notifier_enabler->node, &event_notifier_enabler->group->enablers_head);
b01155ba 3004 lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
dffef45d
FD		 3005
3006 mutex_unlock(&sessions_mutex);
3007
3008 return event_notifier_enabler;
3009}
3010
3011int lttng_event_notifier_enabler_enable(
3012 struct lttng_event_notifier_enabler *event_notifier_enabler)
3013{
3014 mutex_lock(&sessions_mutex);
3015 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 1;
b01155ba 3016 lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
dffef45d
FD		 3017 mutex_unlock(&sessions_mutex);
3018 return 0;
3019}
3020
3021int lttng_event_notifier_enabler_disable(
3022 struct lttng_event_notifier_enabler *event_notifier_enabler)
3023{
3024 mutex_lock(&sessions_mutex);
3025 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0;
b01155ba 3026 lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
dffef45d
FD		 3027 mutex_unlock(&sessions_mutex);
3028 return 0;
3029}
3030
183e8b3a 3031int lttng_event_notifier_enabler_attach_filter_bytecode(
dffef45d
FD		 3032 struct lttng_event_notifier_enabler *event_notifier_enabler,
3033 struct lttng_kernel_filter_bytecode __user *bytecode)
3034{
3035 int ret;
3036
183e8b3a 3037 ret = lttng_enabler_attach_filter_bytecode(
dffef45d
FD		 3038 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
3039 bytecode);
3040 if (ret)
3041 goto error;
3042
b01155ba 3043 lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
dffef45d
FD		 3044 return 0;
3045
3046error:
3047 return ret;
3048}
3049
99d223ad
FD		 3050int lttng_event_notifier_enabler_attach_capture_bytecode(
3051 struct lttng_event_notifier_enabler *event_notifier_enabler,
3052 struct lttng_kernel_capture_bytecode __user *bytecode)
3053{
3054 struct lttng_bytecode_node *bytecode_node;
3055 struct lttng_enabler *enabler =
3056 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler);
3057 uint32_t bytecode_len;
3058 int ret;
3059
3060 ret = get_user(bytecode_len, &bytecode->len);
3061 if (ret)
3062 return ret;
3063
3064 bytecode_node = lttng_kvzalloc(sizeof(*bytecode_node) + bytecode_len,
3065 GFP_KERNEL);
3066 if (!bytecode_node)
3067 return -ENOMEM;
3068
3069 ret = copy_from_user(&bytecode_node->bc, bytecode,
3070 sizeof(*bytecode) + bytecode_len);
3071 if (ret)
3072 goto error_free;
3073
3074 bytecode_node->type = LTTNG_BYTECODE_NODE_TYPE_CAPTURE;
3075 bytecode_node->enabler = enabler;
3076
3077 /* Enforce length based on allocated size */
3078 bytecode_node->bc.len = bytecode_len;
3079 list_add_tail(&bytecode_node->node, &event_notifier_enabler->capture_bytecode_head);
3080
3081 event_notifier_enabler->num_captures++;
3082
3083 lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
3084 goto end;
3085
3086error_free:
3087 lttng_kvfree(bytecode_node);
3088end:
3089 return ret;
3090}
3091
9de67196
FD		 3092int lttng_event_notifier_add_callsite(struct lttng_event_notifier *event_notifier,
3093 struct lttng_kernel_event_callsite __user *callsite)
3094{
3095
3096 switch (event_notifier->instrumentation) {
3097 case LTTNG_KERNEL_UPROBE:
3098 return lttng_uprobes_event_notifier_add_callsite(event_notifier,
3099 callsite);
3100 default:
3101 return -EINVAL;
3102 }
3103}
3104
dffef45d
FD		 3105int lttng_event_notifier_enabler_attach_context(
3106 struct lttng_event_notifier_enabler *event_notifier_enabler,
3107 struct lttng_kernel_context *context_param)
3108{
3109 return -ENOSYS;
3110}
3111
3112static
3113void lttng_event_notifier_enabler_destroy(
3114 struct lttng_event_notifier_enabler *event_notifier_enabler)
3115{
3116 if (!event_notifier_enabler) {
3117 return;
3118 }
3119
3120 list_del(&event_notifier_enabler->node);
3121
3122 lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
3123 kfree(event_notifier_enabler);
3124}
3125
3c997079 3126/*
b2bc0bc8 3127 * lttng_session_sync_event_enablers should be called just before starting a
3c997079
MD		 3128 * session.
3129 * Should be called with sessions mutex held.
3130 */
3131static
b2bc0bc8 3132void lttng_session_sync_event_enablers(struct lttng_session *session)
3c997079 3133{
b2bc0bc8 3134 struct lttng_event_enabler *event_enabler;
3c997079
MD		 3135 struct lttng_event *event;
3136
b2bc0bc8
FD		 3137 list_for_each_entry(event_enabler, &session->enablers_head, node)
3138 lttng_event_enabler_ref_events(event_enabler);
3c997079
MD		 3139 /*
3140 * For each event, if at least one of its enablers is enabled,
0c023c01 3141 * and its event container and session transient states are enabled, we
3c997079
MD		 3142 * enable the event, else we disable it.
3143 */
3144 list_for_each_entry(event, &session->events, list) {
3145 struct lttng_enabler_ref *enabler_ref;
07dfc1d0
MD		 3146 struct lttng_bytecode_runtime *runtime;
3147 int enabled = 0, has_enablers_without_bytecode = 0;
3c997079 3148
4ecb5ad5
MD		 3149 switch (event->instrumentation) {
3150 case LTTNG_KERNEL_TRACEPOINT:
3151 case LTTNG_KERNEL_SYSCALL:
3c997079
MD		 3152 /* Enable events */
3153 list_for_each_entry(enabler_ref,
3154 &event->enablers_ref_head, node) {
3155 if (enabler_ref->ref->enabled) {
3156 enabled = 1;
3157 break;
3158 }
3159 }
4ecb5ad5
MD		 3160 break;
3161 default:
3c997079
MD		 3162 /* Not handled with lazy sync. */
3163 continue;
3164 }
3165 /*
3166 * Enabled state is based on union of enablers, with
0c023c01 3167 * intesection of session and event container transient enable
3c997079
MD		 3168 * states.
3169 */
0c023c01 3170 enabled = enabled && session->tstate && event->container->tstate;
3c997079 3171
a8f2d0c7 3172 WRITE_ONCE(event->enabled, enabled);
3c997079
MD		 3173 /*
3174 * Sync tracepoint registration with event enabled
3175 * state.
3176 */
3177 if (enabled) {
3178 register_event(event);
3179 } else {
3180 _lttng_event_unregister(event);
3181 }
07dfc1d0
MD		 3182
3183 /* Check if has enablers without bytecode enabled */
3184 list_for_each_entry(enabler_ref,
3185 &event->enablers_ref_head, node) {
3186 if (enabler_ref->ref->enabled
3187 && list_empty(&enabler_ref->ref->filter_bytecode_head)) {
3188 has_enablers_without_bytecode = 1;
3189 break;
3190 }
3191 }
3192 event->has_enablers_without_bytecode =
3193 has_enablers_without_bytecode;
3194
3195 /* Enable filters */
3196 list_for_each_entry(runtime,
183e8b3a 3197 &event->filter_bytecode_runtime_head, node)
0b365677 3198 lttng_bytecode_filter_sync_state(runtime);
3c997079
MD		 3199 }
3200}
3201
3202/*
3203 * Apply enablers to session events, adding events to session if need
3204 * be. It is required after each modification applied to an active
3205 * session, and right before session "start".
3206 * "lazy" sync means we only sync if required.
3207 * Should be called with sessions mutex held.
3208 */
3209static
b2bc0bc8 3210void lttng_session_lazy_sync_event_enablers(struct lttng_session *session)
3c997079
MD		 3211{
3212 /* We can skip if session is not active */
3213 if (!session->active)
3214 return;
b2bc0bc8 3215 lttng_session_sync_event_enablers(session);
3c997079
MD		 3216}
3217
b01155ba
FD		 3218static
3219void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group)
3220{
3221 struct lttng_event_notifier_enabler *event_notifier_enabler;
3222 struct lttng_event_notifier *event_notifier;
3223
3224 list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, node)
3225 lttng_event_notifier_enabler_ref_event_notifiers(event_notifier_enabler);
3226
3227 /*
3228 * For each event_notifier, if at least one of its enablers is enabled,
3229 * we enable the event_notifier, else we disable it.
3230 */
3231 list_for_each_entry(event_notifier, &event_notifier_group->event_notifiers_head, list) {
3232 struct lttng_enabler_ref *enabler_ref;
3233 struct lttng_bytecode_runtime *runtime;
3234 int enabled = 0, has_enablers_without_bytecode = 0;
3235
3236 switch (event_notifier->instrumentation) {
3237 case LTTNG_KERNEL_TRACEPOINT:
3238 case LTTNG_KERNEL_SYSCALL:
3239 /* Enable event_notifiers */
3240 list_for_each_entry(enabler_ref,
3241 &event_notifier->enablers_ref_head, node) {
3242 if (enabler_ref->ref->enabled) {
3243 enabled = 1;
3244 break;
3245 }
3246 }
3247 break;
3248 default:
3249 /* Not handled with sync. */
3250 continue;
3251 }
3252
3253 WRITE_ONCE(event_notifier->enabled, enabled);
3254 /*
3255 * Sync tracepoint registration with event_notifier enabled
3256 * state.
3257 */
3258 if (enabled) {
3259 if (!event_notifier->registered)
3260 register_event_notifier(event_notifier);
3261 } else {
3262 if (event_notifier->registered)
3263 _lttng_event_notifier_unregister(event_notifier);
3264 }
3265
3266 /* Check if has enablers without bytecode enabled */
3267 list_for_each_entry(enabler_ref,
3268 &event_notifier->enablers_ref_head, node) {
3269 if (enabler_ref->ref->enabled
3270 && list_empty(&enabler_ref->ref->filter_bytecode_head)) {
3271 has_enablers_without_bytecode = 1;
3272 break;
3273 }
3274 }
3275 event_notifier->has_enablers_without_bytecode =
3276 has_enablers_without_bytecode;
3277
3278 /* Enable filters */
3279 list_for_each_entry(runtime,
183e8b3a 3280 &event_notifier->filter_bytecode_runtime_head, node)
0b365677 3281 lttng_bytecode_filter_sync_state(runtime);
99d223ad
FD		 3282
3283 /* Enable captures */
3284 list_for_each_entry(runtime,
3285 &event_notifier->capture_bytecode_runtime_head, node)
3286 lttng_bytecode_capture_sync_state(runtime);
0c023c01
MD		 3287
3288 WRITE_ONCE(event_notifier->eval_capture, !!event_notifier->num_captures);
b01155ba
FD		 3289 }
3290}
3291
1ec3f75a 3292/*
d83004aa
JD		 3293 * Serialize at most one packet worth of metadata into a metadata
3294 * channel.
92d9f5e6
MD		 3295 * We grab the metadata cache mutex to get exclusive access to our metadata
3296 * buffer and to the metadata cache. Exclusive access to the metadata buffer
3297 * allows us to do racy operations such as looking for remaining space left in
3298 * packet and write, since mutual exclusion protects us from concurrent writes.
3299 * Mutual exclusion on the metadata cache allow us to read the cache content
3300 * without racing against reallocation of the cache by updates.
35097f36
JD		 3301 * Returns the number of bytes written in the channel, 0 if no data
3302 * was written and a negative value on error.
1ec3f75a 3303 */
b3b8072b 3304int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
8b97fd42 3305 struct channel *chan, bool *coherent)
d83004aa
JD		 3306{
3307 struct lib_ring_buffer_ctx ctx;
3308 int ret = 0;
3309 size_t len, reserve_len;
3310
f613e3e6 3311 /*
92d9f5e6
MD		 3312 * Ensure we support mutiple get_next / put sequences followed by
3313 * put_next. The metadata cache lock protects reading the metadata
3314 * cache. It can indeed be read concurrently by "get_next_subbuf" and
3315 * "flush" operations on the buffer invoked by different processes.
3316 * Moreover, since the metadata cache memory can be reallocated, we
3317 * need to have exclusive access against updates even though we only
3318 * read it.
f613e3e6 3319 */
92d9f5e6 3320 mutex_lock(&stream->metadata_cache->lock);
f613e3e6
MD		 3321 WARN_ON(stream->metadata_in < stream->metadata_out);
3322 if (stream->metadata_in != stream->metadata_out)
de23d59d 3323 goto end;
f613e3e6 3324
9616f0bf
JD		 3325 /* Metadata regenerated, change the version. */
3326 if (stream->metadata_cache->version != stream->version)
3327 stream->version = stream->metadata_cache->version;
3328
d83004aa 3329 len = stream->metadata_cache->metadata_written -
f613e3e6 3330 stream->metadata_in;
9de2c215 3331 if (!len)
de23d59d 3332 goto end;
d83004aa 3333 reserve_len = min_t(size_t,
b3b8072b 3334 stream->transport->ops.packet_avail_size(chan),
d83004aa 3335 len);
b3b8072b 3336 lib_ring_buffer_ctx_init(&ctx, chan, NULL, reserve_len,
d83004aa
JD		 3337 sizeof(char), -1);
3338 /*
3339 * If reservation failed, return an error to the caller.
3340 */
b3b8072b 3341 ret = stream->transport->ops.event_reserve(&ctx, 0);
d83004aa
JD		 3342 if (ret != 0) {
3343 printk(KERN_WARNING "LTTng: Metadata event reservation failed\n");
8b97fd42 3344 stream->coherent = false;
d83004aa
JD		 3345 goto end;
3346 }
b3b8072b 3347 stream->transport->ops.event_write(&ctx,
f613e3e6 3348 stream->metadata_cache->data + stream->metadata_in,
d83004aa 3349 reserve_len);
b3b8072b 3350 stream->transport->ops.event_commit(&ctx);
f613e3e6 3351 stream->metadata_in += reserve_len;
3e75e2a7 3352 if (reserve_len < len)
8b97fd42
MD		 3353 stream->coherent = false;
3354 else
3355 stream->coherent = true;
d83004aa
JD		 3356 ret = reserve_len;
3357
3358end:
8b97fd42
MD		 3359 if (coherent)
3360 *coherent = stream->coherent;
92d9f5e6 3361 mutex_unlock(&stream->metadata_cache->lock);
d83004aa
JD		 3362 return ret;
3363}
3364
8b97fd42
MD		 3365static
3366void lttng_metadata_begin(struct lttng_session *session)
3367{
3e75e2a7
MD		 3368 if (atomic_inc_return(&session->metadata_cache->producing) == 1)
3369 mutex_lock(&session->metadata_cache->lock);
8b97fd42
MD		 3370}
3371
3372static
3373void lttng_metadata_end(struct lttng_session *session)
3374{
3e75e2a7
MD		 3375 WARN_ON_ONCE(!atomic_read(&session->metadata_cache->producing));
3376 if (atomic_dec_return(&session->metadata_cache->producing) == 0) {
3377 struct lttng_metadata_stream *stream;
3378
3e75e2a7
MD		 3379 list_for_each_entry(stream, &session->metadata_cache->metadata_stream, list)
3380 wake_up_interruptible(&stream->read_wait);
92143b2c 3381 mutex_unlock(&session->metadata_cache->lock);
3e75e2a7 3382 }
8b97fd42
MD		 3383}
3384
d83004aa
JD		 3385/*
3386 * Write the metadata to the metadata cache.
3387 * Must be called with sessions_mutex held.
92d9f5e6
MD		 3388 * The metadata cache lock protects us from concurrent read access from
3389 * thread outputting metadata content to ring buffer.
8b97fd42
MD		 3390 * The content of the printf is printed as a single atomic metadata
3391 * transaction.
d83004aa 3392 */
a90917c3 3393int lttng_metadata_printf(struct lttng_session *session,
c099397a
MD		 3394 const char *fmt, ...)
3395{
c099397a 3396 char *str;
d83004aa 3397 size_t len;
c099397a
MD		 3398 va_list ap;
3399
585e5dcc 3400 WARN_ON_ONCE(!LTTNG_READ_ONCE(session->active));
c099397a
MD		 3401
3402 va_start(ap, fmt);
3403 str = kvasprintf(GFP_KERNEL, fmt, ap);
3404 va_end(ap);
3405 if (!str)
3406 return -ENOMEM;
3407
1ec3f75a 3408 len = strlen(str);
3e75e2a7 3409 WARN_ON_ONCE(!atomic_read(&session->metadata_cache->producing));
d83004aa
JD		 3410 if (session->metadata_cache->metadata_written + len >
3411 session->metadata_cache->cache_alloc) {
3412 char *tmp_cache_realloc;
3413 unsigned int tmp_cache_alloc_size;
3414
3415 tmp_cache_alloc_size = max_t(unsigned int,
3416 session->metadata_cache->cache_alloc + len,
3417 session->metadata_cache->cache_alloc << 1);
0ca42eb7 3418 tmp_cache_realloc = vzalloc(tmp_cache_alloc_size);
d83004aa
JD		 3419 if (!tmp_cache_realloc)
3420 goto err;
a606b6e8
ML		 3421 if (session->metadata_cache->data) {
3422 memcpy(tmp_cache_realloc,
3423 session->metadata_cache->data,
3424 session->metadata_cache->cache_alloc);
3425 vfree(session->metadata_cache->data);
3426 }
3427
d83004aa
JD		 3428 session->metadata_cache->cache_alloc = tmp_cache_alloc_size;
3429 session->metadata_cache->data = tmp_cache_realloc;
c099397a 3430 }
d83004aa
JD		 3431 memcpy(session->metadata_cache->data +
3432 session->metadata_cache->metadata_written,
3433 str, len);
3434 session->metadata_cache->metadata_written += len;
c099397a 3435 kfree(str);
d83004aa 3436
d83004aa
JD		 3437 return 0;
3438
3439err:
3440 kfree(str);
3441 return -ENOMEM;
c099397a
MD		 3442}
3443
f513b2bf
MD		 3444static
3445int print_tabs(struct lttng_session *session, size_t nesting)
3446{
3447 size_t i;
3448
3449 for (i = 0; i < nesting; i++) {
3450 int ret;
3451
3452 ret = lttng_metadata_printf(session, " ");
3453 if (ret) {
3454 return ret;
3455 }
3456 }
3457 return 0;
3458}
3459
ceabb767
MD		 3460static
3461int lttng_field_name_statedump(struct lttng_session *session,
3462 const struct lttng_event_field *field,
3463 size_t nesting)
3464{
3465 return lttng_metadata_printf(session, " _%s;\n", field->name);
3466}
3467
3468static
3469int _lttng_integer_type_statedump(struct lttng_session *session,
3470 const struct lttng_type *type,
3471 size_t nesting)
3472{
3473 int ret;
3474
3475 WARN_ON_ONCE(type->atype != atype_integer);
3476 ret = print_tabs(session, nesting);
3477 if (ret)
3478 return ret;
3479 ret = lttng_metadata_printf(session,
3480 "integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s }",
3481 type->u.integer.size,
3482 type->u.integer.alignment,
3483 type->u.integer.signedness,
3484 (type->u.integer.encoding == lttng_encode_none)
3485 ? "none"
3486 : (type->u.integer.encoding == lttng_encode_UTF8)
3487 ? "UTF8"
3488 : "ASCII",
3489 type->u.integer.base,
3490#if __BYTE_ORDER == __BIG_ENDIAN
3491 type->u.integer.reverse_byte_order ? " byte_order = le;" : ""
3492#else
3493 type->u.integer.reverse_byte_order ? " byte_order = be;" : ""
3494#endif
3495 );
3496 return ret;
3497}
3498
f513b2bf
MD		 3499/*
3500 * Must be called with sessions_mutex held.
3501 */
3502static
3503int _lttng_struct_type_statedump(struct lttng_session *session,
3504 const struct lttng_type *type,
3505 size_t nesting)
3506{
3507 int ret;
3508 uint32_t i, nr_fields;
ceabb767
MD		 3509 unsigned int alignment;
3510
3511 WARN_ON_ONCE(type->atype != atype_struct_nestable);
f513b2bf
MD		 3512
3513 ret = print_tabs(session, nesting);
3514 if (ret)
3515 return ret;
3516 ret = lttng_metadata_printf(session,
3517 "struct {\n");
3518 if (ret)
3519 return ret;
ceabb767 3520 nr_fields = type->u.struct_nestable.nr_fields;
f513b2bf
MD		 3521 for (i = 0; i < nr_fields; i++) {
3522 const struct lttng_event_field *iter_field;
3523
ceabb767 3524 iter_field = &type->u.struct_nestable.fields[i];
f513b2bf
MD		 3525 ret = _lttng_field_statedump(session, iter_field, nesting + 1);
3526 if (ret)
3527 return ret;
3528 }
3529 ret = print_tabs(session, nesting);
3530 if (ret)
3531 return ret;
ceabb767
MD		 3532 alignment = type->u.struct_nestable.alignment;
3533 if (alignment) {
3534 ret = lttng_metadata_printf(session,
3535 "} align(%u)",
3536 alignment);
3537 } else {
3538 ret = lttng_metadata_printf(session,
3539 "}");
3540 }
f513b2bf
MD		 3541 return ret;
3542}
3543
3544/*
3545 * Must be called with sessions_mutex held.
3546 */
3547static
ceabb767 3548int _lttng_struct_field_statedump(struct lttng_session *session,
f513b2bf
MD		 3549 const struct lttng_event_field *field,
3550 size_t nesting)
3551{
3552 int ret;
3553
3554 ret = _lttng_struct_type_statedump(session,
3555 &field->type, nesting);
3556 if (ret)
3557 return ret;
ceabb767 3558 return lttng_field_name_statedump(session, field, nesting);
f513b2bf
MD		 3559}
3560
65c85aa6
MD		 3561/*
3562 * Must be called with sessions_mutex held.
3563 */
3564static
3565int _lttng_variant_type_statedump(struct lttng_session *session,
3566 const struct lttng_type *type,
3567 size_t nesting)
3568{
3569 int ret;
3570 uint32_t i, nr_choices;
3571
ceabb767
MD		 3572 WARN_ON_ONCE(type->atype != atype_variant_nestable);
3573 /*
3574 * CTF 1.8 does not allow expressing nonzero variant alignment in a nestable way.
3575 */
3576 if (type->u.variant_nestable.alignment != 0)
3577 return -EINVAL;
65c85aa6
MD		 3578 ret = print_tabs(session, nesting);
3579 if (ret)
3580 return ret;
3581 ret = lttng_metadata_printf(session,
3582 "variant <_%s> {\n",
ceabb767 3583 type->u.variant_nestable.tag_name);
65c85aa6
MD		 3584 if (ret)
3585 return ret;
ceabb767 3586 nr_choices = type->u.variant_nestable.nr_choices;
65c85aa6
MD		 3587 for (i = 0; i < nr_choices; i++) {
3588 const struct lttng_event_field *iter_field;
3589
ceabb767 3590 iter_field = &type->u.variant_nestable.choices[i];
65c85aa6
MD		 3591 ret = _lttng_field_statedump(session, iter_field, nesting + 1);
3592 if (ret)
3593 return ret;
3594 }
3595 ret = print_tabs(session, nesting);
3596 if (ret)
3597 return ret;
3598 ret = lttng_metadata_printf(session,
3599 "}");
3600 return ret;
3601}
3602
3603/*
3604 * Must be called with sessions_mutex held.
3605 */
3606static
ceabb767 3607int _lttng_variant_field_statedump(struct lttng_session *session,
65c85aa6
MD		 3608 const struct lttng_event_field *field,
3609 size_t nesting)
3610{
3611 int ret;
3612
3613 ret = _lttng_variant_type_statedump(session,
3614 &field->type, nesting);
3615 if (ret)
3616 return ret;
ceabb767 3617 return lttng_field_name_statedump(session, field, nesting);
65c85aa6
MD		 3618}
3619
f513b2bf
MD		 3620/*
3621 * Must be called with sessions_mutex held.
3622 */
3623static
ceabb767 3624int _lttng_array_field_statedump(struct lttng_session *session,
f513b2bf
MD		 3625 const struct lttng_event_field *field,
3626 size_t nesting)
3627{
3628 int ret;
3629 const struct lttng_type *elem_type;
3630
ceabb767
MD		 3631 WARN_ON_ONCE(field->type.atype != atype_array_nestable);
3632
3633 if (field->type.u.array_nestable.alignment) {
3634 ret = print_tabs(session, nesting);
f513b2bf
MD		 3635 if (ret)
3636 return ret;
ceabb767
MD		 3637 ret = lttng_metadata_printf(session,
3638 "struct { } align(%u) _%s_padding;\n",
3639 field->type.u.array_nestable.alignment * CHAR_BIT,
3640 field->name);
3641 if (ret)
3642 return ret;
3643 }
3644 /*
3645 * Nested compound types: Only array of structures and variants are
3646 * currently supported.
3647 */
3648 elem_type = field->type.u.array_nestable.elem_type;
3649 switch (elem_type->atype) {
3650 case atype_integer:
3651 case atype_struct_nestable:
3652 case atype_variant_nestable:
3653 ret = _lttng_type_statedump(session, elem_type, nesting);
65c85aa6
MD		 3654 if (ret)
3655 return ret;
3656 break;
ceabb767 3657
f513b2bf
MD		 3658 default:
3659 return -EINVAL;
3660 }
3661 ret = lttng_metadata_printf(session,
3662 " _%s[%u];\n",
3663 field->name,
ceabb767 3664 field->type.u.array_nestable.length);
f513b2bf
MD		 3665 return ret;
3666}
3667
3668/*
3669 * Must be called with sessions_mutex held.
3670 */
3671static
ceabb767 3672int _lttng_sequence_field_statedump(struct lttng_session *session,
f513b2bf
MD		 3673 const struct lttng_event_field *field,
3674 size_t nesting)
3675{
3676 int ret;
3677 const char *length_name;
3678 const struct lttng_type *elem_type;
3679
ceabb767 3680 WARN_ON_ONCE(field->type.atype != atype_sequence_nestable);
f513b2bf 3681
ceabb767
MD		 3682 length_name = field->type.u.sequence_nestable.length_name;
3683
3684 if (field->type.u.sequence_nestable.alignment) {
3685 ret = print_tabs(session, nesting);
f513b2bf
MD		 3686 if (ret)
3687 return ret;
ceabb767
MD		 3688 ret = lttng_metadata_printf(session,
3689 "struct { } align(%u) _%s_padding;\n",
3690 field->type.u.sequence_nestable.alignment * CHAR_BIT,
3691 field->name);
3692 if (ret)
3693 return ret;
3694 }
3695
3696 /*
3697 * Nested compound types: Only array of structures and variants are
3698 * currently supported.
3699 */
3700 elem_type = field->type.u.sequence_nestable.elem_type;
3701 switch (elem_type->atype) {
3702 case atype_integer:
3703 case atype_struct_nestable:
3704 case atype_variant_nestable:
3705 ret = _lttng_type_statedump(session, elem_type, nesting);
65c85aa6
MD		 3706 if (ret)
3707 return ret;
3708 break;
ceabb767 3709
f513b2bf
MD		 3710 default:
3711 return -EINVAL;
3712 }
3713 ret = lttng_metadata_printf(session,
3714 " _%s[ _%s ];\n",
3715 field->name,
ceabb767 3716 field->type.u.sequence_nestable.length_name);
f513b2bf
MD		 3717 return ret;
3718}
3719
141ddf28
MD		 3720/*
3721 * Must be called with sessions_mutex held.
3722 */
3723static
ceabb767
MD		 3724int _lttng_enum_type_statedump(struct lttng_session *session,
3725 const struct lttng_type *type,
141ddf28
MD		 3726 size_t nesting)
3727{
3728 const struct lttng_enum_desc *enum_desc;
ceabb767 3729 const struct lttng_type *container_type;
141ddf28
MD		 3730 int ret;
3731 unsigned int i, nr_entries;
3732
ceabb767
MD		 3733 container_type = type->u.enum_nestable.container_type;
3734 if (container_type->atype != atype_integer) {
3735 ret = -EINVAL;
3736 goto end;
3737 }
3738 enum_desc = type->u.enum_nestable.desc;
141ddf28
MD		 3739 nr_entries = enum_desc->nr_entries;
3740
3741 ret = print_tabs(session, nesting);
3742 if (ret)
3743 goto end;
ceabb767
MD		 3744 ret = lttng_metadata_printf(session, "enum : ");
3745 if (ret)
3746 goto end;
3747 ret = _lttng_integer_type_statedump(session, container_type, 0);
141ddf28 3748 if (ret)
ceabb767
MD		 3749 goto end;
3750 ret = lttng_metadata_printf(session, " {\n");
3751 if (ret)
3752 goto end;
141ddf28
MD		 3753 /* Dump all entries */
3754 for (i = 0; i < nr_entries; i++) {
3755 const struct lttng_enum_entry *entry = &enum_desc->entries[i];
3756 int j, len;
3757
3758 ret = print_tabs(session, nesting + 1);
3759 if (ret)
3760 goto end;
3761 ret = lttng_metadata_printf(session,
3762 "\"");
3763 if (ret)
3764 goto end;
3765 len = strlen(entry->string);
3766 /* Escape the character '"' */
3767 for (j = 0; j < len; j++) {
3768 char c = entry->string[j];
3769
3770 switch (c) {
3771 case '"':
3772 ret = lttng_metadata_printf(session,
3773 "\\\"");
3774 break;
3775 case '\\':
3776 ret = lttng_metadata_printf(session,
3777 "\\\\");
3778 break;
3779 default:
3780 ret = lttng_metadata_printf(session,
3781 "%c", c);
3782 break;
3783 }
3784 if (ret)
3785 goto end;
3786 }
08ad1061
PP		 3787 ret = lttng_metadata_printf(session, "\"");
3788 if (ret)
3789 goto end;
3790
3791 if (entry->options.is_auto) {
3792 ret = lttng_metadata_printf(session, ",\n");
3793 if (ret)
3794 goto end;
141ddf28 3795 } else {
7c559490
MD		 3796 ret = lttng_metadata_printf(session,
3797 " = ");
3798 if (ret)
3799 goto end;
3800 if (entry->start.signedness)
141ddf28 3801 ret = lttng_metadata_printf(session,
7c559490
MD		 3802 "%lld", (long long) entry->start.value);
3803 else
3804 ret = lttng_metadata_printf(session,
3805 "%llu", entry->start.value);
3806 if (ret)
3807 goto end;
3808 if (entry->start.signedness == entry->end.signedness &&
3809 entry->start.value
3810 == entry->end.value) {
141ddf28 3811 ret = lttng_metadata_printf(session,
7c559490
MD		 3812 ",\n");
3813 } else {
3814 if (entry->end.signedness) {
3815 ret = lttng_metadata_printf(session,
3816 " ... %lld,\n",
3817 (long long) entry->end.value);
3818 } else {
3819 ret = lttng_metadata_printf(session,
3820 " ... %llu,\n",
3821 entry->end.value);
3822 }
141ddf28 3823 }
7c559490
MD		 3824 if (ret)
3825 goto end;
141ddf28 3826 }
141ddf28
MD		 3827 }
3828 ret = print_tabs(session, nesting);
3829 if (ret)
3830 goto end;
ceabb767 3831 ret = lttng_metadata_printf(session, "}");
141ddf28
MD		 3832end:
3833 return ret;
3834}
3835
d83004aa
JD		 3836/*
3837 * Must be called with sessions_mutex held.
3838 */
c099397a 3839static
ceabb767
MD		 3840int _lttng_enum_field_statedump(struct lttng_session *session,
3841 const struct lttng_event_field *field,
3842 size_t nesting)
3843{
3844 int ret;
3845
3846 ret = _lttng_enum_type_statedump(session, &field->type, nesting);
3847 if (ret)
3848 return ret;
3849 return lttng_field_name_statedump(session, field, nesting);
3850}
3851
3852static
3853int _lttng_integer_field_statedump(struct lttng_session *session,
3854 const struct lttng_event_field *field,
3855 size_t nesting)
3856{
3857 int ret;
3858
3859 ret = _lttng_integer_type_statedump(session, &field->type, nesting);
3860 if (ret)
3861 return ret;
3862 return lttng_field_name_statedump(session, field, nesting);
3863}
3864
3865static
3866int _lttng_string_type_statedump(struct lttng_session *session,
3867 const struct lttng_type *type,
3868 size_t nesting)
3869{
3870 int ret;
3871
3872 WARN_ON_ONCE(type->atype != atype_string);
3873 /* Default encoding is UTF8 */
3874 ret = print_tabs(session, nesting);
3875 if (ret)
3876 return ret;
3877 ret = lttng_metadata_printf(session,
3878 "string%s",
3879 type->u.string.encoding == lttng_encode_ASCII ?
3880 " { encoding = ASCII; }" : "");
3881 return ret;
3882}
3883
3884static
3885int _lttng_string_field_statedump(struct lttng_session *session,
f513b2bf
MD		 3886 const struct lttng_event_field *field,
3887 size_t nesting)
ceabb767
MD		 3888{
3889 int ret;
3890
3891 WARN_ON_ONCE(field->type.atype != atype_string);
3892 ret = _lttng_string_type_statedump(session, &field->type, nesting);
3893 if (ret)
3894 return ret;
3895 return lttng_field_name_statedump(session, field, nesting);
3896}
3897
3898/*
3899 * Must be called with sessions_mutex held.
3900 */
3901static
3902int _lttng_type_statedump(struct lttng_session *session,
3903 const struct lttng_type *type,
3904 size_t nesting)
c099397a 3905{
c099397a 3906 int ret = 0;
c099397a 3907
ceabb767 3908 switch (type->atype) {
8070f5c0 3909 case atype_integer:
ceabb767 3910 ret = _lttng_integer_type_statedump(session, type, nesting);
8070f5c0 3911 break;
ceabb767
MD		 3912 case atype_enum_nestable:
3913 ret = _lttng_enum_type_statedump(session, type, nesting);
8070f5c0 3914 break;
ceabb767
MD		 3915 case atype_string:
3916 ret = _lttng_string_type_statedump(session, type, nesting);
3917 break;
3918 case atype_struct_nestable:
3919 ret = _lttng_struct_type_statedump(session, type, nesting);
8070f5c0 3920 break;
ceabb767
MD		 3921 case atype_variant_nestable:
3922 ret = _lttng_variant_type_statedump(session, type, nesting);
3923 break;
3924
3925 /* Nested arrays and sequences are not supported yet. */
3926 case atype_array_nestable:
3927 case atype_sequence_nestable:
3928 default:
3929 WARN_ON_ONCE(1);
3930 return -EINVAL;
8070f5c0 3931 }
ceabb767
MD		 3932 return ret;
3933}
8070f5c0 3934
ceabb767
MD		 3935/*
3936 * Must be called with sessions_mutex held.
3937 */
3938static
3939int _lttng_field_statedump(struct lttng_session *session,
3940 const struct lttng_event_field *field,
3941 size_t nesting)
3942{
3943 int ret = 0;
27d2368e 3944
ceabb767
MD		 3945 switch (field->type.atype) {
3946 case atype_integer:
3947 ret = _lttng_integer_field_statedump(session, field, nesting);
3948 break;
3949 case atype_enum_nestable:
3950 ret = _lttng_enum_field_statedump(session, field, nesting);
8070f5c0 3951 break;
8070f5c0 3952 case atype_string:
ceabb767 3953 ret = _lttng_string_field_statedump(session, field, nesting);
8070f5c0 3954 break;
ceabb767
MD		 3955 case atype_struct_nestable:
3956 ret = _lttng_struct_field_statedump(session, field, nesting);
f513b2bf 3957 break;
ceabb767
MD		 3958 case atype_array_nestable:
3959 ret = _lttng_array_field_statedump(session, field, nesting);
f513b2bf 3960 break;
ceabb767
MD		 3961 case atype_sequence_nestable:
3962 ret = _lttng_sequence_field_statedump(session, field, nesting);
f513b2bf 3963 break;
ceabb767
MD		 3964 case atype_variant_nestable:
3965 ret = _lttng_variant_field_statedump(session, field, nesting);
65c85aa6 3966 break;
f513b2bf 3967
8070f5c0
MD		 3968 default:
3969 WARN_ON_ONCE(1);
3970 return -EINVAL;
3971 }
3972 return ret;
3973}
3974
3975static
a90917c3 3976int _lttng_context_metadata_statedump(struct lttng_session *session,
8070f5c0
MD		 3977 struct lttng_ctx *ctx)
3978{
3979 int ret = 0;
3980 int i;
3981
3982 if (!ctx)
3983 return 0;
3984 for (i = 0; i < ctx->nr_fields; i++) {
3985 const struct lttng_ctx_field *field = &ctx->fields[i];
3986
f513b2bf 3987 ret = _lttng_field_statedump(session, &field->event_field, 2);
8070f5c0
MD		 3988 if (ret)
3989 return ret;
3990 }
3991 return ret;
3992}
3993
3994static
a90917c3
MD		 3995int _lttng_fields_metadata_statedump(struct lttng_session *session,
3996 struct lttng_event *event)
8070f5c0
MD		 3997{
3998 const struct lttng_event_desc *desc = event->desc;
3999 int ret = 0;
4000 int i;
4001
4002 for (i = 0; i < desc->nr_fields; i++) {
4003 const struct lttng_event_field *field = &desc->fields[i];
4004
f513b2bf 4005 ret = _lttng_field_statedump(session, field, 2);
8070f5c0
MD		 4006 if (ret)
4007 return ret;
c099397a
MD		 4008 }
4009 return ret;
4010}
4011
d83004aa
JD		 4012/*
4013 * Must be called with sessions_mutex held.
8b97fd42
MD		 4014 * The entire event metadata is printed as a single atomic metadata
4015 * transaction.
d83004aa 4016 */
c099397a 4017static
a90917c3 4018int _lttng_event_metadata_statedump(struct lttng_session *session,
a90917c3 4019 struct lttng_event *event)
c099397a 4020{
0c023c01 4021 struct lttng_channel *chan;
c099397a
MD		 4022 int ret = 0;
4023
0c023c01
MD		 4024 WARN_ON_ONCE(event->container->type != LTTNG_EVENT_CONTAINER_CHANNEL);
4025 chan = lttng_event_container_get_channel(event->container);
585e5dcc 4026 if (event->metadata_dumped || !LTTNG_READ_ONCE(session->active))
c099397a 4027 return 0;
d83004aa 4028 if (chan->channel_type == METADATA_CHANNEL)
c099397a
MD		 4029 return 0;
4030
8b97fd42
MD		 4031 lttng_metadata_begin(session);
4032
c099397a
MD		 4033 ret = lttng_metadata_printf(session,
4034 "event {\n"
ae734547 4035 " name = \"%s\";\n"
0c023c01 4036 " id = %zu;\n"
b9074a1b 4037 " stream_id = %u;\n",
c099397a
MD		 4038 event->desc->name,
4039 event->id,
0c023c01 4040 chan->id);
c099397a
MD		 4041 if (ret)
4042 goto end;
4043
b9074a1b
MD		 4044 if (event->ctx) {
4045 ret = lttng_metadata_printf(session,
4046 " context := struct {\n");
4047 if (ret)
4048 goto end;
4049 }
a90917c3 4050 ret = _lttng_context_metadata_statedump(session, event->ctx);
8070f5c0
MD		 4051 if (ret)
4052 goto end;
b9074a1b
MD		 4053 if (event->ctx) {
4054 ret = lttng_metadata_printf(session,
4055 " };\n");
4056 if (ret)
4057 goto end;
4058 }
8070f5c0
MD		 4059
4060 ret = lttng_metadata_printf(session,
8070f5c0
MD		 4061 " fields := struct {\n"
4062 );
4063 if (ret)
4064 goto end;
4065
a90917c3 4066 ret = _lttng_fields_metadata_statedump(session, event);
c099397a
MD		 4067 if (ret)
4068 goto end;
4069
4070 /*
4071 * LTTng space reservation can only reserve multiples of the
4072 * byte size.
4073 */
4074 ret = lttng_metadata_printf(session,
9115fbdc
MD		 4075 " };\n"
4076 "};\n\n");
c099397a
MD		 4077 if (ret)
4078 goto end;
4079
c099397a
MD		 4080 event->metadata_dumped = 1;
4081end:
8b97fd42 4082 lttng_metadata_end(session);
c099397a
MD		 4083 return ret;
4084
4085}
4086
d83004aa
JD		 4087/*
4088 * Must be called with sessions_mutex held.
8b97fd42
MD		 4089 * The entire channel metadata is printed as a single atomic metadata
4090 * transaction.
d83004aa 4091 */
c099397a 4092static
a90917c3
MD		 4093int _lttng_channel_metadata_statedump(struct lttng_session *session,
4094 struct lttng_channel *chan)
c099397a
MD		 4095{
4096 int ret = 0;
4097
585e5dcc 4098 if (chan->metadata_dumped || !LTTNG_READ_ONCE(session->active))
c099397a 4099 return 0;
d83004aa
JD		 4100
4101 if (chan->channel_type == METADATA_CHANNEL)
c099397a
MD		 4102 return 0;
4103
8b97fd42
MD		 4104 lttng_metadata_begin(session);
4105
c099397a
MD		 4106 WARN_ON_ONCE(!chan->header_type);
4107 ret = lttng_metadata_printf(session,
4108 "stream {\n"
4109 " id = %u;\n"
9115fbdc 4110 " event.header := %s;\n"
b9074a1b 4111 " packet.context := struct packet_context;\n",
c099397a
MD		 4112 chan->id,
4113 chan->header_type == 1 ? "struct event_header_compact" :
4114 "struct event_header_large");
4115 if (ret)
4116 goto end;
4117
b9074a1b
MD		 4118 if (chan->ctx) {
4119 ret = lttng_metadata_printf(session,
4120 " event.context := struct {\n");
4121 if (ret)
4122 goto end;
4123 }
a90917c3 4124 ret = _lttng_context_metadata_statedump(session, chan->ctx);
8070f5c0
MD		 4125 if (ret)
4126 goto end;
b9074a1b
MD		 4127 if (chan->ctx) {
4128 ret = lttng_metadata_printf(session,
4129 " };\n");
4130 if (ret)
4131 goto end;
4132 }
8070f5c0
MD		 4133
4134 ret = lttng_metadata_printf(session,
b9074a1b 4135 "};\n\n");
8070f5c0 4136
c099397a
MD		 4137 chan->metadata_dumped = 1;
4138end:
8b97fd42 4139 lttng_metadata_end(session);
c099397a
MD		 4140 return ret;
4141}
4142
d83004aa
JD		 4143/*
4144 * Must be called with sessions_mutex held.
4145 */
9115fbdc 4146static
a90917c3 4147int _lttng_stream_packet_context_declare(struct lttng_session *session)
9115fbdc
MD		 4148{
4149 return lttng_metadata_printf(session,
4150 "struct packet_context {\n"
a3ccff4f
MD		 4151 " uint64_clock_monotonic_t timestamp_begin;\n"
4152 " uint64_clock_monotonic_t timestamp_end;\n"
576ca06a
MD		 4153 " uint64_t content_size;\n"
4154 " uint64_t packet_size;\n"
5b3cf4f9 4155 " uint64_t packet_seq_num;\n"
a9afe705 4156 " unsigned long events_discarded;\n"
9115fbdc 4157 " uint32_t cpu_id;\n"
c6dfdf6f 4158 "};\n\n"
9115fbdc
MD		 4159 );
4160}
4161
4162/*
4163 * Compact header:
4164 * id: range: 0 - 30.
4165 * id 31 is reserved to indicate an extended header.
4166 *
4167 * Large header:
4168 * id: range: 0 - 65534.
4169 * id 65535 is reserved to indicate an extended header.
d83004aa
JD		 4170 *
4171 * Must be called with sessions_mutex held.
9115fbdc
MD		 4172 */
4173static
a90917c3 4174int _lttng_event_header_declare(struct lttng_session *session)
9115fbdc
MD		 4175{
4176 return lttng_metadata_printf(session,
4177 "struct event_header_compact {\n"
4178 " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
4179 " variant <id> {\n"
4180 " struct {\n"
a3ccff4f 4181 " uint27_clock_monotonic_t timestamp;\n"
9115fbdc
MD		 4182 " } compact;\n"
4183 " struct {\n"
4184 " uint32_t id;\n"
a3ccff4f 4185 " uint64_clock_monotonic_t timestamp;\n"
9115fbdc
MD		 4186 " } extended;\n"
4187 " } v;\n"
4188 "} align(%u);\n"
4189 "\n"
4190 "struct event_header_large {\n"
4191 " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
4192 " variant <id> {\n"
4193 " struct {\n"
a3ccff4f 4194 " uint32_clock_monotonic_t timestamp;\n"
9115fbdc
MD		 4195 " } compact;\n"
4196 " struct {\n"
4197 " uint32_t id;\n"
a3ccff4f 4198 " uint64_clock_monotonic_t timestamp;\n"
9115fbdc
MD		 4199 " } extended;\n"
4200 " } v;\n"
4201 "} align(%u);\n\n",
a90917c3
MD		 4202 lttng_alignof(uint32_t) * CHAR_BIT,
4203 lttng_alignof(uint16_t) * CHAR_BIT
9115fbdc
MD		 4204 );
4205}
4206
a3ccff4f
MD		 4207 /*
4208 * Approximation of NTP time of day to clock monotonic correlation,
4209 * taken at start of trace.
4210 * Yes, this is only an approximation. Yes, we can (and will) do better
4211 * in future versions.
5283350b
MD		 4212 * This function may return a negative offset. It may happen if the
4213 * system sets the REALTIME clock to 0 after boot.
3636085f
MJ		 4214 *
4215 * Use 64bit timespec on kernels that have it, this makes 32bit arch
4216 * y2038 compliant.
a3ccff4f
MD		 4217 */
4218static
8967b2a3 4219int64_t measure_clock_offset(void)
a3ccff4f 4220{
dcb93448 4221 uint64_t monotonic_avg, monotonic[2], realtime;
2754583e 4222 uint64_t tcf = trace_clock_freq();
dcb93448 4223 int64_t offset;
a3ccff4f 4224 unsigned long flags;
3636085f
MJ		 4225#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
4226 struct timespec64 rts = { 0, 0 };
4227#else
4228 struct timespec rts = { 0, 0 };
4229#endif
a3ccff4f
MD		 4230
4231 /* Disable interrupts to increase correlation precision. */
4232 local_irq_save(flags);
4233 monotonic[0] = trace_clock_read64();
3636085f
MJ		 4234#ifdef LTTNG_KERNEL_HAS_TIMESPEC64
4235 ktime_get_real_ts64(&rts);
4236#else
216b6baa 4237 getnstimeofday(&rts);
3636085f 4238#endif
a3ccff4f
MD		 4239 monotonic[1] = trace_clock_read64();
4240 local_irq_restore(flags);
4241
dcb93448 4242 monotonic_avg = (monotonic[0] + monotonic[1]) >> 1;
2754583e
MD		 4243 realtime = (uint64_t) rts.tv_sec * tcf;
4244 if (tcf == NSEC_PER_SEC) {
4245 realtime += rts.tv_nsec;
4246 } else {
4247 uint64_t n = rts.tv_nsec * tcf;
4248
4249 do_div(n, NSEC_PER_SEC);
4250 realtime += n;
4251 }
dcb93448 4252 offset = (int64_t) realtime - monotonic_avg;
a3ccff4f
MD		 4253 return offset;
4254}
4255
3eb95be4
JR		 4256static
4257int print_escaped_ctf_string(struct lttng_session *session, const char *string)
4258{
0f3eaad4 4259 int ret = 0;
3eb95be4
JR		 4260 size_t i;
4261 char cur;
4262
4263 i = 0;
4264 cur = string[i];
4265 while (cur != '\0') {
4266 switch (cur) {
4267 case '\n':
4268 ret = lttng_metadata_printf(session, "%s", "\\n");
4269 break;
4270 case '\\':
4271 case '"':
4272 ret = lttng_metadata_printf(session, "%c", '\\');
4273 if (ret)
4274 goto error;
4275 /* We still print the current char */
4276 /* Fallthrough */
4277 default:
4278 ret = lttng_metadata_printf(session, "%c", cur);
4279 break;
4280 }
4281
4282 if (ret)
4283 goto error;
4284
4285 cur = string[++i];
4286 }
4287error:
4288 return ret;
4289}
4290
4291static
1c88f269
JR		 4292int print_metadata_escaped_field(struct lttng_session *session, const char *field,
4293 const char *field_value)
3eb95be4
JR		 4294{
4295 int ret;
4296
1c88f269 4297 ret = lttng_metadata_printf(session, " %s = \"", field);
3eb95be4
JR		 4298 if (ret)
4299 goto error;
4300
1c88f269 4301 ret = print_escaped_ctf_string(session, field_value);
3eb95be4
JR		 4302 if (ret)
4303 goto error;
4304
4305 ret = lttng_metadata_printf(session, "\";\n");
4306
4307error:
4308 return ret;
4309}
4310
c099397a
MD		 4311/*
4312 * Output metadata into this session's metadata buffers.
d83004aa 4313 * Must be called with sessions_mutex held.
c099397a
MD		 4314 */
4315static
a90917c3 4316int _lttng_session_metadata_statedump(struct lttng_session *session)
c099397a 4317{
30bdb6e4 4318 unsigned char *uuid_c = session->uuid.b;
a82c63f1 4319 unsigned char uuid_s[37], clock_uuid_s[BOOT_ID_LEN];
c88f762e 4320 const char *product_uuid;
a90917c3
MD		 4321 struct lttng_channel *chan;
4322 struct lttng_event *event;
c099397a
MD		 4323 int ret = 0;
4324
585e5dcc 4325 if (!LTTNG_READ_ONCE(session->active))
c099397a 4326 return 0;
8b97fd42
MD		 4327
4328 lttng_metadata_begin(session);
4329
c099397a
MD		 4330 if (session->metadata_dumped)
4331 goto skip_session;
c099397a 4332
d793d5e1 4333 snprintf(uuid_s, sizeof(uuid_s),
30bdb6e4
MD		 4334 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
4335 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
4336 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
4337 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
4338 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
d793d5e1
MD		 4339
4340 ret = lttng_metadata_printf(session,
9115fbdc
MD		 4341 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
4342 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
4343 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
4344 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
a9afe705 4345 "typealias integer { size = %u; align = %u; signed = false; } := unsigned long;\n"
9115fbdc
MD		 4346 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
4347 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
d793d5e1
MD		 4348 "\n"
4349 "trace {\n"
4350 " major = %u;\n"
4351 " minor = %u;\n"
30bdb6e4 4352 " uuid = \"%s\";\n"
d793d5e1
MD		 4353 " byte_order = %s;\n"
4354 " packet.header := struct {\n"
4355 " uint32_t magic;\n"
1ec3f75a 4356 " uint8_t uuid[16];\n"
d793d5e1 4357 " uint32_t stream_id;\n"
5594698f 4358 " uint64_t stream_instance_id;\n"
0eb25f58 4359 " };\n"
d793d5e1 4360 "};\n\n",
a90917c3
MD		 4361 lttng_alignof(uint8_t) * CHAR_BIT,
4362 lttng_alignof(uint16_t) * CHAR_BIT,
4363 lttng_alignof(uint32_t) * CHAR_BIT,
4364 lttng_alignof(uint64_t) * CHAR_BIT,
a9afe705
MD		 4365 sizeof(unsigned long) * CHAR_BIT,
4366 lttng_alignof(unsigned long) * CHAR_BIT,
c6c9e10f
MD		 4367 CTF_SPEC_MAJOR,
4368 CTF_SPEC_MINOR,
d793d5e1 4369 uuid_s,
5214fa50 4370#if __BYTE_ORDER == __BIG_ENDIAN
d793d5e1
MD		 4371 "be"
4372#else
4373 "le"
4374#endif
4375 );
4376 if (ret)
4377 goto end;
4378
99dc9597
MD		 4379 ret = lttng_metadata_printf(session,
4380 "env {\n"
a6058143 4381 " hostname = \"%s\";\n"
c6c9e10f 4382 " domain = \"kernel\";\n"
99dc9597 4383 " sysname = \"%s\";\n"
c6c9e10f
MD		 4384 " kernel_release = \"%s\";\n"
4385 " kernel_version = \"%s\";\n"
4386 " tracer_name = \"lttng-modules\";\n"
4387 " tracer_major = %d;\n"
4388 " tracer_minor = %d;\n"
4389 " tracer_patchlevel = %d;\n"
3eb95be4 4390 " trace_buffering_scheme = \"global\";\n",
3d0d43db 4391 current->nsproxy->uts_ns->name.nodename,
99dc9597
MD		 4392 utsname()->sysname,
4393 utsname()->release,
c6c9e10f
MD		 4394 utsname()->version,
4395 LTTNG_MODULES_MAJOR_VERSION,
4396 LTTNG_MODULES_MINOR_VERSION,
4397 LTTNG_MODULES_PATCHLEVEL_VERSION
99dc9597
MD		 4398 );
4399 if (ret)
4400 goto end;
4401
1c88f269
JR		 4402 ret = print_metadata_escaped_field(session, "trace_name", session->name);
4403 if (ret)
4404 goto end;
4405 ret = print_metadata_escaped_field(session, "trace_creation_datetime",
4406 session->creation_time);
3eb95be4
JR		 4407 if (ret)
4408 goto end;
4409
c88f762e
GB		 4410 /* Add the product UUID to the 'env' section */
4411 product_uuid = dmi_get_system_info(DMI_PRODUCT_UUID);
4412 if (product_uuid) {
4413 ret = lttng_metadata_printf(session,
4414 " product_uuid = \"%s\";\n",
4415 product_uuid
4416 );
4417 if (ret)
4418 goto end;
4419 }
4420
4421 /* Close the 'env' section */
3eb95be4
JR		 4422 ret = lttng_metadata_printf(session, "};\n\n");
4423 if (ret)
4424 goto end;
4425
a3ccff4f
MD		 4426 ret = lttng_metadata_printf(session,
4427 "clock {\n"
2754583e
MD		 4428 " name = \"%s\";\n",
4429 trace_clock_name()
a82c63f1
MD		 4430 );
4431 if (ret)
4432 goto end;
4433
4434 if (!trace_clock_uuid(clock_uuid_s)) {
4435 ret = lttng_metadata_printf(session,
7c27cb17 4436 " uuid = \"%s\";\n",
a82c63f1
MD		 4437 clock_uuid_s
4438 );
4439 if (ret)
4440 goto end;
4441 }
4442
4443 ret = lttng_metadata_printf(session,
2754583e 4444 " description = \"%s\";\n"
a3ccff4f
MD		 4445 " freq = %llu; /* Frequency, in Hz */\n"
4446 " /* clock value offset from Epoch is: offset * (1/freq) */\n"
8967b2a3 4447 " offset = %lld;\n"
a3ccff4f 4448 "};\n\n",
2754583e 4449 trace_clock_description(),
a3ccff4f 4450 (unsigned long long) trace_clock_freq(),
8967b2a3 4451 (long long) measure_clock_offset()
a3ccff4f
MD		 4452 );
4453 if (ret)
4454 goto end;
4455
4456 ret = lttng_metadata_printf(session,
4457 "typealias integer {\n"
4458 " size = 27; align = 1; signed = false;\n"
2754583e 4459 " map = clock.%s.value;\n"
a3ccff4f
MD		 4460 "} := uint27_clock_monotonic_t;\n"
4461 "\n"
4462 "typealias integer {\n"
4463 " size = 32; align = %u; signed = false;\n"
2754583e 4464 " map = clock.%s.value;\n"
a3ccff4f
MD		 4465 "} := uint32_clock_monotonic_t;\n"
4466 "\n"
4467 "typealias integer {\n"
4468 " size = 64; align = %u; signed = false;\n"
2754583e 4469 " map = clock.%s.value;\n"
a3ccff4f 4470 "} := uint64_clock_monotonic_t;\n\n",
2754583e 4471 trace_clock_name(),
a3ccff4f 4472 lttng_alignof(uint32_t) * CHAR_BIT,
2754583e
MD		 4473 trace_clock_name(),
4474 lttng_alignof(uint64_t) * CHAR_BIT,
4475 trace_clock_name()
a3ccff4f
MD		 4476 );
4477 if (ret)
4478 goto end;
4479
a90917c3 4480 ret = _lttng_stream_packet_context_declare(session);
9115fbdc
MD		 4481 if (ret)
4482 goto end;
4483
a90917c3 4484 ret = _lttng_event_header_declare(session);
9115fbdc
MD		 4485 if (ret)
4486 goto end;
4487
c099397a
MD		 4488skip_session:
4489 list_for_each_entry(chan, &session->chan, list) {
a90917c3 4490 ret = _lttng_channel_metadata_statedump(session, chan);
c099397a
MD		 4491 if (ret)
4492 goto end;
4493 }
4494
4495 list_for_each_entry(event, &session->events, list) {
0c023c01
MD		 4496 /* Skip counter container. */
4497 if (event->container->type != LTTNG_EVENT_CONTAINER_CHANNEL)
4498 continue;
4499 ret = _lttng_event_metadata_statedump(session, event);
c099397a
MD		 4500 if (ret)
4501 goto end;
4502 }
4503 session->metadata_dumped = 1;
4504end:
8b97fd42 4505 lttng_metadata_end(session);
c099397a
MD		 4506 return ret;
4507}
4508
c0e31d2e 4509/**
a90917c3 4510 * lttng_transport_register - LTT transport registration
c0e31d2e
MD		 4511 * @transport: transport structure
4512 *
4513 * Registers a transport which can be used as output to extract the data out of
4514 * LTTng. The module calling this registration function must ensure that no
4515 * trap-inducing code will be executed by the transport functions. E.g.
263b6c88 4516 * vmalloc_sync_mappings() must be called between a vmalloc and the moment the memory
c0e31d2e 4517 * is made visible to the transport function. This registration acts as a
263b6c88 4518 * vmalloc_sync_mappings. Therefore, only if the module allocates virtual memory
c0e31d2e
MD		 4519 * after its registration must it synchronize the TLBs.
4520 */
a90917c3 4521void lttng_transport_register(struct lttng_transport *transport)
c0e31d2e
MD		 4522{
4523 /*
4524 * Make sure no page fault can be triggered by the module about to be
4525 * registered. We deal with this here so we don't have to call
263b6c88 4526 * vmalloc_sync_mappings() in each module's init.
c0e31d2e 4527 */
263b6c88 4528 wrapper_vmalloc_sync_mappings();
c0e31d2e
MD		 4529
4530 mutex_lock(&sessions_mutex);
a90917c3 4531 list_add_tail(&transport->node, &lttng_transport_list);
c0e31d2e
MD		 4532 mutex_unlock(&sessions_mutex);
4533}
a90917c3 4534EXPORT_SYMBOL_GPL(lttng_transport_register);
c0e31d2e
MD		 4535
4536/**
a90917c3 4537 * lttng_transport_unregister - LTT transport unregistration
c0e31d2e
MD		 4538 * @transport: transport structure
4539 */
a90917c3 4540void lttng_transport_unregister(struct lttng_transport *transport)
c0e31d2e
MD		 4541{
4542 mutex_lock(&sessions_mutex);
4543 list_del(&transport->node);
4544 mutex_unlock(&sessions_mutex);
4545}
a90917c3 4546EXPORT_SYMBOL_GPL(lttng_transport_unregister);
c0e31d2e 4547
a101fa10
MD		 4548void lttng_counter_transport_register(struct lttng_counter_transport *transport)
4549{
4550 /*
4551 * Make sure no page fault can be triggered by the module about to be
4552 * registered. We deal with this here so we don't have to call
4553 * vmalloc_sync_mappings() in each module's init.
4554 */
4555 wrapper_vmalloc_sync_mappings();
4556
4557 mutex_lock(&sessions_mutex);
4558 list_add_tail(&transport->node, &lttng_counter_transport_list);
4559 mutex_unlock(&sessions_mutex);
4560}
4561EXPORT_SYMBOL_GPL(lttng_counter_transport_register);
4562
4563void lttng_counter_transport_unregister(struct lttng_counter_transport *transport)
4564{
4565 mutex_lock(&sessions_mutex);
4566 list_del(&transport->node);
4567 mutex_unlock(&sessions_mutex);
4568}
4569EXPORT_SYMBOL_GPL(lttng_counter_transport_unregister);
4570
5f4c791e 4571#if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0))
1e367326
MD		 4572
4573enum cpuhp_state lttng_hp_prepare;
4574enum cpuhp_state lttng_hp_online;
4575
4576static int lttng_hotplug_prepare(unsigned int cpu, struct hlist_node *node)
4577{
4578 struct lttng_cpuhp_node *lttng_node;
4579
4580 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
4581 switch (lttng_node->component) {
4582 case LTTNG_RING_BUFFER_FRONTEND:
4583 return 0;
4584 case LTTNG_RING_BUFFER_BACKEND:
4585 return lttng_cpuhp_rb_backend_prepare(cpu, lttng_node);
4586 case LTTNG_RING_BUFFER_ITER:
4587 return 0;
4588 case LTTNG_CONTEXT_PERF_COUNTERS:
4589 return 0;
4590 default:
4591 return -EINVAL;
4592 }
4593}
4594
4595static int lttng_hotplug_dead(unsigned int cpu, struct hlist_node *node)
4596{
4597 struct lttng_cpuhp_node *lttng_node;
4598
4599 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
4600 switch (lttng_node->component) {
4601 case LTTNG_RING_BUFFER_FRONTEND:
4602 return lttng_cpuhp_rb_frontend_dead(cpu, lttng_node);
4603 case LTTNG_RING_BUFFER_BACKEND:
4604 return 0;
4605 case LTTNG_RING_BUFFER_ITER:
4606 return 0;
4607 case LTTNG_CONTEXT_PERF_COUNTERS:
4608 return lttng_cpuhp_perf_counter_dead(cpu, lttng_node);
4609 default:
4610 return -EINVAL;
4611 }
4612}
4613
4614static int lttng_hotplug_online(unsigned int cpu, struct hlist_node *node)
4615{
4616 struct lttng_cpuhp_node *lttng_node;
4617
4618 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
4619 switch (lttng_node->component) {
4620 case LTTNG_RING_BUFFER_FRONTEND:
4621 return lttng_cpuhp_rb_frontend_online(cpu, lttng_node);
4622 case LTTNG_RING_BUFFER_BACKEND:
4623 return 0;
4624 case LTTNG_RING_BUFFER_ITER:
4625 return lttng_cpuhp_rb_iter_online(cpu, lttng_node);
4626 case LTTNG_CONTEXT_PERF_COUNTERS:
4627 return lttng_cpuhp_perf_counter_online(cpu, lttng_node);
4628 default:
4629 return -EINVAL;
4630 }
4631}
4632
4633static int lttng_hotplug_offline(unsigned int cpu, struct hlist_node *node)
4634{
4635 struct lttng_cpuhp_node *lttng_node;
4636
4637 lttng_node = container_of(node, struct lttng_cpuhp_node, node);
4638 switch (lttng_node->component) {
4639 case LTTNG_RING_BUFFER_FRONTEND:
4640 return lttng_cpuhp_rb_frontend_offline(cpu, lttng_node);
4641 case LTTNG_RING_BUFFER_BACKEND:
4642 return 0;
4643 case LTTNG_RING_BUFFER_ITER:
4644 return 0;
4645 case LTTNG_CONTEXT_PERF_COUNTERS:
4646 return 0;
4647 default:
4648 return -EINVAL;
4649 }
4650}
4651
4652static int __init lttng_init_cpu_hotplug(void)
4653{
4654 int ret;
4655
4656 ret = cpuhp_setup_state_multi(CPUHP_BP_PREPARE_DYN, "lttng:prepare",
4657 lttng_hotplug_prepare,
4658 lttng_hotplug_dead);
4659 if (ret < 0) {
4660 return ret;
4661 }
4662 lttng_hp_prepare = ret;
4663 lttng_rb_set_hp_prepare(ret);
4664
4665 ret = cpuhp_setup_state_multi(CPUHP_AP_ONLINE_DYN, "lttng:online",
4666 lttng_hotplug_online,
4667 lttng_hotplug_offline);
4668 if (ret < 0) {
4669 cpuhp_remove_multi_state(lttng_hp_prepare);
4670 lttng_hp_prepare = 0;
4671 return ret;
4672 }
4673 lttng_hp_online = ret;
4674 lttng_rb_set_hp_online(ret);
4675
4676 return 0;
4677}
4678
4679static void __exit lttng_exit_cpu_hotplug(void)
4680{
4681 lttng_rb_set_hp_online(0);
4682 cpuhp_remove_multi_state(lttng_hp_online);
4683 lttng_rb_set_hp_prepare(0);
4684 cpuhp_remove_multi_state(lttng_hp_prepare);
4685}
4686
5f4c791e 4687#else /* #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
1e367326
MD		 4688static int lttng_init_cpu_hotplug(void)
4689{
4690 return 0;
4691}
4692static void lttng_exit_cpu_hotplug(void)
4693{
4694}
5f4c791e 4695#endif /* #else #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(4,10,0)) */
1e367326
MD		 4696
4697
a90917c3 4698static int __init lttng_events_init(void)
4e3c1b9b 4699{
1c25284c
MD		 4700 int ret;
4701
453b2495
JD		 4702 ret = wrapper_lttng_fixup_sig(THIS_MODULE);
4703 if (ret)
4704 return ret;
389d7070 4705 ret = wrapper_get_pfnblock_flags_mask_init();
36561775
MD		 4706 if (ret)
4707 return ret;
4708 ret = wrapper_get_pageblock_flags_mask_init();
114667d5
MD		 4709 if (ret)
4710 return ret;
4711 ret = lttng_probes_init();
389d7070
MD		 4712 if (ret)
4713 return ret;
07dfc1d0 4714 ret = lttng_context_init();
20591cf7
MD		 4715 if (ret)
4716 return ret;
07dfc1d0
MD		 4717 ret = lttng_tracepoint_init();
4718 if (ret)
4719 goto error_tp;
a90917c3 4720 event_cache = KMEM_CACHE(lttng_event, 0);
20591cf7
MD		 4721 if (!event_cache) {
4722 ret = -ENOMEM;
dffef45d
FD		 4723 goto error_kmem_event;
4724 }
4725 event_notifier_cache = KMEM_CACHE(lttng_event_notifier, 0);
4726 if (!event_notifier_cache) {
4727 ret = -ENOMEM;
4728 goto error_kmem_event_notifier;
20591cf7 4729 }
80996790 4730 ret = lttng_abi_init();
02119ee5
MD		 4731 if (ret)
4732 goto error_abi;
0c956676
MD		 4733 ret = lttng_logger_init();
4734 if (ret)
4735 goto error_logger;
1e367326
MD		 4736 ret = lttng_init_cpu_hotplug();
4737 if (ret)
4738 goto error_hotplug;
101215b7 4739 printk(KERN_NOTICE "LTTng: Loaded modules v%s.%s.%s%s (%s)%s%s\n",
489de24b
MJ		 4740 __stringify(LTTNG_MODULES_MAJOR_VERSION),
4741 __stringify(LTTNG_MODULES_MINOR_VERSION),
4742 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
4743 LTTNG_MODULES_EXTRAVERSION,
101215b7
MJ		 4744 LTTNG_VERSION_NAME,
4745#ifdef LTTNG_EXTRA_VERSION_GIT
4746 LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
4747#else
4748 "",
4749#endif
4750#ifdef LTTNG_EXTRA_VERSION_NAME
4751 LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
4752#else
4753 "");
4754#endif
4e3c1b9b 4755 return 0;
0c956676 4756
1e367326
MD		 4757error_hotplug:
4758 lttng_logger_exit();
0c956676
MD		 4759error_logger:
4760 lttng_abi_exit();
02119ee5 4761error_abi:
dffef45d
FD		 4762 kmem_cache_destroy(event_notifier_cache);
4763error_kmem_event_notifier:
1c25284c 4764 kmem_cache_destroy(event_cache);
dffef45d 4765error_kmem_event:
20591cf7 4766 lttng_tracepoint_exit();
07dfc1d0
MD		 4767error_tp:
4768 lttng_context_exit();
101215b7 4769 printk(KERN_NOTICE "LTTng: Failed to load modules v%s.%s.%s%s (%s)%s%s\n",
489de24b
MJ		 4770 __stringify(LTTNG_MODULES_MAJOR_VERSION),
4771 __stringify(LTTNG_MODULES_MINOR_VERSION),
4772 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
4773 LTTNG_MODULES_EXTRAVERSION,
101215b7
MJ		 4774 LTTNG_VERSION_NAME,
4775#ifdef LTTNG_EXTRA_VERSION_GIT
4776 LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
4777#else
4778 "",
4779#endif
4780#ifdef LTTNG_EXTRA_VERSION_NAME
4781 LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
4782#else
4783 "");
4784#endif
1c25284c 4785 return ret;
4e3c1b9b
MD		 4786}
4787
a90917c3 4788module_init(lttng_events_init);
11b5a3c2 4789
a90917c3 4790static void __exit lttng_events_exit(void)
4e3c1b9b 4791{
a90917c3 4792 struct lttng_session *session, *tmpsession;
92e94819 4793
1e367326 4794 lttng_exit_cpu_hotplug();
0c956676 4795 lttng_logger_exit();
80996790 4796 lttng_abi_exit();
92e94819 4797 list_for_each_entry_safe(session, tmpsession, &sessions, list)
a90917c3 4798 lttng_session_destroy(session);
11b5a3c2 4799 kmem_cache_destroy(event_cache);
dffef45d 4800 kmem_cache_destroy(event_notifier_cache);
20591cf7 4801 lttng_tracepoint_exit();
07dfc1d0 4802 lttng_context_exit();
101215b7 4803 printk(KERN_NOTICE "LTTng: Unloaded modules v%s.%s.%s%s (%s)%s%s\n",
489de24b
MJ		 4804 __stringify(LTTNG_MODULES_MAJOR_VERSION),
4805 __stringify(LTTNG_MODULES_MINOR_VERSION),
4806 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION),
4807 LTTNG_MODULES_EXTRAVERSION,
101215b7
MJ		 4808 LTTNG_VERSION_NAME,
4809#ifdef LTTNG_EXTRA_VERSION_GIT
4810 LTTNG_EXTRA_VERSION_GIT[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_GIT,
4811#else
4812 "",
4813#endif
4814#ifdef LTTNG_EXTRA_VERSION_NAME
4815 LTTNG_EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " LTTNG_EXTRA_VERSION_NAME);
4816#else
4817 "");
4818#endif
4e3c1b9b 4819}
92e94819 4820
a90917c3 4821module_exit(lttng_events_exit);
11b5a3c2 4822
7ca11e77 4823#include <generated/patches.h>
101215b7
MJ		 4824#ifdef LTTNG_EXTRA_VERSION_GIT
4825MODULE_INFO(extra_version_git, LTTNG_EXTRA_VERSION_GIT);
4826#endif
4827#ifdef LTTNG_EXTRA_VERSION_NAME
4828MODULE_INFO(extra_version_name, LTTNG_EXTRA_VERSION_NAME);
4829#endif
92e94819
MD		 4830MODULE_LICENSE("GPL and additional rights");
4831MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
1c124020 4832MODULE_DESCRIPTION("LTTng tracer");
9a9973ef
MD		 4833MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
4834 __stringify(LTTNG_MODULES_MINOR_VERSION) "."
309370e2
MD		 4835 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
4836 LTTNG_MODULES_EXTRAVERSION);
LTTng modules - Deliverables
This page took 0.302288 seconds and 5 git commands to generate.