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