Commit | Line | Data |
---|---|---|
1c8284eb MD |
1 | /* |
2 | * ltt/ltt-tracer.c | |
3 | * | |
7514523f | 4 | * Copyright (c) 2005-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
1c8284eb MD |
5 | * |
6 | * Tracing management internal kernel API. Trace buffer allocation/free, tracing | |
7 | * start/stop. | |
8 | * | |
9 | * Author: | |
7514523f | 10 | * Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
1c8284eb MD |
11 | * |
12 | * Inspired from LTT : | |
13 | * Karim Yaghmour (karim@opersys.com) | |
14 | * Tom Zanussi (zanussi@us.ibm.com) | |
15 | * Bob Wisniewski (bob@watson.ibm.com) | |
16 | * And from K42 : | |
17 | * Bob Wisniewski (bob@watson.ibm.com) | |
18 | * | |
19 | * Changelog: | |
20 | * 22/09/06, Move to the marker/probes mechanism. | |
21 | * 19/10/05, Complete lockless mechanism. | |
22 | * 27/05/05, Modular redesign and rewrite. | |
23 | * | |
24 | * Dual LGPL v2.1/GPL v2 license. | |
25 | */ | |
26 | ||
27 | #include <linux/time.h> | |
28 | #include <linux/module.h> | |
29 | #include <linux/string.h> | |
30 | #include <linux/slab.h> | |
31 | #include <linux/init.h> | |
32 | #include <linux/rcupdate.h> | |
33 | #include <linux/sched.h> | |
34 | #include <linux/bitops.h> | |
35 | #include <linux/fs.h> | |
36 | #include <linux/cpu.h> | |
37 | #include <linux/kref.h> | |
38 | #include <linux/delay.h> | |
39 | #include <linux/vmalloc.h> | |
40 | #include <asm/atomic.h> | |
41 | ||
42 | #include "ltt-tracer.h" | |
43 | ||
44 | static void synchronize_trace(void) | |
45 | { | |
46 | synchronize_sched(); | |
47 | #ifdef CONFIG_PREEMPT_RT | |
48 | synchronize_rcu(); | |
49 | #endif | |
50 | } | |
51 | ||
52 | static void async_wakeup(unsigned long data); | |
53 | ||
54 | static DEFINE_TIMER(ltt_async_wakeup_timer, async_wakeup, 0, 0); | |
55 | ||
56 | /* Default callbacks for modules */ | |
57 | notrace | |
58 | int ltt_filter_control_default(enum ltt_filter_control_msg msg, | |
59 | struct ltt_trace *trace) | |
60 | { | |
61 | return 0; | |
62 | } | |
63 | ||
64 | int ltt_statedump_default(struct ltt_trace *trace) | |
65 | { | |
66 | return 0; | |
67 | } | |
68 | ||
69 | /* Callbacks for registered modules */ | |
70 | ||
71 | int (*ltt_filter_control_functor) | |
72 | (enum ltt_filter_control_msg msg, struct ltt_trace *trace) = | |
73 | ltt_filter_control_default; | |
74 | struct module *ltt_filter_control_owner; | |
75 | ||
76 | /* These function pointers are protected by a trace activation check */ | |
77 | struct module *ltt_run_filter_owner; | |
78 | int (*ltt_statedump_functor)(struct ltt_trace *trace) = ltt_statedump_default; | |
79 | struct module *ltt_statedump_owner; | |
80 | ||
81 | struct chan_info_struct { | |
82 | const char *name; | |
83 | unsigned int def_sb_size; | |
84 | unsigned int def_n_sb; | |
85 | } chan_infos[] = { | |
86 | [LTT_CHANNEL_METADATA] = { | |
87 | LTT_METADATA_CHANNEL, | |
88 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
89 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
90 | }, | |
91 | [LTT_CHANNEL_FD_STATE] = { | |
92 | LTT_FD_STATE_CHANNEL, | |
93 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
94 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
95 | }, | |
96 | [LTT_CHANNEL_GLOBAL_STATE] = { | |
97 | LTT_GLOBAL_STATE_CHANNEL, | |
98 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
99 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
100 | }, | |
101 | [LTT_CHANNEL_IRQ_STATE] = { | |
102 | LTT_IRQ_STATE_CHANNEL, | |
103 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
104 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
105 | }, | |
106 | [LTT_CHANNEL_MODULE_STATE] = { | |
107 | LTT_MODULE_STATE_CHANNEL, | |
108 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
109 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
110 | }, | |
111 | [LTT_CHANNEL_NETIF_STATE] = { | |
112 | LTT_NETIF_STATE_CHANNEL, | |
113 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
114 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
115 | }, | |
116 | [LTT_CHANNEL_SOFTIRQ_STATE] = { | |
117 | LTT_SOFTIRQ_STATE_CHANNEL, | |
118 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
119 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
120 | }, | |
121 | [LTT_CHANNEL_SWAP_STATE] = { | |
122 | LTT_SWAP_STATE_CHANNEL, | |
123 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
124 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
125 | }, | |
126 | [LTT_CHANNEL_SYSCALL_STATE] = { | |
127 | LTT_SYSCALL_STATE_CHANNEL, | |
128 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
129 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
130 | }, | |
131 | [LTT_CHANNEL_TASK_STATE] = { | |
132 | LTT_TASK_STATE_CHANNEL, | |
133 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
134 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
135 | }, | |
136 | [LTT_CHANNEL_VM_STATE] = { | |
137 | LTT_VM_STATE_CHANNEL, | |
138 | LTT_DEFAULT_SUBBUF_SIZE_MED, | |
139 | LTT_DEFAULT_N_SUBBUFS_MED, | |
140 | }, | |
141 | [LTT_CHANNEL_FS] = { | |
142 | LTT_FS_CHANNEL, | |
143 | LTT_DEFAULT_SUBBUF_SIZE_MED, | |
144 | LTT_DEFAULT_N_SUBBUFS_MED, | |
145 | }, | |
146 | [LTT_CHANNEL_INPUT] = { | |
147 | LTT_INPUT_CHANNEL, | |
148 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
149 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
150 | }, | |
151 | [LTT_CHANNEL_IPC] = { | |
152 | LTT_IPC_CHANNEL, | |
153 | LTT_DEFAULT_SUBBUF_SIZE_LOW, | |
154 | LTT_DEFAULT_N_SUBBUFS_LOW, | |
155 | }, | |
156 | [LTT_CHANNEL_KERNEL] = { | |
157 | LTT_KERNEL_CHANNEL, | |
158 | LTT_DEFAULT_SUBBUF_SIZE_HIGH, | |
159 | LTT_DEFAULT_N_SUBBUFS_HIGH, | |
160 | }, | |
161 | [LTT_CHANNEL_MM] = { | |
162 | LTT_MM_CHANNEL, | |
163 | LTT_DEFAULT_SUBBUF_SIZE_MED, | |
164 | LTT_DEFAULT_N_SUBBUFS_MED, | |
165 | }, | |
166 | [LTT_CHANNEL_RCU] = { | |
167 | LTT_RCU_CHANNEL, | |
168 | LTT_DEFAULT_SUBBUF_SIZE_MED, | |
169 | LTT_DEFAULT_N_SUBBUFS_MED, | |
170 | }, | |
171 | [LTT_CHANNEL_DEFAULT] = { | |
172 | NULL, | |
173 | LTT_DEFAULT_SUBBUF_SIZE_MED, | |
174 | LTT_DEFAULT_N_SUBBUFS_MED, | |
175 | }, | |
176 | }; | |
177 | ||
178 | static enum ltt_channels get_channel_type_from_name(const char *name) | |
179 | { | |
180 | int i; | |
181 | ||
182 | if (!name) | |
183 | return LTT_CHANNEL_DEFAULT; | |
184 | ||
185 | for (i = 0; i < ARRAY_SIZE(chan_infos); i++) | |
186 | if (chan_infos[i].name && !strcmp(name, chan_infos[i].name)) | |
187 | return (enum ltt_channels)i; | |
188 | ||
189 | return LTT_CHANNEL_DEFAULT; | |
190 | } | |
191 | ||
192 | /** | |
193 | * ltt_module_register - LTT module registration | |
194 | * @name: module type | |
195 | * @function: callback to register | |
196 | * @owner: module which owns the callback | |
197 | * | |
198 | * The module calling this registration function must ensure that no | |
199 | * trap-inducing code will be executed by "function". E.g. vmalloc_sync_all() | |
200 | * must be called between a vmalloc and the moment the memory is made visible to | |
201 | * "function". This registration acts as a vmalloc_sync_all. Therefore, only if | |
202 | * the module allocates virtual memory after its registration must it | |
203 | * synchronize the TLBs. | |
204 | */ | |
205 | int ltt_module_register(enum ltt_module_function name, void *function, | |
206 | struct module *owner) | |
207 | { | |
208 | int ret = 0; | |
209 | ||
210 | /* | |
211 | * Make sure no page fault can be triggered by the module about to be | |
212 | * registered. We deal with this here so we don't have to call | |
213 | * vmalloc_sync_all() in each module's init. | |
214 | */ | |
215 | vmalloc_sync_all(); | |
216 | ||
217 | switch (name) { | |
218 | case LTT_FUNCTION_RUN_FILTER: | |
219 | if (ltt_run_filter_owner != NULL) { | |
220 | ret = -EEXIST; | |
221 | goto end; | |
222 | } | |
223 | ltt_filter_register((ltt_run_filter_functor)function); | |
224 | ltt_run_filter_owner = owner; | |
225 | break; | |
226 | case LTT_FUNCTION_FILTER_CONTROL: | |
227 | if (ltt_filter_control_owner != NULL) { | |
228 | ret = -EEXIST; | |
229 | goto end; | |
230 | } | |
231 | ltt_filter_control_functor = | |
232 | (int (*)(enum ltt_filter_control_msg, | |
233 | struct ltt_trace *))function; | |
234 | ltt_filter_control_owner = owner; | |
235 | break; | |
236 | case LTT_FUNCTION_STATEDUMP: | |
237 | if (ltt_statedump_owner != NULL) { | |
238 | ret = -EEXIST; | |
239 | goto end; | |
240 | } | |
241 | ltt_statedump_functor = | |
242 | (int (*)(struct ltt_trace *))function; | |
243 | ltt_statedump_owner = owner; | |
244 | break; | |
245 | } | |
1c8284eb | 246 | end: |
1c8284eb MD |
247 | return ret; |
248 | } | |
249 | EXPORT_SYMBOL_GPL(ltt_module_register); | |
250 | ||
251 | /** | |
252 | * ltt_module_unregister - LTT module unregistration | |
253 | * @name: module type | |
254 | */ | |
255 | void ltt_module_unregister(enum ltt_module_function name) | |
256 | { | |
257 | switch (name) { | |
258 | case LTT_FUNCTION_RUN_FILTER: | |
259 | ltt_filter_unregister(); | |
260 | ltt_run_filter_owner = NULL; | |
261 | /* Wait for preempt sections to finish */ | |
262 | synchronize_trace(); | |
263 | break; | |
264 | case LTT_FUNCTION_FILTER_CONTROL: | |
265 | ltt_filter_control_functor = ltt_filter_control_default; | |
266 | ltt_filter_control_owner = NULL; | |
267 | break; | |
268 | case LTT_FUNCTION_STATEDUMP: | |
269 | ltt_statedump_functor = ltt_statedump_default; | |
270 | ltt_statedump_owner = NULL; | |
271 | break; | |
272 | } | |
273 | ||
274 | } | |
275 | EXPORT_SYMBOL_GPL(ltt_module_unregister); | |
276 | ||
277 | static LIST_HEAD(ltt_transport_list); | |
278 | ||
279 | /** | |
280 | * ltt_transport_register - LTT transport registration | |
281 | * @transport: transport structure | |
282 | * | |
283 | * Registers a transport which can be used as output to extract the data out of | |
284 | * LTTng. The module calling this registration function must ensure that no | |
285 | * trap-inducing code will be executed by the transport functions. E.g. | |
286 | * vmalloc_sync_all() must be called between a vmalloc and the moment the memory | |
287 | * is made visible to the transport function. This registration acts as a | |
288 | * vmalloc_sync_all. Therefore, only if the module allocates virtual memory | |
289 | * after its registration must it synchronize the TLBs. | |
290 | */ | |
291 | void ltt_transport_register(struct ltt_transport *transport) | |
292 | { | |
293 | /* | |
294 | * Make sure no page fault can be triggered by the module about to be | |
295 | * registered. We deal with this here so we don't have to call | |
296 | * vmalloc_sync_all() in each module's init. | |
297 | */ | |
298 | vmalloc_sync_all(); | |
299 | ||
300 | ltt_lock_traces(); | |
301 | list_add_tail(&transport->node, <t_transport_list); | |
302 | ltt_unlock_traces(); | |
303 | } | |
304 | EXPORT_SYMBOL_GPL(ltt_transport_register); | |
305 | ||
306 | /** | |
307 | * ltt_transport_unregister - LTT transport unregistration | |
308 | * @transport: transport structure | |
309 | */ | |
310 | void ltt_transport_unregister(struct ltt_transport *transport) | |
311 | { | |
312 | ltt_lock_traces(); | |
313 | list_del(&transport->node); | |
314 | ltt_unlock_traces(); | |
315 | } | |
316 | EXPORT_SYMBOL_GPL(ltt_transport_unregister); | |
317 | ||
318 | static inline | |
319 | int is_channel_overwrite(enum ltt_channels chan, enum trace_mode mode) | |
320 | { | |
321 | switch (mode) { | |
322 | case LTT_TRACE_NORMAL: | |
323 | return 0; | |
324 | case LTT_TRACE_FLIGHT: | |
325 | switch (chan) { | |
326 | case LTT_CHANNEL_METADATA: | |
327 | return 0; | |
328 | default: | |
329 | return 1; | |
330 | } | |
331 | case LTT_TRACE_HYBRID: | |
332 | switch (chan) { | |
333 | case LTT_CHANNEL_KERNEL: | |
334 | case LTT_CHANNEL_FS: | |
335 | case LTT_CHANNEL_MM: | |
336 | case LTT_CHANNEL_RCU: | |
337 | case LTT_CHANNEL_IPC: | |
338 | case LTT_CHANNEL_INPUT: | |
339 | return 1; | |
340 | default: | |
341 | return 0; | |
342 | } | |
343 | default: | |
344 | return 0; | |
345 | } | |
346 | } | |
347 | ||
1c8284eb MD |
348 | /** |
349 | * _ltt_trace_find - find a trace by given name. | |
350 | * trace_name: trace name | |
351 | * | |
352 | * Returns a pointer to the trace structure, NULL if not found. | |
353 | */ | |
354 | static struct ltt_trace *_ltt_trace_find(const char *trace_name) | |
355 | { | |
356 | struct ltt_trace *trace; | |
357 | ||
358 | list_for_each_entry(trace, <t_traces.head, list) | |
359 | if (!strncmp(trace->trace_name, trace_name, NAME_MAX)) | |
360 | return trace; | |
361 | ||
362 | return NULL; | |
363 | } | |
364 | ||
365 | /* _ltt_trace_find_setup : | |
366 | * find a trace in setup list by given name. | |
367 | * | |
368 | * Returns a pointer to the trace structure, NULL if not found. | |
369 | */ | |
370 | struct ltt_trace *_ltt_trace_find_setup(const char *trace_name) | |
371 | { | |
372 | struct ltt_trace *trace; | |
373 | ||
374 | list_for_each_entry(trace, <t_traces.setup_head, list) | |
375 | if (!strncmp(trace->trace_name, trace_name, NAME_MAX)) | |
376 | return trace; | |
377 | ||
378 | return NULL; | |
379 | } | |
380 | EXPORT_SYMBOL_GPL(_ltt_trace_find_setup); | |
381 | ||
382 | /** | |
383 | * ltt_release_trace - Release a LTT trace | |
384 | * @kref : reference count on the trace | |
385 | */ | |
386 | void ltt_release_trace(struct kref *kref) | |
387 | { | |
388 | struct ltt_trace *trace = container_of(kref, struct ltt_trace, kref); | |
389 | ||
390 | trace->ops->remove_dirs(trace); | |
391 | module_put(trace->transport->owner); | |
7514523f | 392 | ltt_channels_trace_free(trace); |
1c8284eb MD |
393 | kfree(trace); |
394 | } | |
395 | EXPORT_SYMBOL_GPL(ltt_release_trace); | |
396 | ||
397 | static inline void prepare_chan_size_num(unsigned int *subbuf_size, | |
398 | unsigned int *n_subbufs) | |
399 | { | |
400 | /* Make sure the subbuffer size is larger than a page */ | |
401 | *subbuf_size = max_t(unsigned int, *subbuf_size, PAGE_SIZE); | |
402 | ||
403 | /* round to next power of 2 */ | |
404 | *subbuf_size = 1 << get_count_order(*subbuf_size); | |
405 | *n_subbufs = 1 << get_count_order(*n_subbufs); | |
406 | ||
407 | /* Subbuf size and number must both be power of two */ | |
408 | WARN_ON(hweight32(*subbuf_size) != 1); | |
409 | WARN_ON(hweight32(*n_subbufs) != 1); | |
410 | } | |
411 | ||
412 | int _ltt_trace_setup(const char *trace_name) | |
413 | { | |
414 | int err = 0; | |
415 | struct ltt_trace *new_trace = NULL; | |
416 | int metadata_index; | |
417 | unsigned int chan; | |
418 | enum ltt_channels chantype; | |
419 | ||
420 | if (_ltt_trace_find_setup(trace_name)) { | |
421 | printk(KERN_ERR "LTT : Trace name %s already used.\n", | |
422 | trace_name); | |
423 | err = -EEXIST; | |
424 | goto traces_error; | |
425 | } | |
426 | ||
427 | if (_ltt_trace_find(trace_name)) { | |
428 | printk(KERN_ERR "LTT : Trace name %s already used.\n", | |
429 | trace_name); | |
430 | err = -EEXIST; | |
431 | goto traces_error; | |
432 | } | |
433 | ||
434 | new_trace = kzalloc(sizeof(struct ltt_trace), GFP_KERNEL); | |
435 | if (!new_trace) { | |
436 | printk(KERN_ERR | |
437 | "LTT : Unable to allocate memory for trace %s\n", | |
438 | trace_name); | |
439 | err = -ENOMEM; | |
440 | goto traces_error; | |
441 | } | |
442 | strncpy(new_trace->trace_name, trace_name, NAME_MAX); | |
7514523f | 443 | if (ltt_channels_trace_alloc(&new_trace->nr_channels, 0)) { |
1c8284eb MD |
444 | printk(KERN_ERR |
445 | "LTT : Unable to allocate memory for chaninfo %s\n", | |
446 | trace_name); | |
447 | err = -ENOMEM; | |
448 | goto trace_free; | |
449 | } | |
450 | ||
451 | /* | |
7514523f | 452 | * Force metadata channel to no overwrite. |
1c8284eb MD |
453 | */ |
454 | metadata_index = ltt_channels_get_index_from_name("metadata"); | |
455 | WARN_ON(metadata_index < 0); | |
7514523f | 456 | new_trace->settings[metadata_index].overwrite = 0; |
1c8284eb MD |
457 | |
458 | /* | |
459 | * Set hardcoded tracer defaults for some channels | |
460 | */ | |
461 | for (chan = 0; chan < new_trace->nr_channels; chan++) { | |
1c8284eb MD |
462 | chantype = get_channel_type_from_name( |
463 | ltt_channels_get_name_from_index(chan)); | |
7514523f | 464 | new_trace->settings[chan].sb_size = |
1c8284eb | 465 | chan_infos[chantype].def_sb_size; |
7514523f | 466 | new_trace->settings[chan].n_sb = |
1c8284eb MD |
467 | chan_infos[chantype].def_n_sb; |
468 | } | |
469 | ||
470 | list_add(&new_trace->list, <t_traces.setup_head); | |
471 | return 0; | |
472 | ||
473 | trace_free: | |
474 | kfree(new_trace); | |
475 | traces_error: | |
476 | return err; | |
477 | } | |
478 | EXPORT_SYMBOL_GPL(_ltt_trace_setup); | |
479 | ||
480 | ||
481 | int ltt_trace_setup(const char *trace_name) | |
482 | { | |
483 | int ret; | |
484 | ltt_lock_traces(); | |
485 | ret = _ltt_trace_setup(trace_name); | |
486 | ltt_unlock_traces(); | |
487 | return ret; | |
488 | } | |
489 | EXPORT_SYMBOL_GPL(ltt_trace_setup); | |
490 | ||
491 | /* must be called from within a traces lock. */ | |
492 | static void _ltt_trace_free(struct ltt_trace *trace) | |
493 | { | |
494 | list_del(&trace->list); | |
495 | kfree(trace); | |
496 | } | |
497 | ||
498 | int ltt_trace_set_type(const char *trace_name, const char *trace_type) | |
499 | { | |
500 | int err = 0; | |
501 | struct ltt_trace *trace; | |
502 | struct ltt_transport *tran_iter, *transport = NULL; | |
503 | ||
504 | ltt_lock_traces(); | |
505 | ||
506 | trace = _ltt_trace_find_setup(trace_name); | |
507 | if (!trace) { | |
508 | printk(KERN_ERR "LTT : Trace not found %s\n", trace_name); | |
509 | err = -ENOENT; | |
510 | goto traces_error; | |
511 | } | |
512 | ||
513 | list_for_each_entry(tran_iter, <t_transport_list, node) { | |
514 | if (!strcmp(tran_iter->name, trace_type)) { | |
515 | transport = tran_iter; | |
516 | break; | |
517 | } | |
518 | } | |
519 | if (!transport) { | |
520 | printk(KERN_ERR "LTT : Transport %s is not present.\n", | |
521 | trace_type); | |
522 | err = -EINVAL; | |
523 | goto traces_error; | |
524 | } | |
525 | ||
526 | trace->transport = transport; | |
527 | ||
528 | traces_error: | |
529 | ltt_unlock_traces(); | |
530 | return err; | |
531 | } | |
532 | EXPORT_SYMBOL_GPL(ltt_trace_set_type); | |
533 | ||
534 | int ltt_trace_set_channel_subbufsize(const char *trace_name, | |
535 | const char *channel_name, | |
536 | unsigned int size) | |
537 | { | |
538 | int err = 0; | |
539 | struct ltt_trace *trace; | |
540 | int index; | |
541 | ||
542 | ltt_lock_traces(); | |
543 | ||
544 | trace = _ltt_trace_find_setup(trace_name); | |
545 | if (!trace) { | |
546 | printk(KERN_ERR "LTT : Trace not found %s\n", trace_name); | |
547 | err = -ENOENT; | |
548 | goto traces_error; | |
549 | } | |
550 | ||
551 | index = ltt_channels_get_index_from_name(channel_name); | |
552 | if (index < 0) { | |
553 | printk(KERN_ERR "LTT : Channel %s not found\n", channel_name); | |
554 | err = -ENOENT; | |
555 | goto traces_error; | |
556 | } | |
7514523f | 557 | trace->settings[index].sb_size = size; |
1c8284eb MD |
558 | |
559 | traces_error: | |
560 | ltt_unlock_traces(); | |
561 | return err; | |
562 | } | |
563 | EXPORT_SYMBOL_GPL(ltt_trace_set_channel_subbufsize); | |
564 | ||
565 | int ltt_trace_set_channel_subbufcount(const char *trace_name, | |
566 | const char *channel_name, | |
567 | unsigned int cnt) | |
568 | { | |
569 | int err = 0; | |
570 | struct ltt_trace *trace; | |
571 | int index; | |
572 | ||
573 | ltt_lock_traces(); | |
574 | ||
575 | trace = _ltt_trace_find_setup(trace_name); | |
576 | if (!trace) { | |
577 | printk(KERN_ERR "LTT : Trace not found %s\n", trace_name); | |
578 | err = -ENOENT; | |
579 | goto traces_error; | |
580 | } | |
581 | ||
582 | index = ltt_channels_get_index_from_name(channel_name); | |
583 | if (index < 0) { | |
584 | printk(KERN_ERR "LTT : Channel %s not found\n", channel_name); | |
585 | err = -ENOENT; | |
586 | goto traces_error; | |
587 | } | |
7514523f | 588 | trace->settings[index].n_sb = cnt; |
1c8284eb MD |
589 | |
590 | traces_error: | |
591 | ltt_unlock_traces(); | |
592 | return err; | |
593 | } | |
594 | EXPORT_SYMBOL_GPL(ltt_trace_set_channel_subbufcount); | |
595 | ||
596 | int ltt_trace_set_channel_switch_timer(const char *trace_name, | |
597 | const char *channel_name, | |
598 | unsigned long interval) | |
599 | { | |
600 | int err = 0; | |
601 | struct ltt_trace *trace; | |
602 | int index; | |
603 | ||
604 | ltt_lock_traces(); | |
605 | ||
606 | trace = _ltt_trace_find_setup(trace_name); | |
607 | if (!trace) { | |
608 | printk(KERN_ERR "LTT : Trace not found %s\n", trace_name); | |
609 | err = -ENOENT; | |
610 | goto traces_error; | |
611 | } | |
612 | ||
613 | index = ltt_channels_get_index_from_name(channel_name); | |
614 | if (index < 0) { | |
615 | printk(KERN_ERR "LTT : Channel %s not found\n", channel_name); | |
616 | err = -ENOENT; | |
617 | goto traces_error; | |
618 | } | |
7514523f | 619 | ltt_channels_trace_set_timer(&trace->settings[index], interval); |
1c8284eb MD |
620 | |
621 | traces_error: | |
622 | ltt_unlock_traces(); | |
623 | return err; | |
624 | } | |
625 | EXPORT_SYMBOL_GPL(ltt_trace_set_channel_switch_timer); | |
626 | ||
1c8284eb MD |
627 | int ltt_trace_set_channel_overwrite(const char *trace_name, |
628 | const char *channel_name, | |
629 | unsigned int overwrite) | |
630 | { | |
631 | int err = 0; | |
632 | struct ltt_trace *trace; | |
633 | int index; | |
634 | ||
635 | ltt_lock_traces(); | |
636 | ||
637 | trace = _ltt_trace_find_setup(trace_name); | |
638 | if (!trace) { | |
639 | printk(KERN_ERR "LTT : Trace not found %s\n", trace_name); | |
640 | err = -ENOENT; | |
641 | goto traces_error; | |
642 | } | |
643 | ||
644 | /* | |
645 | * Always put the metadata channel in non-overwrite mode : | |
646 | * This is a very low traffic channel and it can't afford to have its | |
647 | * data overwritten : this data (marker info) is necessary to be | |
648 | * able to read the trace. | |
649 | */ | |
650 | if (overwrite && !strcmp(channel_name, "metadata")) { | |
651 | printk(KERN_ERR "LTT : Trying to set metadata channel to " | |
652 | "overwrite mode\n"); | |
653 | err = -EINVAL; | |
654 | goto traces_error; | |
655 | } | |
656 | ||
657 | index = ltt_channels_get_index_from_name(channel_name); | |
658 | if (index < 0) { | |
659 | printk(KERN_ERR "LTT : Channel %s not found\n", channel_name); | |
660 | err = -ENOENT; | |
661 | goto traces_error; | |
662 | } | |
663 | ||
7514523f | 664 | trace->settings[index].overwrite = overwrite; |
1c8284eb MD |
665 | |
666 | traces_error: | |
667 | ltt_unlock_traces(); | |
668 | return err; | |
669 | } | |
670 | EXPORT_SYMBOL_GPL(ltt_trace_set_channel_overwrite); | |
671 | ||
672 | int ltt_trace_alloc(const char *trace_name) | |
673 | { | |
674 | int err = 0; | |
675 | struct ltt_trace *trace; | |
676 | int sb_size, n_sb; | |
677 | unsigned long flags; | |
678 | int chan; | |
679 | const char *channel_name; | |
680 | ||
681 | ltt_lock_traces(); | |
682 | ||
683 | trace = _ltt_trace_find_setup(trace_name); | |
684 | if (!trace) { | |
685 | printk(KERN_ERR "LTT : Trace not found %s\n", trace_name); | |
686 | err = -ENOENT; | |
687 | goto traces_error; | |
688 | } | |
689 | ||
690 | kref_init(&trace->kref); | |
691 | init_waitqueue_head(&trace->kref_wq); | |
692 | trace->active = 0; | |
693 | get_trace_clock(); | |
694 | trace->freq_scale = trace_clock_freq_scale(); | |
695 | ||
696 | if (!trace->transport) { | |
697 | printk(KERN_ERR "LTT : Transport is not set.\n"); | |
698 | err = -EINVAL; | |
699 | goto transport_error; | |
700 | } | |
701 | if (!try_module_get(trace->transport->owner)) { | |
702 | printk(KERN_ERR "LTT : Can't lock transport module.\n"); | |
703 | err = -ENODEV; | |
704 | goto transport_error; | |
705 | } | |
706 | trace->ops = &trace->transport->ops; | |
707 | ||
708 | err = trace->ops->create_dirs(trace); | |
709 | if (err) { | |
710 | printk(KERN_ERR "LTT : Can't create dir for trace %s.\n", | |
711 | trace_name); | |
712 | goto dirs_error; | |
713 | } | |
714 | ||
715 | local_irq_save(flags); | |
716 | trace->start_freq = trace_clock_frequency(); | |
717 | trace->start_tsc = trace_clock_read64(); | |
718 | do_gettimeofday(&trace->start_time); | |
719 | local_irq_restore(flags); | |
720 | ||
721 | for (chan = 0; chan < trace->nr_channels; chan++) { | |
1c8284eb MD |
722 | channel_name = ltt_channels_get_name_from_index(chan); |
723 | WARN_ON(!channel_name); | |
724 | /* | |
725 | * note: sb_size and n_sb will be overwritten with updated | |
726 | * values by channel creation. | |
727 | */ | |
7514523f MD |
728 | sb_size = trace->settings[chan].sb_size; |
729 | n_sb = trace->settings[chan].n_sb; | |
1c8284eb | 730 | prepare_chan_size_num(&sb_size, &n_sb); |
7514523f MD |
731 | trace->channels[chan] = ltt_create_channel(channel_name, |
732 | trace, NULL, sb_size, n_sb, | |
733 | trace->settings[chan].overwrite, | |
734 | trace->settings[chan].switch_timer_interval, | |
735 | trace->settings[chan].read_timer_interval); | |
1c8284eb MD |
736 | if (err != 0) { |
737 | printk(KERN_ERR "LTT : Can't create channel %s.\n", | |
738 | channel_name); | |
739 | goto create_channel_error; | |
740 | } | |
741 | } | |
742 | ||
743 | list_del(&trace->list); | |
7514523f | 744 | if (list_empty(<t_traces.head)) |
1c8284eb | 745 | set_kernel_trace_flag_all_tasks(); |
1c8284eb MD |
746 | list_add_rcu(&trace->list, <t_traces.head); |
747 | synchronize_trace(); | |
748 | ||
749 | ltt_unlock_traces(); | |
750 | ||
751 | return 0; | |
752 | ||
753 | create_channel_error: | |
7514523f MD |
754 | for (chan--; chan >= 0; chan--) |
755 | ltt_channel_destroy(trace->channels[chan]); | |
1c8284eb MD |
756 | trace->ops->remove_dirs(trace); |
757 | ||
758 | dirs_error: | |
759 | module_put(trace->transport->owner); | |
760 | transport_error: | |
761 | put_trace_clock(); | |
762 | traces_error: | |
763 | ltt_unlock_traces(); | |
764 | return err; | |
765 | } | |
766 | EXPORT_SYMBOL_GPL(ltt_trace_alloc); | |
767 | ||
768 | /* | |
769 | * It is worked as a wrapper for current version of ltt_control.ko. | |
770 | * We will make a new ltt_control based on debugfs, and control each channel's | |
771 | * buffer. | |
772 | */ | |
773 | static | |
774 | int ltt_trace_create(const char *trace_name, const char *trace_type, | |
775 | enum trace_mode mode, | |
776 | unsigned int subbuf_size_low, unsigned int n_subbufs_low, | |
777 | unsigned int subbuf_size_med, unsigned int n_subbufs_med, | |
778 | unsigned int subbuf_size_high, unsigned int n_subbufs_high) | |
779 | { | |
780 | int err = 0; | |
781 | ||
782 | err = ltt_trace_setup(trace_name); | |
783 | if (IS_ERR_VALUE(err)) | |
784 | return err; | |
785 | ||
786 | err = ltt_trace_set_type(trace_name, trace_type); | |
787 | if (IS_ERR_VALUE(err)) | |
788 | return err; | |
789 | ||
790 | err = ltt_trace_alloc(trace_name); | |
791 | if (IS_ERR_VALUE(err)) | |
792 | return err; | |
793 | ||
794 | return err; | |
795 | } | |
796 | ||
797 | /* Must be called while sure that trace is in the list. */ | |
798 | static int _ltt_trace_destroy(struct ltt_trace *trace) | |
799 | { | |
800 | int err = -EPERM; | |
801 | ||
802 | if (trace == NULL) { | |
803 | err = -ENOENT; | |
804 | goto traces_error; | |
805 | } | |
806 | if (trace->active) { | |
807 | printk(KERN_ERR | |
808 | "LTT : Can't destroy trace %s : tracer is active\n", | |
809 | trace->trace_name); | |
810 | err = -EBUSY; | |
811 | goto active_error; | |
812 | } | |
813 | /* Everything went fine */ | |
814 | list_del_rcu(&trace->list); | |
815 | synchronize_trace(); | |
816 | if (list_empty(<t_traces.head)) { | |
817 | clear_kernel_trace_flag_all_tasks(); | |
1c8284eb MD |
818 | } |
819 | return 0; | |
820 | ||
821 | /* error handling */ | |
822 | active_error: | |
823 | traces_error: | |
824 | return err; | |
825 | } | |
826 | ||
827 | /* Sleepable part of the destroy */ | |
828 | static void __ltt_trace_destroy(struct ltt_trace *trace) | |
829 | { | |
830 | int i; | |
1c8284eb | 831 | |
7514523f MD |
832 | for (i = 0; i < trace->nr_channels; i++) |
833 | ltt_channel_destroy(trace->channels[i]); | |
1c8284eb MD |
834 | kref_put(&trace->kref, ltt_release_trace); |
835 | } | |
836 | ||
837 | int ltt_trace_destroy(const char *trace_name) | |
838 | { | |
839 | int err = 0; | |
840 | struct ltt_trace *trace; | |
841 | ||
842 | ltt_lock_traces(); | |
843 | ||
844 | trace = _ltt_trace_find(trace_name); | |
845 | if (trace) { | |
846 | err = _ltt_trace_destroy(trace); | |
847 | if (err) | |
848 | goto error; | |
849 | ||
850 | __ltt_trace_destroy(trace); | |
851 | ltt_unlock_traces(); | |
852 | put_trace_clock(); | |
853 | ||
854 | return 0; | |
855 | } | |
856 | ||
857 | trace = _ltt_trace_find_setup(trace_name); | |
858 | if (trace) { | |
859 | _ltt_trace_free(trace); | |
860 | ltt_unlock_traces(); | |
861 | return 0; | |
862 | } | |
863 | ||
864 | err = -ENOENT; | |
865 | ||
866 | /* Error handling */ | |
867 | error: | |
868 | ltt_unlock_traces(); | |
869 | return err; | |
870 | } | |
871 | EXPORT_SYMBOL_GPL(ltt_trace_destroy); | |
872 | ||
1c8284eb MD |
873 | /* must be called from within a traces lock. */ |
874 | static int _ltt_trace_start(struct ltt_trace *trace) | |
875 | { | |
876 | int err = 0; | |
877 | ||
878 | if (trace == NULL) { | |
879 | err = -ENOENT; | |
880 | goto traces_error; | |
881 | } | |
882 | if (trace->active) | |
883 | printk(KERN_INFO "LTT : Tracing already active for trace %s\n", | |
884 | trace->trace_name); | |
885 | if (!try_module_get(ltt_run_filter_owner)) { | |
886 | err = -ENODEV; | |
887 | printk(KERN_ERR "LTT : Can't lock filter module.\n"); | |
888 | goto get_ltt_run_filter_error; | |
889 | } | |
1c8284eb MD |
890 | trace->active = 1; |
891 | /* Read by trace points without protection : be careful */ | |
892 | ltt_traces.num_active_traces++; | |
893 | return err; | |
894 | ||
895 | /* error handling */ | |
896 | get_ltt_run_filter_error: | |
897 | traces_error: | |
898 | return err; | |
899 | } | |
900 | ||
901 | int ltt_trace_start(const char *trace_name) | |
902 | { | |
903 | int err = 0; | |
904 | struct ltt_trace *trace; | |
905 | ||
906 | ltt_lock_traces(); | |
907 | ||
908 | trace = _ltt_trace_find(trace_name); | |
909 | err = _ltt_trace_start(trace); | |
910 | if (err) | |
911 | goto no_trace; | |
912 | ||
913 | ltt_unlock_traces(); | |
914 | ||
915 | /* | |
916 | * Call the kernel state dump. | |
917 | * Events will be mixed with real kernel events, it's ok. | |
918 | * Notice that there is no protection on the trace : that's exactly | |
919 | * why we iterate on the list and check for trace equality instead of | |
920 | * directly using this trace handle inside the logging function. | |
921 | */ | |
922 | ||
923 | ltt_dump_marker_state(trace); | |
924 | ||
925 | if (!try_module_get(ltt_statedump_owner)) { | |
926 | err = -ENODEV; | |
927 | printk(KERN_ERR | |
928 | "LTT : Can't lock state dump module.\n"); | |
929 | } else { | |
930 | ltt_statedump_functor(trace); | |
931 | module_put(ltt_statedump_owner); | |
932 | } | |
933 | ||
934 | return err; | |
935 | ||
936 | /* Error handling */ | |
937 | no_trace: | |
938 | ltt_unlock_traces(); | |
939 | return err; | |
940 | } | |
941 | EXPORT_SYMBOL_GPL(ltt_trace_start); | |
942 | ||
943 | /* must be called from within traces lock */ | |
944 | static int _ltt_trace_stop(struct ltt_trace *trace) | |
945 | { | |
946 | int err = -EPERM; | |
947 | ||
948 | if (trace == NULL) { | |
949 | err = -ENOENT; | |
950 | goto traces_error; | |
951 | } | |
952 | if (!trace->active) | |
953 | printk(KERN_INFO "LTT : Tracing not active for trace %s\n", | |
954 | trace->trace_name); | |
955 | if (trace->active) { | |
1c8284eb MD |
956 | trace->active = 0; |
957 | ltt_traces.num_active_traces--; | |
958 | synchronize_trace(); /* Wait for each tracing to be finished */ | |
959 | } | |
960 | module_put(ltt_run_filter_owner); | |
961 | /* Everything went fine */ | |
962 | return 0; | |
963 | ||
964 | /* Error handling */ | |
965 | traces_error: | |
966 | return err; | |
967 | } | |
968 | ||
969 | int ltt_trace_stop(const char *trace_name) | |
970 | { | |
971 | int err = 0; | |
972 | struct ltt_trace *trace; | |
973 | ||
974 | ltt_lock_traces(); | |
975 | trace = _ltt_trace_find(trace_name); | |
976 | err = _ltt_trace_stop(trace); | |
977 | ltt_unlock_traces(); | |
978 | return err; | |
979 | } | |
980 | EXPORT_SYMBOL_GPL(ltt_trace_stop); | |
981 | ||
982 | /** | |
983 | * ltt_control - Trace control in-kernel API | |
984 | * @msg: Action to perform | |
985 | * @trace_name: Trace on which the action must be done | |
986 | * @trace_type: Type of trace (normal, flight, hybrid) | |
987 | * @args: Arguments specific to the action | |
988 | */ | |
989 | int ltt_control(enum ltt_control_msg msg, const char *trace_name, | |
990 | const char *trace_type, union ltt_control_args args) | |
991 | { | |
992 | int err = -EPERM; | |
993 | ||
994 | printk(KERN_ALERT "ltt_control : trace %s\n", trace_name); | |
995 | switch (msg) { | |
996 | case LTT_CONTROL_START: | |
997 | printk(KERN_DEBUG "Start tracing %s\n", trace_name); | |
998 | err = ltt_trace_start(trace_name); | |
999 | break; | |
1000 | case LTT_CONTROL_STOP: | |
1001 | printk(KERN_DEBUG "Stop tracing %s\n", trace_name); | |
1002 | err = ltt_trace_stop(trace_name); | |
1003 | break; | |
1004 | case LTT_CONTROL_CREATE_TRACE: | |
1005 | printk(KERN_DEBUG "Creating trace %s\n", trace_name); | |
1006 | err = ltt_trace_create(trace_name, trace_type, | |
1007 | args.new_trace.mode, | |
1008 | args.new_trace.subbuf_size_low, | |
1009 | args.new_trace.n_subbufs_low, | |
1010 | args.new_trace.subbuf_size_med, | |
1011 | args.new_trace.n_subbufs_med, | |
1012 | args.new_trace.subbuf_size_high, | |
1013 | args.new_trace.n_subbufs_high); | |
1014 | break; | |
1015 | case LTT_CONTROL_DESTROY_TRACE: | |
1016 | printk(KERN_DEBUG "Destroying trace %s\n", trace_name); | |
1017 | err = ltt_trace_destroy(trace_name); | |
1018 | break; | |
1019 | } | |
1020 | return err; | |
1021 | } | |
1022 | EXPORT_SYMBOL_GPL(ltt_control); | |
1023 | ||
1024 | /** | |
1025 | * ltt_filter_control - Trace filter control in-kernel API | |
1026 | * @msg: Action to perform on the filter | |
1027 | * @trace_name: Trace on which the action must be done | |
1028 | */ | |
1029 | int ltt_filter_control(enum ltt_filter_control_msg msg, const char *trace_name) | |
1030 | { | |
1031 | int err; | |
1032 | struct ltt_trace *trace; | |
1033 | ||
1034 | printk(KERN_DEBUG "ltt_filter_control : trace %s\n", trace_name); | |
1035 | ltt_lock_traces(); | |
1036 | trace = _ltt_trace_find(trace_name); | |
1037 | if (trace == NULL) { | |
1038 | printk(KERN_ALERT | |
1039 | "Trace does not exist. Cannot proxy control request\n"); | |
1040 | err = -ENOENT; | |
1041 | goto trace_error; | |
1042 | } | |
1043 | if (!try_module_get(ltt_filter_control_owner)) { | |
1044 | err = -ENODEV; | |
1045 | goto get_module_error; | |
1046 | } | |
1047 | switch (msg) { | |
1048 | case LTT_FILTER_DEFAULT_ACCEPT: | |
1049 | printk(KERN_DEBUG | |
1050 | "Proxy filter default accept %s\n", trace_name); | |
1051 | err = (*ltt_filter_control_functor)(msg, trace); | |
1052 | break; | |
1053 | case LTT_FILTER_DEFAULT_REJECT: | |
1054 | printk(KERN_DEBUG | |
1055 | "Proxy filter default reject %s\n", trace_name); | |
1056 | err = (*ltt_filter_control_functor)(msg, trace); | |
1057 | break; | |
1058 | default: | |
1059 | err = -EPERM; | |
1060 | } | |
1061 | module_put(ltt_filter_control_owner); | |
1062 | ||
1063 | get_module_error: | |
1064 | trace_error: | |
1065 | ltt_unlock_traces(); | |
1066 | return err; | |
1067 | } | |
1068 | EXPORT_SYMBOL_GPL(ltt_filter_control); | |
1069 | ||
1070 | int __init ltt_init(void) | |
1071 | { | |
1072 | /* Make sure no page fault can be triggered by this module */ | |
1073 | vmalloc_sync_all(); | |
1074 | init_timer_deferrable(<t_async_wakeup_timer); | |
1075 | return 0; | |
1076 | } | |
1077 | ||
1078 | module_init(ltt_init) | |
1079 | ||
1080 | static void __exit ltt_exit(void) | |
1081 | { | |
1082 | struct ltt_trace *trace; | |
1083 | struct list_head *pos, *n; | |
1084 | ||
1085 | ltt_lock_traces(); | |
1086 | /* Stop each trace, currently being read by RCU read-side */ | |
1087 | list_for_each_entry_rcu(trace, <t_traces.head, list) | |
1088 | _ltt_trace_stop(trace); | |
1089 | /* Wait for quiescent state. Readers have preemption disabled. */ | |
1090 | synchronize_trace(); | |
1091 | /* Safe iteration is now permitted. It does not have to be RCU-safe | |
1092 | * because no readers are left. */ | |
1093 | list_for_each_safe(pos, n, <t_traces.head) { | |
1094 | trace = container_of(pos, struct ltt_trace, list); | |
1095 | /* _ltt_trace_destroy does a synchronize_trace() */ | |
1096 | _ltt_trace_destroy(trace); | |
1097 | __ltt_trace_destroy(trace); | |
1098 | } | |
1099 | /* free traces in pre-alloc status */ | |
1100 | list_for_each_safe(pos, n, <t_traces.setup_head) { | |
1101 | trace = container_of(pos, struct ltt_trace, list); | |
1102 | _ltt_trace_free(trace); | |
1103 | } | |
1104 | ||
1105 | ltt_unlock_traces(); | |
1106 | } | |
1107 | ||
1108 | module_exit(ltt_exit) | |
1109 | ||
1110 | MODULE_LICENSE("GPL and additional rights"); | |
1111 | MODULE_AUTHOR("Mathieu Desnoyers"); | |
1112 | MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Tracer Kernel API"); |