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