projects / ust.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
fork: child should issue synchronize_rcu() for urcu-bp garbage collection
[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
186/**
187 * ltt_transport_register - LTT transport registration
188 * @transport: transport structure
189 *
190 * Registers a transport which can be used as output to extract the data out of
191 * LTTng. The module calling this registration function must ensure that no
192 * trap-inducing code will be executed by the transport functions. E.g.
193 * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
194 * is made visible to the transport function. This registration acts as a
195 * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
196 * after its registration must it synchronize the TLBs.
197 */
198void ltt_transport_register(struct ltt_transport *transport)
199{
200 /*
201 * Make sure no page fault can be triggered by the module about to be
202 * registered. We deal with this here so we don't have to call
203 * vmalloc_sync_all() in each module's init.
204 */
205//ust// vmalloc_sync_all();
206
207 ltt_lock_traces();
208 cds_list_add_tail(&transport->node, &ltt_transport_list);
209 ltt_unlock_traces();
210}
211
212/**
213 * ltt_transport_unregister - LTT transport unregistration
214 * @transport: transport structure
215 */
216void ltt_transport_unregister(struct ltt_transport *transport)
217{
218 ltt_lock_traces();
219 cds_list_del(&transport->node);
220 ltt_unlock_traces();
221}
222
223static inline int is_channel_overwrite(enum ltt_channels chan,
224 enum trace_mode mode)
225{
226 switch (mode) {
227 case LTT_TRACE_NORMAL:
228 return 0;
229 case LTT_TRACE_FLIGHT:
230 switch (chan) {
231 case LTT_CHANNEL_METADATA:
232 return 0;
233 default:
234 return 1;
235 }
236 case LTT_TRACE_HYBRID:
237 switch (chan) {
238 case LTT_CHANNEL_METADATA:
239 return 0;
240 default:
241 return 1;
242 }
243 default:
244 return 0;
245 }
246}
247
248static void trace_async_wakeup(struct ust_trace *trace)
249{
250 int i;
251 struct ust_channel *chan;
252
253 /* Must check each channel for pending read wakeup */
254 for (i = 0; i < trace->nr_channels; i++) {
255 chan = &trace->channels[i];
256 if (chan->active)
257 trace->ops->wakeup_channel(chan);
258 }
259}
260
261//ust// /* Timer to send async wakeups to the readers */
262//ust// static void async_wakeup(unsigned long data)
263//ust// {
264//ust// struct ust_trace *trace;
265//ust//
266//ust// /*
267//ust// * PREEMPT_RT does not allow spinlocks to be taken within preempt
268//ust// * disable sections (spinlock taken in wake_up). However, mainline won't
269//ust// * allow mutex to be taken in interrupt context. Ugly.
270//ust// * A proper way to do this would be to turn the timer into a
271//ust// * periodically woken up thread, but it adds to the footprint.
272//ust// */
273//ust// #ifndef CONFIG_PREEMPT_RT
274//ust// rcu_read_lock_sched();
275//ust// #else
276//ust// ltt_lock_traces();
277//ust// #endif
278//ust// cds_list_for_each_entry_rcu(trace, &ltt_traces.head, list) {
279//ust// trace_async_wakeup(trace);
280//ust// }
281//ust// #ifndef CONFIG_PREEMPT_RT
282//ust// rcu_read_unlock_sched();
283//ust// #else
284//ust// ltt_unlock_traces();
285//ust// #endif
286//ust//
287//ust// mod_timer(&ltt_async_wakeup_timer, jiffies + LTT_PERCPU_TIMER_INTERVAL);
288//ust// }
289
290/**
291 * _ltt_trace_find - find a trace by given name.
292 * trace_name: trace name
293 *
294 * Returns a pointer to the trace structure, NULL if not found.
295 */
296struct ust_trace *_ltt_trace_find(const char *trace_name)
297{
298 struct ust_trace *trace;
299
300 cds_list_for_each_entry(trace, &ltt_traces.head, list)
301 if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
302 return trace;
303
304 return NULL;
305}
306
307/* _ltt_trace_find_setup :
308 * find a trace in setup list by given name.
309 *
310 * Returns a pointer to the trace structure, NULL if not found.
311 */
312struct ust_trace *_ltt_trace_find_setup(const char *trace_name)
313{
314 struct ust_trace *trace;
315
316 cds_list_for_each_entry(trace, &ltt_traces.setup_head, list)
317 if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
318 return trace;
319
320 return NULL;
321}
322
323/**
324 * ltt_release_transport - Release an LTT transport
325 * @kref : reference count on the transport
326 */
327void ltt_release_transport(struct urcu_ref *urcu_ref)
328{
329//ust// struct ust_trace *trace = container_of(kref,
330//ust// struct ust_trace, ltt_transport_kref);
331//ust// trace->ops->remove_dirs(trace);
332}
333
334/**
335 * ltt_release_trace - Release a LTT trace
336 * @kref : reference count on the trace
337 */
338void ltt_release_trace(struct urcu_ref *urcu_ref)
339{
340 struct ust_trace *trace = _ust_container_of(urcu_ref,
341 struct ust_trace, urcu_ref);
342 ltt_channels_trace_free(trace->channels);
343 free(trace);
344}
345
346static inline void prepare_chan_size_num(unsigned int *subbuf_size,
347 unsigned int *n_subbufs)
348{
349 /* Make sure the subbuffer size is larger than a page */
350 *subbuf_size = max_t(unsigned int, *subbuf_size, PAGE_SIZE);
351
352 /* round to next power of 2 */
353 *subbuf_size = 1 << get_count_order(*subbuf_size);
354 *n_subbufs = 1 << get_count_order(*n_subbufs);
355
356 /* Subbuf size and number must both be power of two */
357 WARN_ON(hweight32(*subbuf_size) != 1);
358 WARN_ON(hweight32(*n_subbufs) != 1);
359}
360
361int _ltt_trace_setup(const char *trace_name)
362{
363 int err = 0;
364 struct ust_trace *new_trace = NULL;
365 int metadata_index;
366 unsigned int chan;
367 enum ltt_channels chantype;
368
369 if (_ltt_trace_find_setup(trace_name)) {
370 ERR("Trace name %s already used", trace_name);
371 err = -EEXIST;
372 goto traces_error;
373 }
374
375 if (_ltt_trace_find(trace_name)) {
376 ERR("Trace name %s already used", trace_name);
377 err = -EEXIST;
378 goto traces_error;
379 }
380
381 new_trace = zmalloc(sizeof(struct ust_trace));
382 if (!new_trace) {
383 ERR("Unable to allocate memory for trace %s", trace_name);
384 err = -ENOMEM;
385 goto traces_error;
386 }
387 strncpy(new_trace->trace_name, trace_name, NAME_MAX);
388 new_trace->channels = ltt_channels_trace_alloc(&new_trace->nr_channels,
389 ust_channels_overwrite_by_default,
390 ust_channels_request_collection_by_default, 1);
391 if (!new_trace->channels) {
392 ERR("Unable to allocate memory for chaninfo %s\n", trace_name);
393 err = -ENOMEM;
394 goto trace_free;
395 }
396
397 /*
398 * Force metadata channel to active, no overwrite.
399 */
400 metadata_index = ltt_channels_get_index_from_name("metadata");
401 WARN_ON(metadata_index < 0);
402 new_trace->channels[metadata_index].overwrite = 0;
403 new_trace->channels[metadata_index].active = 1;
404
405 /*
406 * Set hardcoded tracer defaults for some channels
407 */
408 for (chan = 0; chan < new_trace->nr_channels; chan++) {
409 if (!(new_trace->channels[chan].active))
410 continue;
411
412 chantype = get_channel_type_from_name(
413 ltt_channels_get_name_from_index(chan));
414 new_trace->channels[chan].subbuf_size =
415 chan_infos[chantype].def_subbufsize;
416 new_trace->channels[chan].subbuf_cnt =
417 chan_infos[chantype].def_subbufcount;
418 }
419
420 cds_list_add(&new_trace->list, &ltt_traces.setup_head);
421 return 0;
422
423trace_free:
424 free(new_trace);
425traces_error:
426 return err;
427}
428
429
430int ltt_trace_setup(const char *trace_name)
431{
432 int ret;
433 ltt_lock_traces();
434 ret = _ltt_trace_setup(trace_name);
435 ltt_unlock_traces();
436 return ret;
437}
438
439/* must be called from within a traces lock. */
440static void _ltt_trace_free(struct ust_trace *trace)
441{
442 cds_list_del(&trace->list);
443 free(trace);
444}
445
446int ltt_trace_set_type(const char *trace_name, const char *trace_type)
447{
448 int err = 0;
449 struct ust_trace *trace;
450 struct ltt_transport *tran_iter, *transport = NULL;
451
452 ltt_lock_traces();
453
454 trace = _ltt_trace_find_setup(trace_name);
455 if (!trace) {
456 ERR("Trace not found %s", trace_name);
457 err = -ENOENT;
458 goto traces_error;
459 }
460
461 cds_list_for_each_entry(tran_iter, &ltt_transport_list, node) {
462 if (!strcmp(tran_iter->name, trace_type)) {
463 transport = tran_iter;
464 break;
465 }
466 }
467 if (!transport) {
468 ERR("Transport %s is not present", trace_type);
469 err = -EINVAL;
470 goto traces_error;
471 }
472
473 trace->transport = transport;
474
475traces_error:
476 ltt_unlock_traces();
477 return err;
478}
479
480int ltt_trace_set_channel_subbufsize(const char *trace_name,
481 const char *channel_name, unsigned int size)
482{
483 int err = 0;
484 struct ust_trace *trace;
485 int index;
486
487 ltt_lock_traces();
488
489 trace = _ltt_trace_find_setup(trace_name);
490 if (!trace) {
491 ERR("Trace not found %s", trace_name);
492 err = -ENOENT;
493 goto traces_error;
494 }
495
496 index = ltt_channels_get_index_from_name(channel_name);
497 if (index < 0) {
498 ERR("Channel %s not found", channel_name);
499 err = -ENOENT;
500 goto traces_error;
501 }
502 trace->channels[index].subbuf_size = size;
503
504traces_error:
505 ltt_unlock_traces();
506 return err;
507}
508
509int ltt_trace_set_channel_subbufcount(const char *trace_name,
510 const char *channel_name, unsigned int cnt)
511{
512 int err = 0;
513 struct ust_trace *trace;
514 int index;
515
516 ltt_lock_traces();
517
518 trace = _ltt_trace_find_setup(trace_name);
519 if (!trace) {
520 ERR("Trace not found %s", trace_name);
521 err = -ENOENT;
522 goto traces_error;
523 }
524
525 index = ltt_channels_get_index_from_name(channel_name);
526 if (index < 0) {
527 ERR("Channel %s not found", channel_name);
528 err = -ENOENT;
529 goto traces_error;
530 }
531 trace->channels[index].subbuf_cnt = cnt;
532
533traces_error:
534 ltt_unlock_traces();
535 return err;
536}
537
538int ltt_trace_set_channel_enable(const char *trace_name,
539 const char *channel_name, unsigned int enable)
540{
541 int err = 0;
542 struct ust_trace *trace;
543 int index;
544
545 ltt_lock_traces();
546
547 trace = _ltt_trace_find_setup(trace_name);
548 if (!trace) {
549 ERR("Trace not found %s", trace_name);
550 err = -ENOENT;
551 goto traces_error;
552 }
553
554 /*
555 * Datas in metadata channel(marker info) is necessary to be able to
556 * read the trace, we always enable this channel.
557 */
558 if (!enable && !strcmp(channel_name, "metadata")) {
559 ERR("Trying to disable metadata channel");
560 err = -EINVAL;
561 goto traces_error;
562 }
563
564 index = ltt_channels_get_index_from_name(channel_name);
565 if (index < 0) {
566 ERR("Channel %s not found", channel_name);
567 err = -ENOENT;
568 goto traces_error;
569 }
570
571 trace->channels[index].active = enable;
572
573traces_error:
574 ltt_unlock_traces();
575 return err;
576}
577
578int ltt_trace_set_channel_overwrite(const char *trace_name,
579 const char *channel_name, unsigned int overwrite)
580{
581 int err = 0;
582 struct ust_trace *trace;
583 int index;
584
585 ltt_lock_traces();
586
587 trace = _ltt_trace_find_setup(trace_name);
588 if (!trace) {
589 ERR("Trace not found %s", trace_name);
590 err = -ENOENT;
591 goto traces_error;
592 }
593
594 /*
595 * Always put the metadata channel in non-overwrite mode :
596 * This is a very low traffic channel and it can't afford to have its
597 * data overwritten : this data (marker info) is necessary to be
598 * able to read the trace.
599 */
600 if (overwrite && !strcmp(channel_name, "metadata")) {
601 ERR("Trying to set metadata channel to overwrite mode");
602 err = -EINVAL;
603 goto traces_error;
604 }
605
606 index = ltt_channels_get_index_from_name(channel_name);
607 if (index < 0) {
608 ERR("Channel %s not found", channel_name);
609 err = -ENOENT;
610 goto traces_error;
611 }
612
613 trace->channels[index].overwrite = overwrite;
614
615traces_error:
616 ltt_unlock_traces();
617 return err;
618}
619
620int ltt_trace_alloc(const char *trace_name)
621{
622 int err = 0;
623 struct ust_trace *trace;
624 unsigned int subbuf_size, subbuf_cnt;
625//ust// unsigned long flags;
626 int chan;
627 const char *channel_name;
628
629 ltt_lock_traces();
630
631 if (_ltt_trace_find(trace_name)) { /* Trace already allocated */
632 err = 1;
633 goto traces_error;
634 }
635
636 trace = _ltt_trace_find_setup(trace_name);
637 if (!trace) {
638 ERR("Trace not found %s", trace_name);
639 err = -ENOENT;
640 goto traces_error;
641 }
642
643 urcu_ref_init(&trace->urcu_ref);
644 urcu_ref_init(&trace->ltt_transport_urcu_ref);
645//ust// init_waitqueue_head(&trace->urcu_ref_wq);
646 trace->active = 0;
647//ust// get_trace_clock();
648 trace->freq_scale = trace_clock_freq_scale();
649
650 if (!trace->transport) {
651 ERR("Transport is not set");
652 err = -EINVAL;
653 goto transport_error;
654 }
655//ust// if (!try_module_get(trace->transport->owner)) {
656//ust// ERR("Can't lock transport module");
657//ust// err = -ENODEV;
658//ust// goto transport_error;
659//ust// }
660 trace->ops = &trace->transport->ops;
661
662//ust// err = trace->ops->create_dirs(trace);
663//ust// if (err) {
664//ust// ERR("Can't create dir for trace %s", trace_name);
665//ust// goto dirs_error;
666//ust// }
667
668//ust// local_irq_save(flags);
669 trace->start_freq = trace_clock_frequency();
670 trace->start_tsc = trace_clock_read64();
671 gettimeofday(&trace->start_time, NULL); //ust// changed /* FIXME: is this ok? */
672//ust// local_irq_restore(flags);
673
674 for (chan = 0; chan < trace->nr_channels; chan++) {
675 if (!(trace->channels[chan].active))
676 continue;
677
678 channel_name = ltt_channels_get_name_from_index(chan);
679 WARN_ON(!channel_name);
680 subbuf_size = trace->channels[chan].subbuf_size;
681 subbuf_cnt = trace->channels[chan].subbuf_cnt;
682 prepare_chan_size_num(&subbuf_size, &subbuf_cnt);
683 err = trace->ops->create_channel(trace_name, trace,
684 channel_name,
685 &trace->channels[chan],
686 subbuf_size,
687 subbuf_cnt,
688 trace->channels[chan].overwrite);
689 if (err != 0) {
690 ERR("Cannot create channel %s", channel_name);
691 goto create_channel_error;
692 }
693 }
694
695 cds_list_del(&trace->list);
696//ust// if (cds_list_empty(&ltt_traces.head)) {
697//ust// mod_timer(&ltt_async_wakeup_timer,
698//ust// jiffies + LTT_PERCPU_TIMER_INTERVAL);
699//ust// set_kernel_trace_flag_all_tasks();
700//ust// }
701 cds_list_add_rcu(&trace->list, &ltt_traces.head);
702//ust// synchronize_sched();
703
704 ltt_unlock_traces();
705
706 return 0;
707
708create_channel_error:
709 for (chan--; chan >= 0; chan--)
710 if (trace->channels[chan].active)
711 trace->ops->remove_channel(&trace->channels[chan]);
712
713//ust// dirs_error:
714//ust// module_put(trace->transport->owner);
715transport_error:
716//ust// put_trace_clock();
717traces_error:
718 ltt_unlock_traces();
719 return err;
720}
721
722/*
723 * It is worked as a wrapper for current version of ltt_control.ko.
724 * We will make a new ltt_control based on debugfs, and control each channel's
725 * buffer.
726 */
727//ust// static int ltt_trace_create(const char *trace_name, const char *trace_type,
728//ust// enum trace_mode mode,
729//ust// unsigned int subbuf_size_low, unsigned int n_subbufs_low,
730//ust// unsigned int subbuf_size_med, unsigned int n_subbufs_med,
731//ust// unsigned int subbuf_size_high, unsigned int n_subbufs_high)
732//ust// {
733//ust// int err = 0;
734//ust//
735//ust// err = ltt_trace_setup(trace_name);
736//ust// if (IS_ERR_VALUE(err))
737//ust// return err;
738//ust//
739//ust// err = ltt_trace_set_type(trace_name, trace_type);
740//ust// if (IS_ERR_VALUE(err))
741//ust// return err;
742//ust//
743//ust// err = ltt_trace_alloc(trace_name);
744//ust// if (IS_ERR_VALUE(err))
745//ust// return err;
746//ust//
747//ust// return err;
748//ust// }
749
750/* Must be called while sure that trace is in the list. */
751static int _ltt_trace_destroy(struct ust_trace *trace)
752{
753 int err = -EPERM;
754
755 if (trace == NULL) {
756 err = -ENOENT;
757 goto traces_error;
758 }
759 if (trace->active) {
760 ERR("Can't destroy trace %s : tracer is active", trace->trace_name);
761 err = -EBUSY;
762 goto active_error;
763 }
764 /* Everything went fine */
765 cds_list_del_rcu(&trace->list);
766 synchronize_rcu();
767 if (cds_list_empty(&ltt_traces.head)) {
768//ust// clear_kernel_trace_flag_all_tasks();
769 /*
770 * We stop the asynchronous delivery of reader wakeup, but
771 * we must make one last check for reader wakeups pending
772 * later in __ltt_trace_destroy.
773 */
774//ust// del_timer_sync(&ltt_async_wakeup_timer);
775 }
776 return 0;
777
778 /* error handling */
779active_error:
780traces_error:
781 return err;
782}
783
784/* Sleepable part of the destroy */
785static void __ltt_trace_destroy(struct ust_trace *trace, int drop)
786{
787 int i;
788 struct ust_channel *chan;
789
790 if(!drop) {
791 for (i = 0; i < trace->nr_channels; i++) {
792 chan = &trace->channels[i];
793 if (chan->active)
794 trace->ops->finish_channel(chan);
795 }
796 }
797
798 /*
799 * The currently destroyed trace is not in the trace list anymore,
800 * so it's safe to call the async wakeup ourself. It will deliver
801 * the last subbuffers.
802 */
803 trace_async_wakeup(trace);
804
805 for (i = 0; i < trace->nr_channels; i++) {
806 chan = &trace->channels[i];
807 if (chan->active)
808 trace->ops->remove_channel(chan);
809 }
810
811 urcu_ref_put(&trace->ltt_transport_urcu_ref, ltt_release_transport);
812
813//ust// module_put(trace->transport->owner);
814
815 /*
816 * Wait for lttd readers to release the files, therefore making sure
817 * the last subbuffers have been read.
818 */
819//ust// if (atomic_read(&trace->kref.refcount) > 1) {
820//ust// int ret = 0;
821//ust// __wait_event_interruptible(trace->kref_wq,
822//ust// (atomic_read(&trace->kref.refcount) == 1), ret);
823//ust// }
824 urcu_ref_put(&trace->urcu_ref, ltt_release_trace);
825}
826
827int ltt_trace_destroy(const char *trace_name, int drop)
828{
829 int err = 0;
830 struct ust_trace *trace;
831
832 ltt_lock_traces();
833
834 trace = _ltt_trace_find(trace_name);
835 if (trace) {
836 err = _ltt_trace_destroy(trace);
837 if (err)
838 goto error;
839
840 ltt_unlock_traces();
841
842 __ltt_trace_destroy(trace, drop);
843//ust// put_trace_clock();
844
845 return 0;
846 }
847
848 trace = _ltt_trace_find_setup(trace_name);
849 if (trace) {
850 _ltt_trace_free(trace);
851 ltt_unlock_traces();
852 return 0;
853 }
854
855 err = -ENOENT;
856
857 /* Error handling */
858error:
859 ltt_unlock_traces();
860 return err;
861}
862
863/* must be called from within a traces lock. */
864static int _ltt_trace_start(struct ust_trace *trace)
865{
866 int err = 0;
867
868 if (trace == NULL) {
869 err = -ENOENT;
870 goto traces_error;
871 }
872 if (trace->active)
873 DBG("Tracing already active for trace %s", trace->trace_name);
874//ust// if (!try_module_get(ltt_run_filter_owner)) {
875//ust// err = -ENODEV;
876//ust// ERR("Cannot lock filter module");
877//ust// goto get_ltt_run_filter_error;
878//ust// }
879 trace->active = 1;
880 /* Read by trace points without protection : be careful */
881 ltt_traces.num_active_traces++;
882 return err;
883
884 /* error handling */
885//ust// get_ltt_run_filter_error:
886traces_error:
887 return err;
888}
889
890int ltt_trace_start(const char *trace_name)
891{
892 int err = 0;
893 struct ust_trace *trace;
894
895 ltt_lock_traces();
896
897 trace = _ltt_trace_find(trace_name);
898 err = _ltt_trace_start(trace);
899 if (err)
900 goto no_trace;
901
902 ltt_unlock_traces();
903
904 /*
905 * Call the kernel state dump.
906 * Events will be mixed with real kernel events, it's ok.
907 * Notice that there is no protection on the trace : that's exactly
908 * why we iterate on the list and check for trace equality instead of
909 * directly using this trace handle inside the logging function.
910 */
911
912 ltt_dump_marker_state(trace);
913
914//ust// if (!try_module_get(ltt_statedump_owner)) {
915//ust// err = -ENODEV;
916//ust// ERR("Cannot lock state dump module");
917//ust// } else {
918 ltt_statedump_functor(trace);
919//ust// module_put(ltt_statedump_owner);
920//ust// }
921
922 return err;
923
924 /* Error handling */
925no_trace:
926 ltt_unlock_traces();
927 return err;
928}
929
930/* must be called from within traces lock */
931static int _ltt_trace_stop(struct ust_trace *trace)
932{
933 int err = -EPERM;
934
935 if (trace == NULL) {
936 err = -ENOENT;
937 goto traces_error;
938 }
939 if (!trace->active)
940 DBG("LTT : Tracing not active for trace %s", trace->trace_name);
941 if (trace->active) {
942 trace->active = 0;
943 ltt_traces.num_active_traces--;
944//ust// synchronize_sched(); /* Wait for each tracing to be finished */
945 }
946//ust// module_put(ltt_run_filter_owner);
947 /* Everything went fine */
948 return 0;
949
950 /* Error handling */
951traces_error:
952 return err;
953}
954
955int ltt_trace_stop(const char *trace_name)
956{
957 int err = 0;
958 struct ust_trace *trace;
959
960 ltt_lock_traces();
961 trace = _ltt_trace_find(trace_name);
962 err = _ltt_trace_stop(trace);
963 ltt_unlock_traces();
964 return err;
965}
966
967/**
968 * ltt_filter_control - Trace filter control in-kernel API
969 * @msg: Action to perform on the filter
970 * @trace_name: Trace on which the action must be done
971 */
972int ltt_filter_control(enum ltt_filter_control_msg msg, const char *trace_name)
973{
974 int err;
975 struct ust_trace *trace;
976
977 DBG("ltt_filter_control : trace %s", trace_name);
978 ltt_lock_traces();
979 trace = _ltt_trace_find(trace_name);
980 if (trace == NULL) {
981 ERR("Trace does not exist. Cannot proxy control request");
982 err = -ENOENT;
983 goto trace_error;
984 }
985//ust// if (!try_module_get(ltt_filter_control_owner)) {
986//ust// err = -ENODEV;
987//ust// goto get_module_error;
988//ust// }
989 switch (msg) {
990 case LTT_FILTER_DEFAULT_ACCEPT:
991 DBG("Proxy filter default accept %s", trace_name);
992 err = (*ltt_filter_control_functor)(msg, trace);
993 break;
994 case LTT_FILTER_DEFAULT_REJECT:
995 DBG("Proxy filter default reject %s", trace_name);
996 err = (*ltt_filter_control_functor)(msg, trace);
997 break;
998 default:
999 err = -EPERM;
1000 }
1001//ust// module_put(ltt_filter_control_owner);
1002
1003//ust// get_module_error:
1004trace_error:
1005 ltt_unlock_traces();
1006 return err;
1007}
UST 0.x - Userspace Tracer
This page took 0.027652 seconds and 4 git commands to generate.