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