projects / ust.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
libust: New transport mutex v2
[ust.git] / libust / tracer.c
... / ...
CommitLineData
1/*
2 * tracer.c
3 *
4 * (C) Copyright 2005-2008 -
5 * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 * Inspired from LTT :
22 * Karim Yaghmour (karim@opersys.com)
23 * Tom Zanussi (zanussi@us.ibm.com)
24 * Bob Wisniewski (bob@watson.ibm.com)
25 * And from K42 :
26 * Bob Wisniewski (bob@watson.ibm.com)
27 *
28 * Changelog:
29 * 22/09/06, Move to the marker/probes mechanism.
30 * 19/10/05, Complete lockless mechanism.
31 * 27/05/05, Modular redesign and rewrite.
32 */
33
34#include <urcu-bp.h>
35#include <urcu/rculist.h>
36
37#include <ust/clock.h>
38
39#include "tracercore.h"
40#include "tracer.h"
41#include "usterr.h"
42
43//ust// static void async_wakeup(unsigned long data);
44//ust//
45//ust// static DEFINE_TIMER(ltt_async_wakeup_timer, async_wakeup, 0, 0);
46
47/* Default callbacks for modules */
48notrace int ltt_filter_control_default(enum ltt_filter_control_msg msg,
49 struct ust_trace *trace)
50{
51 return 0;
52}
53
54int ltt_statedump_default(struct ust_trace *trace)
55{
56 return 0;
57}
58
59/* Callbacks for registered modules */
60
61int (*ltt_filter_control_functor)
62 (enum ltt_filter_control_msg msg, struct ust_trace *trace) =
63 ltt_filter_control_default;
64struct module *ltt_filter_control_owner;
65
66/* These function pointers are protected by a trace activation check */
67struct module *ltt_run_filter_owner;
68int (*ltt_statedump_functor)(struct ust_trace *trace) =
69 ltt_statedump_default;
70struct module *ltt_statedump_owner;
71
72struct chan_info_struct chan_infos[] = {
73 [LTT_CHANNEL_METADATA] = {
74 LTT_METADATA_CHANNEL,
75 LTT_DEFAULT_SUBBUF_SIZE_LOW,
76 LTT_DEFAULT_N_SUBBUFS_LOW,
77 },
78 [LTT_CHANNEL_UST] = {
79 LTT_UST_CHANNEL,
80 LTT_DEFAULT_SUBBUF_SIZE_HIGH,
81 LTT_DEFAULT_N_SUBBUFS_HIGH,
82 },
83};
84
85static enum ltt_channels get_channel_type_from_name(const char *name)
86{
87 int i;
88
89 if (!name)
90 return LTT_CHANNEL_UST;
91
92 for (i = 0; i < ARRAY_SIZE(chan_infos); i++)
93 if (chan_infos[i].name && !strcmp(name, chan_infos[i].name))
94 return (enum ltt_channels)i;
95
96 return LTT_CHANNEL_UST;
97}
98
99/**
100 * ltt_module_register - LTT module registration
101 * @name: module type
102 * @function: callback to register
103 * @owner: module which owns the callback
104 *
105 * The module calling this registration function must ensure that no
106 * trap-inducing code will be executed by "function". E.g. vmalloc_sync_all()
107 * must be called between a vmalloc and the moment the memory is made visible to
108 * "function". This registration acts as a vmalloc_sync_all. Therefore, only if
109 * the module allocates virtual memory after its registration must it
110 * synchronize the TLBs.
111 */
112//ust// int ltt_module_register(enum ltt_module_function name, void *function,
113//ust// struct module *owner)
114//ust// {
115//ust// int ret = 0;
116//ust//
117//ust// /*
118//ust// * Make sure no page fault can be triggered by the module about to be
119//ust// * registered. We deal with this here so we don't have to call
120//ust// * vmalloc_sync_all() in each module's init.
121//ust// */
122//ust// vmalloc_sync_all();
123//ust//
124//ust// switch (name) {
125//ust// case LTT_FUNCTION_RUN_FILTER:
126//ust// if (ltt_run_filter_owner != NULL) {
127//ust// ret = -EEXIST;
128//ust// goto end;
129//ust// }
130//ust// ltt_filter_register((ltt_run_filter_functor)function);
131//ust// ltt_run_filter_owner = owner;
132//ust// break;
133//ust// case LTT_FUNCTION_FILTER_CONTROL:
134//ust// if (ltt_filter_control_owner != NULL) {
135//ust// ret = -EEXIST;
136//ust// goto end;
137//ust// }
138//ust// ltt_filter_control_functor =
139//ust// (int (*)(enum ltt_filter_control_msg,
140//ust// struct ust_trace *))function;
141//ust// ltt_filter_control_owner = owner;
142//ust// break;
143//ust// case LTT_FUNCTION_STATEDUMP:
144//ust// if (ltt_statedump_owner != NULL) {
145//ust// ret = -EEXIST;
146//ust// goto end;
147//ust// }
148//ust// ltt_statedump_functor =
149//ust// (int (*)(struct ust_trace *))function;
150//ust// ltt_statedump_owner = owner;
151//ust// break;
152//ust// }
153//ust//
154//ust// end:
155//ust//
156//ust// return ret;
157//ust// }
158
159/**
160 * ltt_module_unregister - LTT module unregistration
161 * @name: module type
162 */
163//ust// void ltt_module_unregister(enum ltt_module_function name)
164//ust// {
165//ust// switch (name) {
166//ust// case LTT_FUNCTION_RUN_FILTER:
167//ust// ltt_filter_unregister();
168//ust// ltt_run_filter_owner = NULL;
169//ust// /* Wait for preempt sections to finish */
170//ust// synchronize_sched();
171//ust// break;
172//ust// case LTT_FUNCTION_FILTER_CONTROL:
173//ust// ltt_filter_control_functor = ltt_filter_control_default;
174//ust// ltt_filter_control_owner = NULL;
175//ust// break;
176//ust// case LTT_FUNCTION_STATEDUMP:
177//ust// ltt_statedump_functor = ltt_statedump_default;
178//ust// ltt_statedump_owner = NULL;
179//ust// break;
180//ust// }
181//ust//
182//ust// }
183
184static CDS_LIST_HEAD(ltt_transport_list);
185/* transport mutex, nests inside traces mutex (ltt_lock_traces) */
186static DEFINE_MUTEX(ltt_transport_mutex);
187/**
188 * ltt_transport_register - LTT transport registration
189 * @transport: transport structure
190 *
191 * Registers a transport which can be used as output to extract the data out of
192 * LTTng. The module calling this registration function must ensure that no
193 * trap-inducing code will be executed by the transport functions. E.g.
194 * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
195 * is made visible to the transport function. This registration acts as a
196 * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
197 * after its registration must it synchronize the TLBs.
198 */
199void ltt_transport_register(struct ltt_transport *transport)
200{
201 /*
202 * Make sure no page fault can be triggered by the module about to be
203 * registered. We deal with this here so we don't have to call
204 * vmalloc_sync_all() in each module's init.
205 */
206//ust// vmalloc_sync_all();
207
208 pthread_mutex_lock(&ltt_transport_mutex);
209 cds_list_add_tail(&transport->node, &ltt_transport_list);
210 pthread_mutex_unlock(&ltt_transport_mutex);
211}
212
213/**
214 * ltt_transport_unregister - LTT transport unregistration
215 * @transport: transport structure
216 */
217void ltt_transport_unregister(struct ltt_transport *transport)
218{
219 pthread_mutex_lock(&ltt_transport_mutex);
220 cds_list_del(&transport->node);
221 pthread_mutex_unlock(&ltt_transport_mutex);
222}
223
224static inline int is_channel_overwrite(enum ltt_channels chan,
225 enum trace_mode mode)
226{
227 switch (mode) {
228 case LTT_TRACE_NORMAL:
229 return 0;
230 case LTT_TRACE_FLIGHT:
231 switch (chan) {
232 case LTT_CHANNEL_METADATA:
233 return 0;
234 default:
235 return 1;
236 }
237 case LTT_TRACE_HYBRID:
238 switch (chan) {
239 case LTT_CHANNEL_METADATA:
240 return 0;
241 default:
242 return 1;
243 }
244 default:
245 return 0;
246 }
247}
248
249static void trace_async_wakeup(struct ust_trace *trace)
250{
251 int i;
252 struct ust_channel *chan;
253
254 /* Must check each channel for pending read wakeup */
255 for (i = 0; i < trace->nr_channels; i++) {
256 chan = &trace->channels[i];
257 if (chan->active)
258 trace->ops->wakeup_channel(chan);
259 }
260}
261
262//ust// /* Timer to send async wakeups to the readers */
263//ust// static void async_wakeup(unsigned long data)
264//ust// {
265//ust// struct ust_trace *trace;
266//ust//
267//ust// /*
268//ust// * PREEMPT_RT does not allow spinlocks to be taken within preempt
269//ust// * disable sections (spinlock taken in wake_up). However, mainline won't
270//ust// * allow mutex to be taken in interrupt context. Ugly.
271//ust// * A proper way to do this would be to turn the timer into a
272//ust// * periodically woken up thread, but it adds to the footprint.
273//ust// */
274//ust// #ifndef CONFIG_PREEMPT_RT
275//ust// rcu_read_lock_sched();
276//ust// #else
277//ust// ltt_lock_traces();
278//ust// #endif
279//ust// cds_list_for_each_entry_rcu(trace, &ltt_traces.head, list) {
280//ust// trace_async_wakeup(trace);
281//ust// }
282//ust// #ifndef CONFIG_PREEMPT_RT
283//ust// rcu_read_unlock_sched();
284//ust// #else
285//ust// ltt_unlock_traces();
286//ust// #endif
287//ust//
288//ust// mod_timer(&ltt_async_wakeup_timer, jiffies + LTT_PERCPU_TIMER_INTERVAL);
289//ust// }
290
291/**
292 * _ltt_trace_find - find a trace by given name.
293 * trace_name: trace name
294 *
295 * Returns a pointer to the trace structure, NULL if not found.
296 */
297struct ust_trace *_ltt_trace_find(const char *trace_name)
298{
299 struct ust_trace *trace;
300
301 cds_list_for_each_entry(trace, &ltt_traces.head, list)
302 if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
303 return trace;
304
305 return NULL;
306}
307
308/* _ltt_trace_find_setup :
309 * find a trace in setup list by given name.
310 *
311 * Returns a pointer to the trace structure, NULL if not found.
312 */
313struct ust_trace *_ltt_trace_find_setup(const char *trace_name)
314{
315 struct ust_trace *trace;
316
317 cds_list_for_each_entry(trace, &ltt_traces.setup_head, list)
318 if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
319 return trace;
320
321 return NULL;
322}
323
324/**
325 * ltt_release_transport - Release an LTT transport
326 * @kref : reference count on the transport
327 */
328void ltt_release_transport(struct urcu_ref *urcu_ref)
329{
330//ust// struct ust_trace *trace = container_of(kref,
331//ust// struct ust_trace, ltt_transport_kref);
332//ust// trace->ops->remove_dirs(trace);
333}
334
335/**
336 * ltt_release_trace - Release a LTT trace
337 * @kref : reference count on the trace
338 */
339void ltt_release_trace(struct urcu_ref *urcu_ref)
340{
341 struct ust_trace *trace = _ust_container_of(urcu_ref,
342 struct ust_trace, urcu_ref);
343 ltt_channels_trace_free(trace->channels);
344 free(trace);
345}
346
347static inline void prepare_chan_size_num(unsigned int *subbuf_size,
348 unsigned int *n_subbufs)
349{
350 /* Make sure the subbuffer size is larger than a page */
351 *subbuf_size = max_t(unsigned int, *subbuf_size, PAGE_SIZE);
352
353 /* round to next power of 2 */
354 *subbuf_size = 1 << get_count_order(*subbuf_size);
355 *n_subbufs = 1 << get_count_order(*n_subbufs);
356
357 /* Subbuf size and number must both be power of two */
358 WARN_ON(hweight32(*subbuf_size) != 1);
359 WARN_ON(hweight32(*n_subbufs) != 1);
360}
361
362int _ltt_trace_setup(const char *trace_name)
363{
364 int err = 0;
365 struct ust_trace *new_trace = NULL;
366 int metadata_index;
367 unsigned int chan;
368 enum ltt_channels chantype;
369
370 if (_ltt_trace_find_setup(trace_name)) {
371 ERR("Trace name %s already used", trace_name);
372 err = -EEXIST;
373 goto traces_error;
374 }
375
376 if (_ltt_trace_find(trace_name)) {
377 ERR("Trace name %s already used", trace_name);
378 err = -EEXIST;
379 goto traces_error;
380 }
381
382 new_trace = zmalloc(sizeof(struct ust_trace));
383 if (!new_trace) {
384 ERR("Unable to allocate memory for trace %s", trace_name);
385 err = -ENOMEM;
386 goto traces_error;
387 }
388 strncpy(new_trace->trace_name, trace_name, NAME_MAX);
389 new_trace->channels = ltt_channels_trace_alloc(&new_trace->nr_channels,
390 ust_channels_overwrite_by_default,
391 ust_channels_request_collection_by_default, 1);
392 if (!new_trace->channels) {
393 ERR("Unable to allocate memory for chaninfo %s\n", trace_name);
394 err = -ENOMEM;
395 goto trace_free;
396 }
397
398 /*
399 * Force metadata channel to active, no overwrite.
400 */
401 metadata_index = ltt_channels_get_index_from_name("metadata");
402 WARN_ON(metadata_index < 0);
403 new_trace->channels[metadata_index].overwrite = 0;
404 new_trace->channels[metadata_index].active = 1;
405
406 /*
407 * Set hardcoded tracer defaults for some channels
408 */
409 for (chan = 0; chan < new_trace->nr_channels; chan++) {
410 if (!(new_trace->channels[chan].active))
411 continue;
412
413 chantype = get_channel_type_from_name(
414 ltt_channels_get_name_from_index(chan));
415 new_trace->channels[chan].subbuf_size =
416 chan_infos[chantype].def_subbufsize;
417 new_trace->channels[chan].subbuf_cnt =
418 chan_infos[chantype].def_subbufcount;
419 }
420
421 cds_list_add(&new_trace->list, &ltt_traces.setup_head);
422 return 0;
423
424trace_free:
425 free(new_trace);
426traces_error:
427 return err;
428}
429
430
431int ltt_trace_setup(const char *trace_name)
432{
433 int ret;
434 ltt_lock_traces();
435 ret = _ltt_trace_setup(trace_name);
436 ltt_unlock_traces();
437 return ret;
438}
439
440/* must be called from within a traces lock. */
441static void _ltt_trace_free(struct ust_trace *trace)
442{
443 cds_list_del(&trace->list);
444 free(trace);
445}
446
447int ltt_trace_set_type(const char *trace_name, const char *trace_type)
448{
449 int err = 0;
450 struct ust_trace *trace;
451 struct ltt_transport *tran_iter, *transport = NULL;
452
453 ltt_lock_traces();
454
455 trace = _ltt_trace_find_setup(trace_name);
456 if (!trace) {
457 ERR("Trace not found %s", trace_name);
458 err = -ENOENT;
459 goto traces_error;
460 }
461
462 pthread_mutex_lock(&ltt_transport_mutex);
463 cds_list_for_each_entry(tran_iter, &ltt_transport_list, node) {
464 if (!strcmp(tran_iter->name, trace_type)) {
465 transport = tran_iter;
466 break;
467 }
468 }
469 pthread_mutex_unlock(&ltt_transport_mutex);
470
471 if (!transport) {
472 ERR("Transport %s is not present", trace_type);
473 err = -EINVAL;
474 goto traces_error;
475 }
476
477 trace->transport = transport;
478
479traces_error:
480 ltt_unlock_traces();
481 return err;
482}
483
484int ltt_trace_set_channel_subbufsize(const char *trace_name,
485 const char *channel_name, unsigned int size)
486{
487 int err = 0;
488 struct ust_trace *trace;
489 int index;
490
491 ltt_lock_traces();
492
493 trace = _ltt_trace_find_setup(trace_name);
494 if (!trace) {
495 ERR("Trace not found %s", trace_name);
496 err = -ENOENT;
497 goto traces_error;
498 }
499
500 index = ltt_channels_get_index_from_name(channel_name);
501 if (index < 0) {
502 ERR("Channel %s not found", channel_name);
503 err = -ENOENT;
504 goto traces_error;
505 }
506 trace->channels[index].subbuf_size = size;
507
508traces_error:
509 ltt_unlock_traces();
510 return err;
511}
512
513int ltt_trace_set_channel_subbufcount(const char *trace_name,
514 const char *channel_name, unsigned int cnt)
515{
516 int err = 0;
517 struct ust_trace *trace;
518 int index;
519
520 ltt_lock_traces();
521
522 trace = _ltt_trace_find_setup(trace_name);
523 if (!trace) {
524 ERR("Trace not found %s", trace_name);
525 err = -ENOENT;
526 goto traces_error;
527 }
528
529 index = ltt_channels_get_index_from_name(channel_name);
530 if (index < 0) {
531 ERR("Channel %s not found", channel_name);
532 err = -ENOENT;
533 goto traces_error;
534 }
535 trace->channels[index].subbuf_cnt = cnt;
536
537traces_error:
538 ltt_unlock_traces();
539 return err;
540}
541
542int ltt_trace_set_channel_enable(const char *trace_name,
543 const char *channel_name, unsigned int enable)
544{
545 int err = 0;
546 struct ust_trace *trace;
547 int index;
548
549 ltt_lock_traces();
550
551 trace = _ltt_trace_find_setup(trace_name);
552 if (!trace) {
553 ERR("Trace not found %s", trace_name);
554 err = -ENOENT;
555 goto traces_error;
556 }
557
558 /*
559 * Datas in metadata channel(marker info) is necessary to be able to
560 * read the trace, we always enable this channel.
561 */
562 if (!enable && !strcmp(channel_name, "metadata")) {
563 ERR("Trying to disable metadata channel");
564 err = -EINVAL;
565 goto traces_error;
566 }
567
568 index = ltt_channels_get_index_from_name(channel_name);
569 if (index < 0) {
570 ERR("Channel %s not found", channel_name);
571 err = -ENOENT;
572 goto traces_error;
573 }
574
575 trace->channels[index].active = enable;
576
577traces_error:
578 ltt_unlock_traces();
579 return err;
580}
581
582int ltt_trace_set_channel_overwrite(const char *trace_name,
583 const char *channel_name, unsigned int overwrite)
584{
585 int err = 0;
586 struct ust_trace *trace;
587 int index;
588
589 ltt_lock_traces();
590
591 trace = _ltt_trace_find_setup(trace_name);
592 if (!trace) {
593 ERR("Trace not found %s", trace_name);
594 err = -ENOENT;
595 goto traces_error;
596 }
597
598 /*
599 * Always put the metadata channel in non-overwrite mode :
600 * This is a very low traffic channel and it can't afford to have its
601 * data overwritten : this data (marker info) is necessary to be
602 * able to read the trace.
603 */
604 if (overwrite && !strcmp(channel_name, "metadata")) {
605 ERR("Trying to set metadata channel to overwrite mode");
606 err = -EINVAL;
607 goto traces_error;
608 }
609
610 index = ltt_channels_get_index_from_name(channel_name);
611 if (index < 0) {
612 ERR("Channel %s not found", channel_name);
613 err = -ENOENT;
614 goto traces_error;
615 }
616
617 trace->channels[index].overwrite = overwrite;
618
619traces_error:
620 ltt_unlock_traces();
621 return err;
622}
623
624int ltt_trace_alloc(const char *trace_name)
625{
626 int err = 0;
627 struct ust_trace *trace;
628 unsigned int subbuf_size, subbuf_cnt;
629//ust// unsigned long flags;
630 int chan;
631 const char *channel_name;
632
633 ltt_lock_traces();
634
635 if (_ltt_trace_find(trace_name)) { /* Trace already allocated */
636 err = 1;
637 goto traces_error;
638 }
639
640 trace = _ltt_trace_find_setup(trace_name);
641 if (!trace) {
642 ERR("Trace not found %s", trace_name);
643 err = -ENOENT;
644 goto traces_error;
645 }
646
647 urcu_ref_init(&trace->urcu_ref);
648 urcu_ref_init(&trace->ltt_transport_urcu_ref);
649//ust// init_waitqueue_head(&trace->urcu_ref_wq);
650 trace->active = 0;
651//ust// get_trace_clock();
652 trace->freq_scale = trace_clock_freq_scale();
653
654 if (!trace->transport) {
655 ERR("Transport is not set");
656 err = -EINVAL;
657 goto transport_error;
658 }
659//ust// if (!try_module_get(trace->transport->owner)) {
660//ust// ERR("Can't lock transport module");
661//ust// err = -ENODEV;
662//ust// goto transport_error;
663//ust// }
664 trace->ops = &trace->transport->ops;
665
666//ust// err = trace->ops->create_dirs(trace);
667//ust// if (err) {
668//ust// ERR("Can't create dir for trace %s", trace_name);
669//ust// goto dirs_error;
670//ust// }
671
672//ust// local_irq_save(flags);
673 trace->start_freq = trace_clock_frequency();
674 trace->start_tsc = trace_clock_read64();
675 gettimeofday(&trace->start_time, NULL); //ust// changed /* FIXME: is this ok? */
676//ust// local_irq_restore(flags);
677
678 for (chan = 0; chan < trace->nr_channels; chan++) {
679 if (!(trace->channels[chan].active))
680 continue;
681
682 channel_name = ltt_channels_get_name_from_index(chan);
683 WARN_ON(!channel_name);
684 subbuf_size = trace->channels[chan].subbuf_size;
685 subbuf_cnt = trace->channels[chan].subbuf_cnt;
686 prepare_chan_size_num(&subbuf_size, &subbuf_cnt);
687 err = trace->ops->create_channel(trace_name, trace,
688 channel_name,
689 &trace->channels[chan],
690 subbuf_size,
691 subbuf_cnt,
692 trace->channels[chan].overwrite);
693 if (err != 0) {
694 ERR("Cannot create channel %s", channel_name);
695 goto create_channel_error;
696 }
697 }
698
699 cds_list_del(&trace->list);
700//ust// if (cds_list_empty(&ltt_traces.head)) {
701//ust// mod_timer(&ltt_async_wakeup_timer,
702//ust// jiffies + LTT_PERCPU_TIMER_INTERVAL);
703//ust// set_kernel_trace_flag_all_tasks();
704//ust// }
705 cds_list_add_rcu(&trace->list, &ltt_traces.head);
706//ust// synchronize_sched();
707
708 ltt_unlock_traces();
709
710 return 0;
711
712create_channel_error:
713 for (chan--; chan >= 0; chan--)
714 if (trace->channels[chan].active)
715 trace->ops->remove_channel(&trace->channels[chan]);
716
717//ust// dirs_error:
718//ust// module_put(trace->transport->owner);
719transport_error:
720//ust// put_trace_clock();
721traces_error:
722 ltt_unlock_traces();
723 return err;
724}
725
726/*
727 * It is worked as a wrapper for current version of ltt_control.ko.
728 * We will make a new ltt_control based on debugfs, and control each channel's
729 * buffer.
730 */
731//ust// static int ltt_trace_create(const char *trace_name, const char *trace_type,
732//ust// enum trace_mode mode,
733//ust// unsigned int subbuf_size_low, unsigned int n_subbufs_low,
734//ust// unsigned int subbuf_size_med, unsigned int n_subbufs_med,
735//ust// unsigned int subbuf_size_high, unsigned int n_subbufs_high)
736//ust// {
737//ust// int err = 0;
738//ust//
739//ust// err = ltt_trace_setup(trace_name);
740//ust// if (IS_ERR_VALUE(err))
741//ust// return err;
742//ust//
743//ust// err = ltt_trace_set_type(trace_name, trace_type);
744//ust// if (IS_ERR_VALUE(err))
745//ust// return err;
746//ust//
747//ust// err = ltt_trace_alloc(trace_name);
748//ust// if (IS_ERR_VALUE(err))
749//ust// return err;
750//ust//
751//ust// return err;
752//ust// }
753
754/* Must be called while sure that trace is in the list. */
755static int _ltt_trace_destroy(struct ust_trace *trace)
756{
757 int err = -EPERM;
758
759 if (trace == NULL) {
760 err = -ENOENT;
761 goto traces_error;
762 }
763 if (trace->active) {
764 ERR("Can't destroy trace %s : tracer is active", trace->trace_name);
765 err = -EBUSY;
766 goto active_error;
767 }
768 /* Everything went fine */
769 cds_list_del_rcu(&trace->list);
770 synchronize_rcu();
771 if (cds_list_empty(&ltt_traces.head)) {
772//ust// clear_kernel_trace_flag_all_tasks();
773 /*
774 * We stop the asynchronous delivery of reader wakeup, but
775 * we must make one last check for reader wakeups pending
776 * later in __ltt_trace_destroy.
777 */
778//ust// del_timer_sync(&ltt_async_wakeup_timer);
779 }
780 return 0;
781
782 /* error handling */
783active_error:
784traces_error:
785 return err;
786}
787
788/* Sleepable part of the destroy */
789static void __ltt_trace_destroy(struct ust_trace *trace, int drop)
790{
791 int i;
792 struct ust_channel *chan;
793
794 if(!drop) {
795 for (i = 0; i < trace->nr_channels; i++) {
796 chan = &trace->channels[i];
797 if (chan->active)
798 trace->ops->finish_channel(chan);
799 }
800 }
801
802 /*
803 * The currently destroyed trace is not in the trace list anymore,
804 * so it's safe to call the async wakeup ourself. It will deliver
805 * the last subbuffers.
806 */
807 trace_async_wakeup(trace);
808
809 for (i = 0; i < trace->nr_channels; i++) {
810 chan = &trace->channels[i];
811 if (chan->active)
812 trace->ops->remove_channel(chan);
813 }
814
815 urcu_ref_put(&trace->ltt_transport_urcu_ref, ltt_release_transport);
816
817//ust// module_put(trace->transport->owner);
818
819 /*
820 * Wait for lttd readers to release the files, therefore making sure
821 * the last subbuffers have been read.
822 */
823//ust// if (atomic_read(&trace->kref.refcount) > 1) {
824//ust// int ret = 0;
825//ust// __wait_event_interruptible(trace->kref_wq,
826//ust// (atomic_read(&trace->kref.refcount) == 1), ret);
827//ust// }
828 urcu_ref_put(&trace->urcu_ref, ltt_release_trace);
829}
830
831int ltt_trace_destroy(const char *trace_name, int drop)
832{
833 int err = 0;
834 struct ust_trace *trace;
835
836 ltt_lock_traces();
837
838 trace = _ltt_trace_find(trace_name);
839 if (trace) {
840 err = _ltt_trace_destroy(trace);
841 if (err)
842 goto error;
843
844 ltt_unlock_traces();
845
846 __ltt_trace_destroy(trace, drop);
847//ust// put_trace_clock();
848
849 return 0;
850 }
851
852 trace = _ltt_trace_find_setup(trace_name);
853 if (trace) {
854 _ltt_trace_free(trace);
855 ltt_unlock_traces();
856 return 0;
857 }
858
859 err = -ENOENT;
860
861 /* Error handling */
862error:
863 ltt_unlock_traces();
864 return err;
865}
866
867/* must be called from within a traces lock. */
868static int _ltt_trace_start(struct ust_trace *trace)
869{
870 int err = 0;
871
872 if (trace == NULL) {
873 err = -ENOENT;
874 goto traces_error;
875 }
876 if (trace->active)
877 DBG("Tracing already active for trace %s", trace->trace_name);
878//ust// if (!try_module_get(ltt_run_filter_owner)) {
879//ust// err = -ENODEV;
880//ust// ERR("Cannot lock filter module");
881//ust// goto get_ltt_run_filter_error;
882//ust// }
883 trace->active = 1;
884 /* Read by trace points without protection : be careful */
885 ltt_traces.num_active_traces++;
886 return err;
887
888 /* error handling */
889//ust// get_ltt_run_filter_error:
890traces_error:
891 return err;
892}
893
894int ltt_trace_start(const char *trace_name)
895{
896 int err = 0;
897 struct ust_trace *trace;
898
899 ltt_lock_traces();
900
901 trace = _ltt_trace_find(trace_name);
902 err = _ltt_trace_start(trace);
903 if (err)
904 goto no_trace;
905
906 ltt_unlock_traces();
907
908 /*
909 * Call the process-wide state dump.
910 * Notice that there is no protection on the trace : that's exactly
911 * why we iterate on the list and check for trace equality instead of
912 * directly using this trace handle inside the logging function: we want
913 * to record events only in a single trace in the trace session list.
914 */
915
916 ltt_dump_marker_state(trace);
917
918//ust// if (!try_module_get(ltt_statedump_owner)) {
919//ust// err = -ENODEV;
920//ust// ERR("Cannot lock state dump module");
921//ust// } else {
922 ltt_statedump_functor(trace);
923//ust// module_put(ltt_statedump_owner);
924//ust// }
925
926 return err;
927
928 /* Error handling */
929no_trace:
930 ltt_unlock_traces();
931 return err;
932}
933
934/* must be called from within traces lock */
935static int _ltt_trace_stop(struct ust_trace *trace)
936{
937 int err = -EPERM;
938
939 if (trace == NULL) {
940 err = -ENOENT;
941 goto traces_error;
942 }
943 if (!trace->active)
944 DBG("LTT : Tracing not active for trace %s", trace->trace_name);
945 if (trace->active) {
946 trace->active = 0;
947 ltt_traces.num_active_traces--;
948//ust// synchronize_sched(); /* Wait for each tracing to be finished */
949 }
950//ust// module_put(ltt_run_filter_owner);
951 /* Everything went fine */
952 return 0;
953
954 /* Error handling */
955traces_error:
956 return err;
957}
958
959int ltt_trace_stop(const char *trace_name)
960{
961 int err = 0;
962 struct ust_trace *trace;
963
964 ltt_lock_traces();
965 trace = _ltt_trace_find(trace_name);
966 err = _ltt_trace_stop(trace);
967 ltt_unlock_traces();
968 return err;
969}
970
971/**
972 * ltt_filter_control - Trace filter control in-kernel API
973 * @msg: Action to perform on the filter
974 * @trace_name: Trace on which the action must be done
975 */
976int ltt_filter_control(enum ltt_filter_control_msg msg, const char *trace_name)
977{
978 int err;
979 struct ust_trace *trace;
980
981 DBG("ltt_filter_control : trace %s", trace_name);
982 ltt_lock_traces();
983 trace = _ltt_trace_find(trace_name);
984 if (trace == NULL) {
985 ERR("Trace does not exist. Cannot proxy control request");
986 err = -ENOENT;
987 goto trace_error;
988 }
989//ust// if (!try_module_get(ltt_filter_control_owner)) {
990//ust// err = -ENODEV;
991//ust// goto get_module_error;
992//ust// }
993 switch (msg) {
994 case LTT_FILTER_DEFAULT_ACCEPT:
995 DBG("Proxy filter default accept %s", trace_name);
996 err = (*ltt_filter_control_functor)(msg, trace);
997 break;
998 case LTT_FILTER_DEFAULT_REJECT:
999 DBG("Proxy filter default reject %s", trace_name);
1000 err = (*ltt_filter_control_functor)(msg, trace);
1001 break;
1002 default:
1003 err = -EPERM;
1004 }
1005//ust// module_put(ltt_filter_control_owner);
1006
1007//ust// get_module_error:
1008trace_error:
1009 ltt_unlock_traces();
1010 return err;
1011}
UST 0.x - Userspace Tracer
This page took 0.029751 seconds and 4 git commands to generate.