projects / lttng-modules.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Implement syscall wildcard support
[lttng-modules.git] / lttng-events.c
1 /*
2 * lttng-events.c
3 *
4 * Holds LTTng per-session event registry.
5 *
6 * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; only
11 * version 2.1 of the License.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 */
22
23 #include <linux/module.h>
24 #include <linux/mutex.h>
25 #include <linux/sched.h>
26 #include <linux/slab.h>
27 #include <linux/jiffies.h>
28 #include <linux/utsname.h>
29 #include <linux/err.h>
30 #include <linux/seq_file.h>
31 #include <linux/file.h>
32 #include <linux/anon_inodes.h>
33 #include "wrapper/file.h"
34 #include <linux/jhash.h>
35
36 #include "wrapper/uuid.h"
37 #include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */
38 #include "wrapper/random.h"
39 #include "wrapper/tracepoint.h"
40 #include "wrapper/list.h"
41 #include "lttng-kernel-version.h"
42 #include "lttng-events.h"
43 #include "lttng-tracer.h"
44 #include "lttng-abi-old.h"
45
46 #define METADATA_CACHE_DEFAULT_SIZE 4096
47
48 static LIST_HEAD(sessions);
49 static LIST_HEAD(lttng_transport_list);
50 /*
51 * Protect the sessions and metadata caches.
52 */
53 static DEFINE_MUTEX(sessions_mutex);
54 static struct kmem_cache *event_cache;
55
56 static void lttng_session_lazy_sync_enablers(struct lttng_session *session);
57 static void lttng_session_sync_enablers(struct lttng_session *session);
58 static void lttng_enabler_destroy(struct lttng_enabler *enabler);
59
60 static void _lttng_event_destroy(struct lttng_event *event);
61 static void _lttng_channel_destroy(struct lttng_channel *chan);
62 static int _lttng_event_unregister(struct lttng_event *event);
63 static
64 int _lttng_event_metadata_statedump(struct lttng_session *session,
65 struct lttng_channel *chan,
66 struct lttng_event *event);
67 static
68 int _lttng_session_metadata_statedump(struct lttng_session *session);
69 static
70 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream);
71
72 void synchronize_trace(void)
73 {
74 synchronize_sched();
75 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0))
76 #ifdef CONFIG_PREEMPT_RT_FULL
77 synchronize_rcu();
78 #endif
79 #else /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
80 #ifdef CONFIG_PREEMPT_RT
81 synchronize_rcu();
82 #endif
83 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)) */
84 }
85
86 void lttng_lock_sessions(void)
87 {
88 mutex_lock(&sessions_mutex);
89 }
90
91 void lttng_unlock_sessions(void)
92 {
93 mutex_unlock(&sessions_mutex);
94 }
95
96 /*
97 * Called with sessions lock held.
98 */
99 int lttng_session_active(void)
100 {
101 struct lttng_session *iter;
102
103 list_for_each_entry(iter, &sessions, list) {
104 if (iter->active)
105 return 1;
106 }
107 return 0;
108 }
109
110 struct lttng_session *lttng_session_create(void)
111 {
112 struct lttng_session *session;
113 struct lttng_metadata_cache *metadata_cache;
114 int i;
115
116 mutex_lock(&sessions_mutex);
117 session = kzalloc(sizeof(struct lttng_session), GFP_KERNEL);
118 if (!session)
119 goto err;
120 INIT_LIST_HEAD(&session->chan);
121 INIT_LIST_HEAD(&session->events);
122 uuid_le_gen(&session->uuid);
123
124 metadata_cache = kzalloc(sizeof(struct lttng_metadata_cache),
125 GFP_KERNEL);
126 if (!metadata_cache)
127 goto err_free_session;
128 metadata_cache->data = kzalloc(METADATA_CACHE_DEFAULT_SIZE,
129 GFP_KERNEL);
130 if (!metadata_cache->data)
131 goto err_free_cache;
132 metadata_cache->cache_alloc = METADATA_CACHE_DEFAULT_SIZE;
133 kref_init(&metadata_cache->refcount);
134 session->metadata_cache = metadata_cache;
135 INIT_LIST_HEAD(&metadata_cache->metadata_stream);
136 memcpy(&metadata_cache->uuid, &session->uuid,
137 sizeof(metadata_cache->uuid));
138 INIT_LIST_HEAD(&session->enablers_head);
139 for (i = 0; i < LTTNG_EVENT_HT_SIZE; i++)
140 INIT_HLIST_HEAD(&session->events_ht.table[i]);
141 list_add(&session->list, &sessions);
142 mutex_unlock(&sessions_mutex);
143 return session;
144
145 err_free_cache:
146 kfree(metadata_cache);
147 err_free_session:
148 kfree(session);
149 err:
150 mutex_unlock(&sessions_mutex);
151 return NULL;
152 }
153
154 void metadata_cache_destroy(struct kref *kref)
155 {
156 struct lttng_metadata_cache *cache =
157 container_of(kref, struct lttng_metadata_cache, refcount);
158 kfree(cache->data);
159 kfree(cache);
160 }
161
162 void lttng_session_destroy(struct lttng_session *session)
163 {
164 struct lttng_channel *chan, *tmpchan;
165 struct lttng_event *event, *tmpevent;
166 struct lttng_metadata_stream *metadata_stream;
167 struct lttng_enabler *enabler, *tmpenabler;
168 int ret;
169
170 mutex_lock(&sessions_mutex);
171 ACCESS_ONCE(session->active) = 0;
172 list_for_each_entry(chan, &session->chan, list) {
173 ret = lttng_syscalls_unregister(chan);
174 WARN_ON(ret);
175 }
176 list_for_each_entry(event, &session->events, list) {
177 ret = _lttng_event_unregister(event);
178 WARN_ON(ret);
179 }
180 synchronize_trace(); /* Wait for in-flight events to complete */
181 list_for_each_entry_safe(enabler, tmpenabler,
182 &session->enablers_head, node)
183 lttng_enabler_destroy(enabler);
184 list_for_each_entry_safe(event, tmpevent, &session->events, list)
185 _lttng_event_destroy(event);
186 list_for_each_entry_safe(chan, tmpchan, &session->chan, list) {
187 BUG_ON(chan->channel_type == METADATA_CHANNEL);
188 _lttng_channel_destroy(chan);
189 }
190 list_for_each_entry(metadata_stream, &session->metadata_cache->metadata_stream, list)
191 _lttng_metadata_channel_hangup(metadata_stream);
192 if (session->pid_tracker)
193 lttng_pid_tracker_destroy(session->pid_tracker);
194 kref_put(&session->metadata_cache->refcount, metadata_cache_destroy);
195 list_del(&session->list);
196 mutex_unlock(&sessions_mutex);
197 kfree(session);
198 }
199
200 int lttng_session_enable(struct lttng_session *session)
201 {
202 int ret = 0;
203 struct lttng_channel *chan;
204
205 mutex_lock(&sessions_mutex);
206 if (session->active) {
207 ret = -EBUSY;
208 goto end;
209 }
210
211 /* Set transient enabler state to "enabled" */
212 session->tstate = 1;
213
214 /*
215 * Snapshot the number of events per channel to know the type of header
216 * we need to use.
217 */
218 list_for_each_entry(chan, &session->chan, list) {
219 if (chan->header_type)
220 continue; /* don't change it if session stop/restart */
221 if (chan->free_event_id < 31)
222 chan->header_type = 1; /* compact */
223 else
224 chan->header_type = 2; /* large */
225 }
226
227 /* We need to sync enablers with session before activation. */
228 lttng_session_sync_enablers(session);
229
230 ACCESS_ONCE(session->active) = 1;
231 ACCESS_ONCE(session->been_active) = 1;
232 ret = _lttng_session_metadata_statedump(session);
233 if (ret) {
234 ACCESS_ONCE(session->active) = 0;
235 goto end;
236 }
237 ret = lttng_statedump_start(session);
238 if (ret)
239 ACCESS_ONCE(session->active) = 0;
240 end:
241 mutex_unlock(&sessions_mutex);
242 return ret;
243 }
244
245 int lttng_session_disable(struct lttng_session *session)
246 {
247 int ret = 0;
248
249 mutex_lock(&sessions_mutex);
250 if (!session->active) {
251 ret = -EBUSY;
252 goto end;
253 }
254 ACCESS_ONCE(session->active) = 0;
255
256 /* Set transient enabler state to "disabled" */
257 session->tstate = 0;
258 lttng_session_sync_enablers(session);
259 end:
260 mutex_unlock(&sessions_mutex);
261 return ret;
262 }
263
264 int lttng_channel_enable(struct lttng_channel *channel)
265 {
266 int ret = 0;
267
268 mutex_lock(&sessions_mutex);
269 if (channel->channel_type == METADATA_CHANNEL) {
270 ret = -EPERM;
271 goto end;
272 }
273 if (channel->enabled) {
274 ret = -EEXIST;
275 goto end;
276 }
277 /* Set transient enabler state to "enabled" */
278 channel->tstate = 1;
279 lttng_session_sync_enablers(channel->session);
280 /* Set atomically the state to "enabled" */
281 ACCESS_ONCE(channel->enabled) = 1;
282 end:
283 mutex_unlock(&sessions_mutex);
284 return ret;
285 }
286
287 int lttng_channel_disable(struct lttng_channel *channel)
288 {
289 int ret = 0;
290
291 mutex_lock(&sessions_mutex);
292 if (channel->channel_type == METADATA_CHANNEL) {
293 ret = -EPERM;
294 goto end;
295 }
296 if (!channel->enabled) {
297 ret = -EEXIST;
298 goto end;
299 }
300 /* Set atomically the state to "disabled" */
301 ACCESS_ONCE(channel->enabled) = 0;
302 /* Set transient enabler state to "enabled" */
303 channel->tstate = 0;
304 lttng_session_sync_enablers(channel->session);
305 end:
306 mutex_unlock(&sessions_mutex);
307 return ret;
308 }
309
310 int lttng_event_enable(struct lttng_event *event)
311 {
312 int ret = 0;
313
314 mutex_lock(&sessions_mutex);
315 if (event->chan->channel_type == METADATA_CHANNEL) {
316 ret = -EPERM;
317 goto end;
318 }
319 if (event->enabled) {
320 ret = -EEXIST;
321 goto end;
322 }
323 ACCESS_ONCE(event->enabled) = 1;
324 lttng_session_sync_enablers(event->chan->session);
325 end:
326 mutex_unlock(&sessions_mutex);
327 return ret;
328 }
329
330 int lttng_event_disable(struct lttng_event *event)
331 {
332 int ret = 0;
333
334 mutex_lock(&sessions_mutex);
335 if (event->chan->channel_type == METADATA_CHANNEL) {
336 ret = -EPERM;
337 goto end;
338 }
339 if (!event->enabled) {
340 ret = -EEXIST;
341 goto end;
342 }
343 ACCESS_ONCE(event->enabled) = 0;
344 lttng_session_sync_enablers(event->chan->session);
345 end:
346 mutex_unlock(&sessions_mutex);
347 return ret;
348 }
349
350 static struct lttng_transport *lttng_transport_find(const char *name)
351 {
352 struct lttng_transport *transport;
353
354 list_for_each_entry(transport, &lttng_transport_list, node) {
355 if (!strcmp(transport->name, name))
356 return transport;
357 }
358 return NULL;
359 }
360
361 struct lttng_channel *lttng_channel_create(struct lttng_session *session,
362 const char *transport_name,
363 void *buf_addr,
364 size_t subbuf_size, size_t num_subbuf,
365 unsigned int switch_timer_interval,
366 unsigned int read_timer_interval,
367 enum channel_type channel_type)
368 {
369 struct lttng_channel *chan;
370 struct lttng_transport *transport = NULL;
371
372 mutex_lock(&sessions_mutex);
373 if (session->been_active && channel_type != METADATA_CHANNEL)
374 goto active; /* Refuse to add channel to active session */
375 transport = lttng_transport_find(transport_name);
376 if (!transport) {
377 printk(KERN_WARNING "LTTng transport %s not found\n",
378 transport_name);
379 goto notransport;
380 }
381 if (!try_module_get(transport->owner)) {
382 printk(KERN_WARNING "LTT : Can't lock transport module.\n");
383 goto notransport;
384 }
385 chan = kzalloc(sizeof(struct lttng_channel), GFP_KERNEL);
386 if (!chan)
387 goto nomem;
388 chan->session = session;
389 chan->id = session->free_chan_id++;
390 chan->ops = &transport->ops;
391 /*
392 * Note: the channel creation op already writes into the packet
393 * headers. Therefore the "chan" information used as input
394 * should be already accessible.
395 */
396 chan->chan = transport->ops.channel_create(transport_name,
397 chan, buf_addr, subbuf_size, num_subbuf,
398 switch_timer_interval, read_timer_interval);
399 if (!chan->chan)
400 goto create_error;
401 chan->tstate = 1;
402 chan->enabled = 1;
403 chan->transport = transport;
404 chan->channel_type = channel_type;
405 list_add(&chan->list, &session->chan);
406 mutex_unlock(&sessions_mutex);
407 return chan;
408
409 create_error:
410 kfree(chan);
411 nomem:
412 if (transport)
413 module_put(transport->owner);
414 notransport:
415 active:
416 mutex_unlock(&sessions_mutex);
417 return NULL;
418 }
419
420 /*
421 * Only used internally at session destruction for per-cpu channels, and
422 * when metadata channel is released.
423 * Needs to be called with sessions mutex held.
424 */
425 static
426 void _lttng_channel_destroy(struct lttng_channel *chan)
427 {
428 chan->ops->channel_destroy(chan->chan);
429 module_put(chan->transport->owner);
430 list_del(&chan->list);
431 lttng_destroy_context(chan->ctx);
432 kfree(chan);
433 }
434
435 void lttng_metadata_channel_destroy(struct lttng_channel *chan)
436 {
437 BUG_ON(chan->channel_type != METADATA_CHANNEL);
438
439 /* Protect the metadata cache with the sessions_mutex. */
440 mutex_lock(&sessions_mutex);
441 _lttng_channel_destroy(chan);
442 mutex_unlock(&sessions_mutex);
443 }
444 EXPORT_SYMBOL_GPL(lttng_metadata_channel_destroy);
445
446 static
447 void _lttng_metadata_channel_hangup(struct lttng_metadata_stream *stream)
448 {
449 stream->finalized = 1;
450 wake_up_interruptible(&stream->read_wait);
451 }
452
453 /*
454 * Supports event creation while tracing session is active.
455 * Needs to be called with sessions mutex held.
456 */
457 struct lttng_event *_lttng_event_create(struct lttng_channel *chan,
458 struct lttng_kernel_event *event_param,
459 void *filter,
460 const struct lttng_event_desc *event_desc,
461 enum lttng_kernel_instrumentation itype)
462 {
463 struct lttng_session *session = chan->session;
464 struct lttng_event *event;
465 const char *event_name;
466 struct hlist_head *head;
467 size_t name_len;
468 uint32_t hash;
469 int ret;
470
471 if (chan->free_event_id == -1U) {
472 ret = -EMFILE;
473 goto full;
474 }
475
476 switch (itype) {
477 case LTTNG_KERNEL_TRACEPOINT:
478 event_name = event_desc->name;
479 break;
480 case LTTNG_KERNEL_KPROBE:
481 case LTTNG_KERNEL_KRETPROBE:
482 case LTTNG_KERNEL_FUNCTION:
483 case LTTNG_KERNEL_NOOP:
484 case LTTNG_KERNEL_SYSCALL:
485 event_name = event_param->name;
486 break;
487 default:
488 WARN_ON_ONCE(1);
489 ret = -EINVAL;
490 goto type_error;
491 }
492 name_len = strlen(event_name);
493 hash = jhash(event_name, name_len, 0);
494 head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
495 hlist_for_each_entry(event, head, hlist) {
496 WARN_ON_ONCE(!event->desc);
497 if (!strncmp(event->desc->name, event_name,
498 LTTNG_KERNEL_SYM_NAME_LEN - 1)
499 && chan == event->chan) {
500 ret = -EEXIST;
501 goto exist;
502 }
503 }
504
505 event = kmem_cache_zalloc(event_cache, GFP_KERNEL);
506 if (!event) {
507 ret = -ENOMEM;
508 goto cache_error;
509 }
510 event->chan = chan;
511 event->filter = filter;
512 event->id = chan->free_event_id++;
513 event->instrumentation = itype;
514 event->evtype = LTTNG_TYPE_EVENT;
515 INIT_LIST_HEAD(&event->enablers_ref_head);
516
517 switch (itype) {
518 case LTTNG_KERNEL_TRACEPOINT:
519 /* Event will be enabled by enabler sync. */
520 event->enabled = 0;
521 event->registered = 0;
522 event->desc = lttng_event_get(event_name);
523 if (!event->desc) {
524 ret = -ENOENT;
525 goto register_error;
526 }
527 /* Populate lttng_event structure before event registration. */
528 smp_wmb();
529 break;
530 case LTTNG_KERNEL_KPROBE:
531 event->enabled = 1;
532 event->registered = 1;
533 /*
534 * Populate lttng_event structure before event
535 * registration.
536 */
537 smp_wmb();
538 ret = lttng_kprobes_register(event_name,
539 event_param->u.kprobe.symbol_name,
540 event_param->u.kprobe.offset,
541 event_param->u.kprobe.addr,
542 event);
543 if (ret) {
544 ret = -EINVAL;
545 goto register_error;
546 }
547 ret = try_module_get(event->desc->owner);
548 WARN_ON_ONCE(!ret);
549 break;
550 case LTTNG_KERNEL_KRETPROBE:
551 {
552 struct lttng_event *event_return;
553
554 /* kretprobe defines 2 events */
555 event->enabled = 1;
556 event->registered = 1;
557 event_return =
558 kmem_cache_zalloc(event_cache, GFP_KERNEL);
559 if (!event_return) {
560 ret = -ENOMEM;
561 goto register_error;
562 }
563 event_return->chan = chan;
564 event_return->filter = filter;
565 event_return->id = chan->free_event_id++;
566 event_return->enabled = 1;
567 event_return->registered = 1;
568 event_return->instrumentation = itype;
569 /*
570 * Populate lttng_event structure before kretprobe registration.
571 */
572 smp_wmb();
573 ret = lttng_kretprobes_register(event_name,
574 event_param->u.kretprobe.symbol_name,
575 event_param->u.kretprobe.offset,
576 event_param->u.kretprobe.addr,
577 event, event_return);
578 if (ret) {
579 kmem_cache_free(event_cache, event_return);
580 ret = -EINVAL;
581 goto register_error;
582 }
583 /* Take 2 refs on the module: one per event. */
584 ret = try_module_get(event->desc->owner);
585 WARN_ON_ONCE(!ret);
586 ret = try_module_get(event->desc->owner);
587 WARN_ON_ONCE(!ret);
588 ret = _lttng_event_metadata_statedump(chan->session, chan,
589 event_return);
590 WARN_ON_ONCE(ret > 0);
591 if (ret) {
592 kmem_cache_free(event_cache, event_return);
593 module_put(event->desc->owner);
594 module_put(event->desc->owner);
595 goto statedump_error;
596 }
597 list_add(&event_return->list, &chan->session->events);
598 break;
599 }
600 case LTTNG_KERNEL_FUNCTION:
601 event->enabled = 1;
602 event->registered = 1;
603 /*
604 * Populate lttng_event structure before event
605 * registration.
606 */
607 smp_wmb();
608 ret = lttng_ftrace_register(event_name,
609 event_param->u.ftrace.symbol_name,
610 event);
611 if (ret) {
612 goto register_error;
613 }
614 ret = try_module_get(event->desc->owner);
615 WARN_ON_ONCE(!ret);
616 break;
617 case LTTNG_KERNEL_NOOP:
618 case LTTNG_KERNEL_SYSCALL:
619 event->enabled = 1;
620 event->registered = 0;
621 event->desc = event_desc;
622 if (!event->desc) {
623 ret = -EINVAL;
624 goto register_error;
625 }
626 break;
627 default:
628 WARN_ON_ONCE(1);
629 ret = -EINVAL;
630 goto register_error;
631 }
632 ret = _lttng_event_metadata_statedump(chan->session, chan, event);
633 WARN_ON_ONCE(ret > 0);
634 if (ret) {
635 goto statedump_error;
636 }
637 hlist_add_head(&event->hlist, head);
638 list_add(&event->list, &chan->session->events);
639 mutex_unlock(&sessions_mutex);
640 return event;
641
642 statedump_error:
643 /* If a statedump error occurs, events will not be readable. */
644 register_error:
645 kmem_cache_free(event_cache, event);
646 cache_error:
647 exist:
648 type_error:
649 full:
650 return ERR_PTR(ret);
651 }
652
653 struct lttng_event *lttng_event_create(struct lttng_channel *chan,
654 struct lttng_kernel_event *event_param,
655 void *filter,
656 const struct lttng_event_desc *event_desc,
657 enum lttng_kernel_instrumentation itype)
658 {
659 struct lttng_event *event;
660
661 mutex_lock(&sessions_mutex);
662 event = _lttng_event_create(chan, event_param, filter, event_desc,
663 itype);
664 mutex_unlock(&sessions_mutex);
665 return event;
666 }
667
668 /* Only used for tracepoints for now. */
669 static
670 void register_event(struct lttng_event *event)
671 {
672 const struct lttng_event_desc *desc;
673 int ret;
674
675 WARN_ON_ONCE(event->instrumentation != LTTNG_KERNEL_TRACEPOINT);
676 if (event->registered)
677 return;
678 desc = event->desc;
679 ret = lttng_wrapper_tracepoint_probe_register(desc->kname,
680 desc->probe_callback, event);
681 if (!ret)
682 event->registered = 1;
683 }
684
685 /*
686 * Only used internally at session destruction.
687 */
688 int _lttng_event_unregister(struct lttng_event *event)
689 {
690 int ret = -EINVAL;
691
692 if (!event->registered)
693 return 0;
694
695 switch (event->instrumentation) {
696 case LTTNG_KERNEL_TRACEPOINT:
697 ret = lttng_wrapper_tracepoint_probe_unregister(event->desc->kname,
698 event->desc->probe_callback,
699 event);
700 if (ret)
701 return ret;
702 break;
703 case LTTNG_KERNEL_KPROBE:
704 lttng_kprobes_unregister(event);
705 ret = 0;
706 break;
707 case LTTNG_KERNEL_KRETPROBE:
708 lttng_kretprobes_unregister(event);
709 ret = 0;
710 break;
711 case LTTNG_KERNEL_FUNCTION:
712 lttng_ftrace_unregister(event);
713 ret = 0;
714 break;
715 case LTTNG_KERNEL_NOOP:
716 case LTTNG_KERNEL_SYSCALL:
717 ret = 0;
718 break;
719 default:
720 WARN_ON_ONCE(1);
721 }
722 if (!ret)
723 event->registered = 0;
724 return ret;
725 }
726
727 /*
728 * Only used internally at session destruction.
729 */
730 static
731 void _lttng_event_destroy(struct lttng_event *event)
732 {
733 switch (event->instrumentation) {
734 case LTTNG_KERNEL_TRACEPOINT:
735 lttng_event_put(event->desc);
736 break;
737 case LTTNG_KERNEL_KPROBE:
738 module_put(event->desc->owner);
739 lttng_kprobes_destroy_private(event);
740 break;
741 case LTTNG_KERNEL_KRETPROBE:
742 module_put(event->desc->owner);
743 lttng_kretprobes_destroy_private(event);
744 break;
745 case LTTNG_KERNEL_FUNCTION:
746 module_put(event->desc->owner);
747 lttng_ftrace_destroy_private(event);
748 break;
749 case LTTNG_KERNEL_NOOP:
750 case LTTNG_KERNEL_SYSCALL:
751 break;
752 default:
753 WARN_ON_ONCE(1);
754 }
755 list_del(&event->list);
756 lttng_destroy_context(event->ctx);
757 kmem_cache_free(event_cache, event);
758 }
759
760 int lttng_session_track_pid(struct lttng_session *session, int pid)
761 {
762 int ret;
763
764 if (pid < -1)
765 return -EINVAL;
766 mutex_lock(&sessions_mutex);
767 if (pid == -1) {
768 /* track all pids: destroy tracker. */
769 if (session->pid_tracker) {
770 struct lttng_pid_tracker *lpf;
771
772 lpf = session->pid_tracker;
773 rcu_assign_pointer(session->pid_tracker, NULL);
774 synchronize_trace();
775 lttng_pid_tracker_destroy(lpf);
776 }
777 ret = 0;
778 } else {
779 if (!session->pid_tracker) {
780 struct lttng_pid_tracker *lpf;
781
782 lpf = lttng_pid_tracker_create();
783 if (!lpf) {
784 ret = -ENOMEM;
785 goto unlock;
786 }
787 ret = lttng_pid_tracker_add(lpf, pid);
788 rcu_assign_pointer(session->pid_tracker, lpf);
789 } else {
790 ret = lttng_pid_tracker_add(session->pid_tracker, pid);
791 }
792 }
793 unlock:
794 mutex_unlock(&sessions_mutex);
795 return ret;
796 }
797
798 int lttng_session_untrack_pid(struct lttng_session *session, int pid)
799 {
800 int ret;
801
802 if (pid < -1)
803 return -EINVAL;
804 mutex_lock(&sessions_mutex);
805 if (pid == -1) {
806 /* untrack all pids: replace by empty tracker. */
807 struct lttng_pid_tracker *old_lpf = session->pid_tracker;
808 struct lttng_pid_tracker *lpf;
809
810 lpf = lttng_pid_tracker_create();
811 if (!lpf) {
812 ret = -ENOMEM;
813 goto unlock;
814 }
815 rcu_assign_pointer(session->pid_tracker, lpf);
816 synchronize_trace();
817 if (old_lpf)
818 lttng_pid_tracker_destroy(old_lpf);
819 ret = 0;
820 } else {
821 if (!session->pid_tracker) {
822 ret = -ENOENT;
823 goto unlock;
824 }
825 ret = lttng_pid_tracker_del(session->pid_tracker, pid);
826 }
827 unlock:
828 mutex_unlock(&sessions_mutex);
829 return ret;
830 }
831
832 static
833 void *pid_list_start(struct seq_file *m, loff_t *pos)
834 {
835 struct lttng_session *session = m->private;
836 struct lttng_pid_tracker *lpf;
837 struct lttng_pid_hash_node *e;
838 int iter = 0, i;
839
840 mutex_lock(&sessions_mutex);
841 lpf = session->pid_tracker;
842 if (lpf) {
843 for (i = 0; i < LTTNG_PID_TABLE_SIZE; i++) {
844 struct hlist_head *head = &lpf->pid_hash[i];
845
846 lttng_hlist_for_each_entry(e, head, hlist) {
847 if (iter++ >= *pos)
848 return e;
849 }
850 }
851 } else {
852 /* PID tracker disabled. */
853 if (iter >= *pos && iter == 0) {
854 return session; /* empty tracker */
855 }
856 iter++;
857 }
858 /* End of list */
859 return NULL;
860 }
861
862 /* Called with sessions_mutex held. */
863 static
864 void *pid_list_next(struct seq_file *m, void *p, loff_t *ppos)
865 {
866 struct lttng_session *session = m->private;
867 struct lttng_pid_tracker *lpf;
868 struct lttng_pid_hash_node *e;
869 int iter = 0, i;
870
871 (*ppos)++;
872 lpf = session->pid_tracker;
873 if (lpf) {
874 for (i = 0; i < LTTNG_PID_TABLE_SIZE; i++) {
875 struct hlist_head *head = &lpf->pid_hash[i];
876
877 lttng_hlist_for_each_entry(e, head, hlist) {
878 if (iter++ >= *ppos)
879 return e;
880 }
881 }
882 } else {
883 /* PID tracker disabled. */
884 if (iter >= *ppos && iter == 0)
885 return session; /* empty tracker */
886 iter++;
887 }
888
889 /* End of list */
890 return NULL;
891 }
892
893 static
894 void pid_list_stop(struct seq_file *m, void *p)
895 {
896 mutex_unlock(&sessions_mutex);
897 }
898
899 static
900 int pid_list_show(struct seq_file *m, void *p)
901 {
902 int pid;
903
904 if (p == m->private) {
905 /* Tracker disabled. */
906 pid = -1;
907 } else {
908 const struct lttng_pid_hash_node *e = p;
909
910 pid = lttng_pid_tracker_get_node_pid(e);
911 }
912 seq_printf(m, "process { pid = %d; };\n", pid);
913 return 0;
914 }
915
916 static
917 const struct seq_operations lttng_tracker_pids_list_seq_ops = {
918 .start = pid_list_start,
919 .next = pid_list_next,
920 .stop = pid_list_stop,
921 .show = pid_list_show,
922 };
923
924 static
925 int lttng_tracker_pids_list_open(struct inode *inode, struct file *file)
926 {
927 return seq_open(file, &lttng_tracker_pids_list_seq_ops);
928 }
929
930 static
931 int lttng_tracker_pids_list_release(struct inode *inode, struct file *file)
932 {
933 struct seq_file *m = file->private_data;
934 struct lttng_session *session = m->private;
935 int ret;
936
937 WARN_ON_ONCE(!session);
938 ret = seq_release(inode, file);
939 if (!ret && session)
940 fput(session->file);
941 return ret;
942 }
943
944 const struct file_operations lttng_tracker_pids_list_fops = {
945 .owner = THIS_MODULE,
946 .open = lttng_tracker_pids_list_open,
947 .read = seq_read,
948 .llseek = seq_lseek,
949 .release = lttng_tracker_pids_list_release,
950 };
951
952 int lttng_session_list_tracker_pids(struct lttng_session *session)
953 {
954 struct file *tracker_pids_list_file;
955 struct seq_file *m;
956 int file_fd, ret;
957
958 file_fd = lttng_get_unused_fd();
959 if (file_fd < 0) {
960 ret = file_fd;
961 goto fd_error;
962 }
963
964 tracker_pids_list_file = anon_inode_getfile("[lttng_tracker_pids_list]",
965 &lttng_tracker_pids_list_fops,
966 NULL, O_RDWR);
967 if (IS_ERR(tracker_pids_list_file)) {
968 ret = PTR_ERR(tracker_pids_list_file);
969 goto file_error;
970 }
971 ret = lttng_tracker_pids_list_fops.open(NULL, tracker_pids_list_file);
972 if (ret < 0)
973 goto open_error;
974 m = tracker_pids_list_file->private_data;
975 m->private = session;
976 fd_install(file_fd, tracker_pids_list_file);
977 atomic_long_inc(&session->file->f_count);
978
979 return file_fd;
980
981 open_error:
982 fput(tracker_pids_list_file);
983 file_error:
984 put_unused_fd(file_fd);
985 fd_error:
986 return ret;
987 }
988
989 /*
990 * Enabler management.
991 */
992 static
993 int lttng_desc_match_wildcard_enabler(const struct lttng_event_desc *desc,
994 struct lttng_enabler *enabler)
995 {
996 WARN_ON_ONCE(enabler->type != LTTNG_ENABLER_WILDCARD);
997 /* Compare excluding final '*' */
998 if (strncmp(desc->name, enabler->event_param.name,
999 strlen(enabler->event_param.name) - 1))
1000 return 0;
1001 return 1;
1002 }
1003
1004 static
1005 int lttng_desc_match_name_enabler(const struct lttng_event_desc *desc,
1006 struct lttng_enabler *enabler)
1007 {
1008 WARN_ON_ONCE(enabler->type != LTTNG_ENABLER_NAME);
1009 if (strcmp(desc->name, enabler->event_param.name))
1010 return 0;
1011 return 1;
1012 }
1013
1014 static
1015 int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
1016 struct lttng_enabler *enabler)
1017 {
1018 switch (enabler->type) {
1019 case LTTNG_ENABLER_WILDCARD:
1020 return lttng_desc_match_wildcard_enabler(desc, enabler);
1021 case LTTNG_ENABLER_NAME:
1022 return lttng_desc_match_name_enabler(desc, enabler);
1023 default:
1024 return -EINVAL;
1025 }
1026 }
1027
1028 static
1029 int lttng_event_match_enabler(struct lttng_event *event,
1030 struct lttng_enabler *enabler)
1031 {
1032 if (enabler->event_param.instrumentation != event->instrumentation)
1033 return 0;
1034 if (lttng_desc_match_enabler(event->desc, enabler)
1035 && event->chan == enabler->chan)
1036 return 1;
1037 else
1038 return 0;
1039 }
1040
1041 static
1042 struct lttng_enabler_ref *lttng_event_enabler_ref(struct lttng_event *event,
1043 struct lttng_enabler *enabler)
1044 {
1045 struct lttng_enabler_ref *enabler_ref;
1046
1047 list_for_each_entry(enabler_ref,
1048 &event->enablers_ref_head, node) {
1049 if (enabler_ref->ref == enabler)
1050 return enabler_ref;
1051 }
1052 return NULL;
1053 }
1054
1055 static
1056 void lttng_create_tracepoint_if_missing(struct lttng_enabler *enabler)
1057 {
1058 struct lttng_session *session = enabler->chan->session;
1059 struct lttng_probe_desc *probe_desc;
1060 const struct lttng_event_desc *desc;
1061 int i;
1062 struct list_head *probe_list;
1063
1064 probe_list = lttng_get_probe_list_head();
1065 /*
1066 * For each probe event, if we find that a probe event matches
1067 * our enabler, create an associated lttng_event if not
1068 * already present.
1069 */
1070 list_for_each_entry(probe_desc, probe_list, head) {
1071 for (i = 0; i < probe_desc->nr_events; i++) {
1072 int found = 0;
1073 struct hlist_head *head;
1074 const char *event_name;
1075 size_t name_len;
1076 uint32_t hash;
1077 struct lttng_event *event;
1078
1079 desc = probe_desc->event_desc[i];
1080 if (!lttng_desc_match_enabler(desc, enabler))
1081 continue;
1082 event_name = desc->name;
1083 name_len = strlen(event_name);
1084
1085 /*
1086 * Check if already created.
1087 */
1088 hash = jhash(event_name, name_len, 0);
1089 head = &session->events_ht.table[hash & (LTTNG_EVENT_HT_SIZE - 1)];
1090 hlist_for_each_entry(event, head, hlist) {
1091 if (event->desc == desc
1092 && event->chan == enabler->chan)
1093 found = 1;
1094 }
1095 if (found)
1096 continue;
1097
1098 /*
1099 * We need to create an event for this
1100 * event probe.
1101 */
1102 event = _lttng_event_create(enabler->chan,
1103 NULL, NULL, desc,
1104 LTTNG_KERNEL_TRACEPOINT);
1105 if (!event) {
1106 printk(KERN_INFO "Unable to create event %s\n",
1107 probe_desc->event_desc[i]->name);
1108 }
1109 }
1110 }
1111 }
1112
1113 static
1114 void lttng_create_syscall_if_missing(struct lttng_enabler *enabler)
1115 {
1116 int ret;
1117
1118 ret = lttng_syscalls_register(enabler->chan, NULL);
1119 WARN_ON_ONCE(ret);
1120 }
1121
1122 /*
1123 * Create struct lttng_event if it is missing and present in the list of
1124 * tracepoint probes.
1125 * Should be called with sessions mutex held.
1126 */
1127 static
1128 void lttng_create_event_if_missing(struct lttng_enabler *enabler)
1129 {
1130 switch (enabler->event_param.instrumentation) {
1131 case LTTNG_KERNEL_TRACEPOINT:
1132 lttng_create_tracepoint_if_missing(enabler);
1133 break;
1134 case LTTNG_KERNEL_SYSCALL:
1135 lttng_create_syscall_if_missing(enabler);
1136 break;
1137 default:
1138 WARN_ON_ONCE(1);
1139 break;
1140 }
1141 }
1142
1143 /*
1144 * Create events associated with an enabler (if not already present),
1145 * and add backward reference from the event to the enabler.
1146 * Should be called with sessions mutex held.
1147 */
1148 static
1149 int lttng_enabler_ref_events(struct lttng_enabler *enabler)
1150 {
1151 struct lttng_session *session = enabler->chan->session;
1152 struct lttng_event *event;
1153
1154 /* First ensure that probe events are created for this enabler. */
1155 lttng_create_event_if_missing(enabler);
1156
1157 /* For each event matching enabler in session event list. */
1158 list_for_each_entry(event, &session->events, list) {
1159 struct lttng_enabler_ref *enabler_ref;
1160
1161 if (!lttng_event_match_enabler(event, enabler))
1162 continue;
1163 enabler_ref = lttng_event_enabler_ref(event, enabler);
1164 if (!enabler_ref) {
1165 /*
1166 * If no backward ref, create it.
1167 * Add backward ref from event to enabler.
1168 */
1169 enabler_ref = kzalloc(sizeof(*enabler_ref), GFP_KERNEL);
1170 if (!enabler_ref)
1171 return -ENOMEM;
1172 enabler_ref->ref = enabler;
1173 list_add(&enabler_ref->node,
1174 &event->enablers_ref_head);
1175 }
1176
1177 /* TODO: merge event context. */
1178 }
1179 return 0;
1180 }
1181
1182 /*
1183 * Called at module load: connect the probe on all enablers matching
1184 * this event.
1185 * Called with sessions lock held.
1186 */
1187 int lttng_fix_pending_events(void)
1188 {
1189 struct lttng_session *session;
1190
1191 list_for_each_entry(session, &sessions, list)
1192 lttng_session_lazy_sync_enablers(session);
1193 return 0;
1194 }
1195
1196 struct lttng_enabler *lttng_enabler_create(enum lttng_enabler_type type,
1197 struct lttng_kernel_event *event_param,
1198 struct lttng_channel *chan)
1199 {
1200 struct lttng_enabler *enabler;
1201
1202 enabler = kzalloc(sizeof(*enabler), GFP_KERNEL);
1203 if (!enabler)
1204 return NULL;
1205 enabler->type = type;
1206 memcpy(&enabler->event_param, event_param,
1207 sizeof(enabler->event_param));
1208 enabler->chan = chan;
1209 /* ctx left NULL */
1210 enabler->enabled = 1;
1211 enabler->evtype = LTTNG_TYPE_ENABLER;
1212 mutex_lock(&sessions_mutex);
1213 list_add(&enabler->node, &enabler->chan->session->enablers_head);
1214 lttng_session_lazy_sync_enablers(enabler->chan->session);
1215 mutex_unlock(&sessions_mutex);
1216 return enabler;
1217 }
1218
1219 int lttng_enabler_enable(struct lttng_enabler *enabler)
1220 {
1221 mutex_lock(&sessions_mutex);
1222 enabler->enabled = 1;
1223 lttng_session_lazy_sync_enablers(enabler->chan->session);
1224 mutex_unlock(&sessions_mutex);
1225 return 0;
1226 }
1227
1228 int lttng_enabler_disable(struct lttng_enabler *enabler)
1229 {
1230 mutex_lock(&sessions_mutex);
1231 enabler->enabled = 0;
1232 lttng_session_lazy_sync_enablers(enabler->chan->session);
1233 mutex_unlock(&sessions_mutex);
1234 return 0;
1235 }
1236
1237 int lttng_enabler_attach_context(struct lttng_enabler *enabler,
1238 struct lttng_kernel_context *context_param)
1239 {
1240 return -ENOSYS;
1241 }
1242
1243 static
1244 void lttng_enabler_destroy(struct lttng_enabler *enabler)
1245 {
1246 /* Destroy contexts */
1247 lttng_destroy_context(enabler->ctx);
1248
1249 list_del(&enabler->node);
1250 kfree(enabler);
1251 }
1252
1253 /*
1254 * lttng_session_sync_enablers should be called just before starting a
1255 * session.
1256 * Should be called with sessions mutex held.
1257 */
1258 static
1259 void lttng_session_sync_enablers(struct lttng_session *session)
1260 {
1261 struct lttng_enabler *enabler;
1262 struct lttng_event *event;
1263
1264 list_for_each_entry(enabler, &session->enablers_head, node)
1265 lttng_enabler_ref_events(enabler);
1266 /*
1267 * For each event, if at least one of its enablers is enabled,
1268 * and its channel and session transient states are enabled, we
1269 * enable the event, else we disable it.
1270 */
1271 list_for_each_entry(event, &session->events, list) {
1272 struct lttng_enabler_ref *enabler_ref;
1273 int enabled = 0;
1274
1275 if (event->instrumentation == LTTNG_KERNEL_TRACEPOINT) {
1276 /* Enable events */
1277 list_for_each_entry(enabler_ref,
1278 &event->enablers_ref_head, node) {
1279 if (enabler_ref->ref->enabled) {
1280 enabled = 1;
1281 break;
1282 }
1283 }
1284 } else {
1285 /* Not handled with lazy sync. */
1286 continue;
1287 }
1288 /*
1289 * Enabled state is based on union of enablers, with
1290 * intesection of session and channel transient enable
1291 * states.
1292 */
1293 enabled = enabled && session->tstate && event->chan->tstate;
1294
1295 ACCESS_ONCE(event->enabled) = enabled;
1296 /*
1297 * Sync tracepoint registration with event enabled
1298 * state.
1299 */
1300 if (enabled) {
1301 register_event(event);
1302 } else {
1303 _lttng_event_unregister(event);
1304 }
1305 }
1306 }
1307
1308 /*
1309 * Apply enablers to session events, adding events to session if need
1310 * be. It is required after each modification applied to an active
1311 * session, and right before session "start".
1312 * "lazy" sync means we only sync if required.
1313 * Should be called with sessions mutex held.
1314 */
1315 static
1316 void lttng_session_lazy_sync_enablers(struct lttng_session *session)
1317 {
1318 /* We can skip if session is not active */
1319 if (!session->active)
1320 return;
1321 lttng_session_sync_enablers(session);
1322 }
1323
1324 /*
1325 * Serialize at most one packet worth of metadata into a metadata
1326 * channel.
1327 * We have exclusive access to our metadata buffer (protected by the
1328 * sessions_mutex), so we can do racy operations such as looking for
1329 * remaining space left in packet and write, since mutual exclusion
1330 * protects us from concurrent writes.
1331 * Returns the number of bytes written in the channel, 0 if no data
1332 * was written and a negative value on error.
1333 */
1334 int lttng_metadata_output_channel(struct lttng_metadata_stream *stream,
1335 struct channel *chan)
1336 {
1337 struct lib_ring_buffer_ctx ctx;
1338 int ret = 0;
1339 size_t len, reserve_len;
1340
1341 /*
1342 * Ensure we support mutiple get_next / put sequences followed
1343 * by put_next. The metadata stream lock internally protects
1344 * reading the metadata cache. It can indeed be read
1345 * concurrently by "get_next_subbuf" and "flush" operations on
1346 * the buffer invoked by different processes.
1347 */
1348 mutex_lock(&stream->lock);
1349 WARN_ON(stream->metadata_in < stream->metadata_out);
1350 if (stream->metadata_in != stream->metadata_out)
1351 goto end;
1352
1353 len = stream->metadata_cache->metadata_written -
1354 stream->metadata_in;
1355 if (!len)
1356 goto end;
1357 reserve_len = min_t(size_t,
1358 stream->transport->ops.packet_avail_size(chan),
1359 len);
1360 lib_ring_buffer_ctx_init(&ctx, chan, NULL, reserve_len,
1361 sizeof(char), -1);
1362 /*
1363 * If reservation failed, return an error to the caller.
1364 */
1365 ret = stream->transport->ops.event_reserve(&ctx, 0);
1366 if (ret != 0) {
1367 printk(KERN_WARNING "LTTng: Metadata event reservation failed\n");
1368 goto end;
1369 }
1370 stream->transport->ops.event_write(&ctx,
1371 stream->metadata_cache->data + stream->metadata_in,
1372 reserve_len);
1373 stream->transport->ops.event_commit(&ctx);
1374 stream->metadata_in += reserve_len;
1375 ret = reserve_len;
1376
1377 end:
1378 mutex_unlock(&stream->lock);
1379 return ret;
1380 }
1381
1382 /*
1383 * Write the metadata to the metadata cache.
1384 * Must be called with sessions_mutex held.
1385 */
1386 int lttng_metadata_printf(struct lttng_session *session,
1387 const char *fmt, ...)
1388 {
1389 char *str;
1390 size_t len;
1391 va_list ap;
1392 struct lttng_metadata_stream *stream;
1393
1394 WARN_ON_ONCE(!ACCESS_ONCE(session->active));
1395
1396 va_start(ap, fmt);
1397 str = kvasprintf(GFP_KERNEL, fmt, ap);
1398 va_end(ap);
1399 if (!str)
1400 return -ENOMEM;
1401
1402 len = strlen(str);
1403 if (session->metadata_cache->metadata_written + len >
1404 session->metadata_cache->cache_alloc) {
1405 char *tmp_cache_realloc;
1406 unsigned int tmp_cache_alloc_size;
1407
1408 tmp_cache_alloc_size = max_t(unsigned int,
1409 session->metadata_cache->cache_alloc + len,
1410 session->metadata_cache->cache_alloc << 1);
1411 tmp_cache_realloc = krealloc(session->metadata_cache->data,
1412 tmp_cache_alloc_size, GFP_KERNEL);
1413 if (!tmp_cache_realloc)
1414 goto err;
1415 session->metadata_cache->cache_alloc = tmp_cache_alloc_size;
1416 session->metadata_cache->data = tmp_cache_realloc;
1417 }
1418 memcpy(session->metadata_cache->data +
1419 session->metadata_cache->metadata_written,
1420 str, len);
1421 session->metadata_cache->metadata_written += len;
1422 kfree(str);
1423
1424 list_for_each_entry(stream, &session->metadata_cache->metadata_stream, list)
1425 wake_up_interruptible(&stream->read_wait);
1426
1427 return 0;
1428
1429 err:
1430 kfree(str);
1431 return -ENOMEM;
1432 }
1433
1434 /*
1435 * Must be called with sessions_mutex held.
1436 */
1437 static
1438 int _lttng_field_statedump(struct lttng_session *session,
1439 const struct lttng_event_field *field)
1440 {
1441 int ret = 0;
1442
1443 switch (field->type.atype) {
1444 case atype_integer:
1445 ret = lttng_metadata_printf(session,
1446 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s;\n",
1447 field->type.u.basic.integer.size,
1448 field->type.u.basic.integer.alignment,
1449 field->type.u.basic.integer.signedness,
1450 (field->type.u.basic.integer.encoding == lttng_encode_none)
1451 ? "none"
1452 : (field->type.u.basic.integer.encoding == lttng_encode_UTF8)
1453 ? "UTF8"
1454 : "ASCII",
1455 field->type.u.basic.integer.base,
1456 #ifdef __BIG_ENDIAN
1457 field->type.u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
1458 #else
1459 field->type.u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
1460 #endif
1461 field->name);
1462 break;
1463 case atype_enum:
1464 ret = lttng_metadata_printf(session,
1465 " %s _%s;\n",
1466 field->type.u.basic.enumeration.name,
1467 field->name);
1468 break;
1469 case atype_array:
1470 {
1471 const struct lttng_basic_type *elem_type;
1472
1473 elem_type = &field->type.u.array.elem_type;
1474 ret = lttng_metadata_printf(session,
1475 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[%u];\n",
1476 elem_type->u.basic.integer.size,
1477 elem_type->u.basic.integer.alignment,
1478 elem_type->u.basic.integer.signedness,
1479 (elem_type->u.basic.integer.encoding == lttng_encode_none)
1480 ? "none"
1481 : (elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
1482 ? "UTF8"
1483 : "ASCII",
1484 elem_type->u.basic.integer.base,
1485 #ifdef __BIG_ENDIAN
1486 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
1487 #else
1488 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
1489 #endif
1490 field->name, field->type.u.array.length);
1491 break;
1492 }
1493 case atype_sequence:
1494 {
1495 const struct lttng_basic_type *elem_type;
1496 const struct lttng_basic_type *length_type;
1497
1498 elem_type = &field->type.u.sequence.elem_type;
1499 length_type = &field->type.u.sequence.length_type;
1500 ret = lttng_metadata_printf(session,
1501 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } __%s_length;\n",
1502 length_type->u.basic.integer.size,
1503 (unsigned int) length_type->u.basic.integer.alignment,
1504 length_type->u.basic.integer.signedness,
1505 (length_type->u.basic.integer.encoding == lttng_encode_none)
1506 ? "none"
1507 : ((length_type->u.basic.integer.encoding == lttng_encode_UTF8)
1508 ? "UTF8"
1509 : "ASCII"),
1510 length_type->u.basic.integer.base,
1511 #ifdef __BIG_ENDIAN
1512 length_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
1513 #else
1514 length_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
1515 #endif
1516 field->name);
1517 if (ret)
1518 return ret;
1519
1520 ret = lttng_metadata_printf(session,
1521 " integer { size = %u; align = %u; signed = %u; encoding = %s; base = %u;%s } _%s[ __%s_length ];\n",
1522 elem_type->u.basic.integer.size,
1523 (unsigned int) elem_type->u.basic.integer.alignment,
1524 elem_type->u.basic.integer.signedness,
1525 (elem_type->u.basic.integer.encoding == lttng_encode_none)
1526 ? "none"
1527 : ((elem_type->u.basic.integer.encoding == lttng_encode_UTF8)
1528 ? "UTF8"
1529 : "ASCII"),
1530 elem_type->u.basic.integer.base,
1531 #ifdef __BIG_ENDIAN
1532 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = le;" : "",
1533 #else
1534 elem_type->u.basic.integer.reverse_byte_order ? " byte_order = be;" : "",
1535 #endif
1536 field->name,
1537 field->name);
1538 break;
1539 }
1540
1541 case atype_string:
1542 /* Default encoding is UTF8 */
1543 ret = lttng_metadata_printf(session,
1544 " string%s _%s;\n",
1545 field->type.u.basic.string.encoding == lttng_encode_ASCII ?
1546 " { encoding = ASCII; }" : "",
1547 field->name);
1548 break;
1549 default:
1550 WARN_ON_ONCE(1);
1551 return -EINVAL;
1552 }
1553 return ret;
1554 }
1555
1556 static
1557 int _lttng_context_metadata_statedump(struct lttng_session *session,
1558 struct lttng_ctx *ctx)
1559 {
1560 int ret = 0;
1561 int i;
1562
1563 if (!ctx)
1564 return 0;
1565 for (i = 0; i < ctx->nr_fields; i++) {
1566 const struct lttng_ctx_field *field = &ctx->fields[i];
1567
1568 ret = _lttng_field_statedump(session, &field->event_field);
1569 if (ret)
1570 return ret;
1571 }
1572 return ret;
1573 }
1574
1575 static
1576 int _lttng_fields_metadata_statedump(struct lttng_session *session,
1577 struct lttng_event *event)
1578 {
1579 const struct lttng_event_desc *desc = event->desc;
1580 int ret = 0;
1581 int i;
1582
1583 for (i = 0; i < desc->nr_fields; i++) {
1584 const struct lttng_event_field *field = &desc->fields[i];
1585
1586 ret = _lttng_field_statedump(session, field);
1587 if (ret)
1588 return ret;
1589 }
1590 return ret;
1591 }
1592
1593 /*
1594 * Must be called with sessions_mutex held.
1595 */
1596 static
1597 int _lttng_event_metadata_statedump(struct lttng_session *session,
1598 struct lttng_channel *chan,
1599 struct lttng_event *event)
1600 {
1601 int ret = 0;
1602
1603 if (event->metadata_dumped || !ACCESS_ONCE(session->active))
1604 return 0;
1605 if (chan->channel_type == METADATA_CHANNEL)
1606 return 0;
1607
1608 ret = lttng_metadata_printf(session,
1609 "event {\n"
1610 " name = \"%s\";\n"
1611 " id = %u;\n"
1612 " stream_id = %u;\n",
1613 event->desc->name,
1614 event->id,
1615 event->chan->id);
1616 if (ret)
1617 goto end;
1618
1619 if (event->ctx) {
1620 ret = lttng_metadata_printf(session,
1621 " context := struct {\n");
1622 if (ret)
1623 goto end;
1624 }
1625 ret = _lttng_context_metadata_statedump(session, event->ctx);
1626 if (ret)
1627 goto end;
1628 if (event->ctx) {
1629 ret = lttng_metadata_printf(session,
1630 " };\n");
1631 if (ret)
1632 goto end;
1633 }
1634
1635 ret = lttng_metadata_printf(session,
1636 " fields := struct {\n"
1637 );
1638 if (ret)
1639 goto end;
1640
1641 ret = _lttng_fields_metadata_statedump(session, event);
1642 if (ret)
1643 goto end;
1644
1645 /*
1646 * LTTng space reservation can only reserve multiples of the
1647 * byte size.
1648 */
1649 ret = lttng_metadata_printf(session,
1650 " };\n"
1651 "};\n\n");
1652 if (ret)
1653 goto end;
1654
1655 event->metadata_dumped = 1;
1656 end:
1657 return ret;
1658
1659 }
1660
1661 /*
1662 * Must be called with sessions_mutex held.
1663 */
1664 static
1665 int _lttng_channel_metadata_statedump(struct lttng_session *session,
1666 struct lttng_channel *chan)
1667 {
1668 int ret = 0;
1669
1670 if (chan->metadata_dumped || !ACCESS_ONCE(session->active))
1671 return 0;
1672
1673 if (chan->channel_type == METADATA_CHANNEL)
1674 return 0;
1675
1676 WARN_ON_ONCE(!chan->header_type);
1677 ret = lttng_metadata_printf(session,
1678 "stream {\n"
1679 " id = %u;\n"
1680 " event.header := %s;\n"
1681 " packet.context := struct packet_context;\n",
1682 chan->id,
1683 chan->header_type == 1 ? "struct event_header_compact" :
1684 "struct event_header_large");
1685 if (ret)
1686 goto end;
1687
1688 if (chan->ctx) {
1689 ret = lttng_metadata_printf(session,
1690 " event.context := struct {\n");
1691 if (ret)
1692 goto end;
1693 }
1694 ret = _lttng_context_metadata_statedump(session, chan->ctx);
1695 if (ret)
1696 goto end;
1697 if (chan->ctx) {
1698 ret = lttng_metadata_printf(session,
1699 " };\n");
1700 if (ret)
1701 goto end;
1702 }
1703
1704 ret = lttng_metadata_printf(session,
1705 "};\n\n");
1706
1707 chan->metadata_dumped = 1;
1708 end:
1709 return ret;
1710 }
1711
1712 /*
1713 * Must be called with sessions_mutex held.
1714 */
1715 static
1716 int _lttng_stream_packet_context_declare(struct lttng_session *session)
1717 {
1718 return lttng_metadata_printf(session,
1719 "struct packet_context {\n"
1720 " uint64_clock_monotonic_t timestamp_begin;\n"
1721 " uint64_clock_monotonic_t timestamp_end;\n"
1722 " uint64_t content_size;\n"
1723 " uint64_t packet_size;\n"
1724 " unsigned long events_discarded;\n"
1725 " uint32_t cpu_id;\n"
1726 "};\n\n"
1727 );
1728 }
1729
1730 /*
1731 * Compact header:
1732 * id: range: 0 - 30.
1733 * id 31 is reserved to indicate an extended header.
1734 *
1735 * Large header:
1736 * id: range: 0 - 65534.
1737 * id 65535 is reserved to indicate an extended header.
1738 *
1739 * Must be called with sessions_mutex held.
1740 */
1741 static
1742 int _lttng_event_header_declare(struct lttng_session *session)
1743 {
1744 return lttng_metadata_printf(session,
1745 "struct event_header_compact {\n"
1746 " enum : uint5_t { compact = 0 ... 30, extended = 31 } id;\n"
1747 " variant <id> {\n"
1748 " struct {\n"
1749 " uint27_clock_monotonic_t timestamp;\n"
1750 " } compact;\n"
1751 " struct {\n"
1752 " uint32_t id;\n"
1753 " uint64_clock_monotonic_t timestamp;\n"
1754 " } extended;\n"
1755 " } v;\n"
1756 "} align(%u);\n"
1757 "\n"
1758 "struct event_header_large {\n"
1759 " enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;\n"
1760 " variant <id> {\n"
1761 " struct {\n"
1762 " uint32_clock_monotonic_t timestamp;\n"
1763 " } compact;\n"
1764 " struct {\n"
1765 " uint32_t id;\n"
1766 " uint64_clock_monotonic_t timestamp;\n"
1767 " } extended;\n"
1768 " } v;\n"
1769 "} align(%u);\n\n",
1770 lttng_alignof(uint32_t) * CHAR_BIT,
1771 lttng_alignof(uint16_t) * CHAR_BIT
1772 );
1773 }
1774
1775 /*
1776 * Approximation of NTP time of day to clock monotonic correlation,
1777 * taken at start of trace.
1778 * Yes, this is only an approximation. Yes, we can (and will) do better
1779 * in future versions.
1780 */
1781 static
1782 uint64_t measure_clock_offset(void)
1783 {
1784 uint64_t offset, monotonic[2], realtime;
1785 struct timespec rts = { 0, 0 };
1786 unsigned long flags;
1787
1788 /* Disable interrupts to increase correlation precision. */
1789 local_irq_save(flags);
1790 monotonic[0] = trace_clock_read64();
1791 getnstimeofday(&rts);
1792 monotonic[1] = trace_clock_read64();
1793 local_irq_restore(flags);
1794
1795 offset = (monotonic[0] + monotonic[1]) >> 1;
1796 realtime = (uint64_t) rts.tv_sec * NSEC_PER_SEC;
1797 realtime += rts.tv_nsec;
1798 offset = realtime - offset;
1799 return offset;
1800 }
1801
1802 /*
1803 * Output metadata into this session's metadata buffers.
1804 * Must be called with sessions_mutex held.
1805 */
1806 static
1807 int _lttng_session_metadata_statedump(struct lttng_session *session)
1808 {
1809 unsigned char *uuid_c = session->uuid.b;
1810 unsigned char uuid_s[37], clock_uuid_s[BOOT_ID_LEN];
1811 struct lttng_channel *chan;
1812 struct lttng_event *event;
1813 int ret = 0;
1814
1815 if (!ACCESS_ONCE(session->active))
1816 return 0;
1817 if (session->metadata_dumped)
1818 goto skip_session;
1819
1820 snprintf(uuid_s, sizeof(uuid_s),
1821 "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
1822 uuid_c[0], uuid_c[1], uuid_c[2], uuid_c[3],
1823 uuid_c[4], uuid_c[5], uuid_c[6], uuid_c[7],
1824 uuid_c[8], uuid_c[9], uuid_c[10], uuid_c[11],
1825 uuid_c[12], uuid_c[13], uuid_c[14], uuid_c[15]);
1826
1827 ret = lttng_metadata_printf(session,
1828 "typealias integer { size = 8; align = %u; signed = false; } := uint8_t;\n"
1829 "typealias integer { size = 16; align = %u; signed = false; } := uint16_t;\n"
1830 "typealias integer { size = 32; align = %u; signed = false; } := uint32_t;\n"
1831 "typealias integer { size = 64; align = %u; signed = false; } := uint64_t;\n"
1832 "typealias integer { size = %u; align = %u; signed = false; } := unsigned long;\n"
1833 "typealias integer { size = 5; align = 1; signed = false; } := uint5_t;\n"
1834 "typealias integer { size = 27; align = 1; signed = false; } := uint27_t;\n"
1835 "\n"
1836 "trace {\n"
1837 " major = %u;\n"
1838 " minor = %u;\n"
1839 " uuid = \"%s\";\n"
1840 " byte_order = %s;\n"
1841 " packet.header := struct {\n"
1842 " uint32_t magic;\n"
1843 " uint8_t uuid[16];\n"
1844 " uint32_t stream_id;\n"
1845 " };\n"
1846 "};\n\n",
1847 lttng_alignof(uint8_t) * CHAR_BIT,
1848 lttng_alignof(uint16_t) * CHAR_BIT,
1849 lttng_alignof(uint32_t) * CHAR_BIT,
1850 lttng_alignof(uint64_t) * CHAR_BIT,
1851 sizeof(unsigned long) * CHAR_BIT,
1852 lttng_alignof(unsigned long) * CHAR_BIT,
1853 CTF_SPEC_MAJOR,
1854 CTF_SPEC_MINOR,
1855 uuid_s,
1856 #ifdef __BIG_ENDIAN
1857 "be"
1858 #else
1859 "le"
1860 #endif
1861 );
1862 if (ret)
1863 goto end;
1864
1865 ret = lttng_metadata_printf(session,
1866 "env {\n"
1867 " hostname = \"%s\";\n"
1868 " domain = \"kernel\";\n"
1869 " sysname = \"%s\";\n"
1870 " kernel_release = \"%s\";\n"
1871 " kernel_version = \"%s\";\n"
1872 " tracer_name = \"lttng-modules\";\n"
1873 " tracer_major = %d;\n"
1874 " tracer_minor = %d;\n"
1875 " tracer_patchlevel = %d;\n"
1876 "};\n\n",
1877 current->nsproxy->uts_ns->name.nodename,
1878 utsname()->sysname,
1879 utsname()->release,
1880 utsname()->version,
1881 LTTNG_MODULES_MAJOR_VERSION,
1882 LTTNG_MODULES_MINOR_VERSION,
1883 LTTNG_MODULES_PATCHLEVEL_VERSION
1884 );
1885 if (ret)
1886 goto end;
1887
1888 ret = lttng_metadata_printf(session,
1889 "clock {\n"
1890 " name = %s;\n",
1891 "monotonic"
1892 );
1893 if (ret)
1894 goto end;
1895
1896 if (!trace_clock_uuid(clock_uuid_s)) {
1897 ret = lttng_metadata_printf(session,
1898 " uuid = \"%s\";\n",
1899 clock_uuid_s
1900 );
1901 if (ret)
1902 goto end;
1903 }
1904
1905 ret = lttng_metadata_printf(session,
1906 " description = \"Monotonic Clock\";\n"
1907 " freq = %llu; /* Frequency, in Hz */\n"
1908 " /* clock value offset from Epoch is: offset * (1/freq) */\n"
1909 " offset = %llu;\n"
1910 "};\n\n",
1911 (unsigned long long) trace_clock_freq(),
1912 (unsigned long long) measure_clock_offset()
1913 );
1914 if (ret)
1915 goto end;
1916
1917 ret = lttng_metadata_printf(session,
1918 "typealias integer {\n"
1919 " size = 27; align = 1; signed = false;\n"
1920 " map = clock.monotonic.value;\n"
1921 "} := uint27_clock_monotonic_t;\n"
1922 "\n"
1923 "typealias integer {\n"
1924 " size = 32; align = %u; signed = false;\n"
1925 " map = clock.monotonic.value;\n"
1926 "} := uint32_clock_monotonic_t;\n"
1927 "\n"
1928 "typealias integer {\n"
1929 " size = 64; align = %u; signed = false;\n"
1930 " map = clock.monotonic.value;\n"
1931 "} := uint64_clock_monotonic_t;\n\n",
1932 lttng_alignof(uint32_t) * CHAR_BIT,
1933 lttng_alignof(uint64_t) * CHAR_BIT
1934 );
1935 if (ret)
1936 goto end;
1937
1938 ret = _lttng_stream_packet_context_declare(session);
1939 if (ret)
1940 goto end;
1941
1942 ret = _lttng_event_header_declare(session);
1943 if (ret)
1944 goto end;
1945
1946 skip_session:
1947 list_for_each_entry(chan, &session->chan, list) {
1948 ret = _lttng_channel_metadata_statedump(session, chan);
1949 if (ret)
1950 goto end;
1951 }
1952
1953 list_for_each_entry(event, &session->events, list) {
1954 ret = _lttng_event_metadata_statedump(session, event->chan, event);
1955 if (ret)
1956 goto end;
1957 }
1958 session->metadata_dumped = 1;
1959 end:
1960 return ret;
1961 }
1962
1963 /**
1964 * lttng_transport_register - LTT transport registration
1965 * @transport: transport structure
1966 *
1967 * Registers a transport which can be used as output to extract the data out of
1968 * LTTng. The module calling this registration function must ensure that no
1969 * trap-inducing code will be executed by the transport functions. E.g.
1970 * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
1971 * is made visible to the transport function. This registration acts as a
1972 * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
1973 * after its registration must it synchronize the TLBs.
1974 */
1975 void lttng_transport_register(struct lttng_transport *transport)
1976 {
1977 /*
1978 * Make sure no page fault can be triggered by the module about to be
1979 * registered. We deal with this here so we don't have to call
1980 * vmalloc_sync_all() in each module's init.
1981 */
1982 wrapper_vmalloc_sync_all();
1983
1984 mutex_lock(&sessions_mutex);
1985 list_add_tail(&transport->node, &lttng_transport_list);
1986 mutex_unlock(&sessions_mutex);
1987 }
1988 EXPORT_SYMBOL_GPL(lttng_transport_register);
1989
1990 /**
1991 * lttng_transport_unregister - LTT transport unregistration
1992 * @transport: transport structure
1993 */
1994 void lttng_transport_unregister(struct lttng_transport *transport)
1995 {
1996 mutex_lock(&sessions_mutex);
1997 list_del(&transport->node);
1998 mutex_unlock(&sessions_mutex);
1999 }
2000 EXPORT_SYMBOL_GPL(lttng_transport_unregister);
2001
2002 static int __init lttng_events_init(void)
2003 {
2004 int ret;
2005
2006 ret = wrapper_lttng_fixup_sig(THIS_MODULE);
2007 if (ret)
2008 return ret;
2009
2010 ret = lttng_tracepoint_init();
2011 if (ret)
2012 return ret;
2013 event_cache = KMEM_CACHE(lttng_event, 0);
2014 if (!event_cache) {
2015 ret = -ENOMEM;
2016 goto error_kmem;
2017 }
2018 ret = lttng_abi_init();
2019 if (ret)
2020 goto error_abi;
2021 ret = lttng_logger_init();
2022 if (ret)
2023 goto error_logger;
2024 return 0;
2025
2026 error_logger:
2027 lttng_abi_exit();
2028 error_abi:
2029 kmem_cache_destroy(event_cache);
2030 error_kmem:
2031 lttng_tracepoint_exit();
2032 return ret;
2033 }
2034
2035 module_init(lttng_events_init);
2036
2037 static void __exit lttng_events_exit(void)
2038 {
2039 struct lttng_session *session, *tmpsession;
2040
2041 lttng_logger_exit();
2042 lttng_abi_exit();
2043 list_for_each_entry_safe(session, tmpsession, &sessions, list)
2044 lttng_session_destroy(session);
2045 kmem_cache_destroy(event_cache);
2046 lttng_tracepoint_exit();
2047 }
2048
2049 module_exit(lttng_events_exit);
2050
2051 MODULE_LICENSE("GPL and additional rights");
2052 MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
2053 MODULE_DESCRIPTION("LTTng Events");
2054 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
2055 __stringify(LTTNG_MODULES_MINOR_VERSION) "."
2056 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
2057 LTTNG_MODULES_EXTRAVERSION);
LTTng 2.0/0.x modules
This page took 0.098424 seconds and 5 git commands to generate.