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