4 * (C) Copyright 2008 - Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
6 * LTTng channel management.
9 * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 //ust// #include <linux/module.h>
27 //ust// #include <linux/ltt-channels.h>
28 //ust// #include <linux/mutex.h>
29 //ust// #include <linux/vmalloc.h>
31 #include "kernelcompat.h"
36 * ltt_channel_mutex may be nested inside the LTT trace mutex.
37 * ltt_channel_mutex mutex may be nested inside markers mutex.
39 static DEFINE_MUTEX(ltt_channel_mutex
);
40 static LIST_HEAD(ltt_channels
);
42 * Index of next channel in array. Makes sure that as long as a trace channel is
43 * allocated, no array index will be re-used when a channel is freed and then
44 * another channel is allocated. This index is cleared and the array indexeds
45 * get reassigned when the index_kref goes back to 0, which indicates that no
46 * more trace channels are allocated.
48 static unsigned int free_index
;
49 static struct kref index_kref
; /* Keeps track of allocated trace channels */
51 static struct ltt_channel_setting
*lookup_channel(const char *name
)
53 struct ltt_channel_setting
*iter
;
55 list_for_each_entry(iter
, <t_channels
, list
)
56 if (strcmp(name
, iter
->name
) == 0)
62 * Must be called when channel refcount falls to 0 _and_ also when the last
63 * trace is freed. This function is responsible for compacting the channel and
64 * event IDs when no users are active.
66 * Called with lock_markers() and channels mutex held.
68 static void release_channel_setting(struct kref
*kref
)
70 struct ltt_channel_setting
*setting
= container_of(kref
,
71 struct ltt_channel_setting
, kref
);
72 struct ltt_channel_setting
*iter
;
74 if (atomic_read(&index_kref
.refcount
) == 0
75 && atomic_read(&setting
->kref
.refcount
) == 0) {
76 list_del(&setting
->list
);
80 list_for_each_entry(iter
, <t_channels
, list
) {
81 iter
->index
= free_index
++;
82 iter
->free_event_id
= 0;
84 //ust// markers_compact_event_ids();
89 * Perform channel index compaction when the last trace channel is freed.
91 * Called with lock_markers() and channels mutex held.
93 static void release_trace_channel(struct kref
*kref
)
95 struct ltt_channel_setting
*iter
, *n
;
97 list_for_each_entry_safe(iter
, n
, <t_channels
, list
)
98 release_channel_setting(&iter
->kref
);
102 * ltt_channels_register - Register a trace channel.
103 * @name: channel name
107 int ltt_channels_register(const char *name
)
109 struct ltt_channel_setting
*setting
;
112 mutex_lock(<t_channel_mutex
);
113 setting
= lookup_channel(name
);
115 if (atomic_read(&setting
->kref
.refcount
) == 0)
118 kref_get(&setting
->kref
);
122 setting
= kzalloc(sizeof(*setting
), GFP_KERNEL
);
127 list_add(&setting
->list
, <t_channels
);
128 strncpy(setting
->name
, name
, PATH_MAX
-1);
129 setting
->index
= free_index
++;
131 kref_init(&setting
->kref
);
133 mutex_unlock(<t_channel_mutex
);
136 //ust// EXPORT_SYMBOL_GPL(ltt_channels_register);
139 * ltt_channels_unregister - Unregister a trace channel.
140 * @name: channel name
142 * Must be called with markers mutex held.
144 int ltt_channels_unregister(const char *name
)
146 struct ltt_channel_setting
*setting
;
149 mutex_lock(<t_channel_mutex
);
150 setting
= lookup_channel(name
);
151 if (!setting
|| atomic_read(&setting
->kref
.refcount
) == 0) {
155 kref_put(&setting
->kref
, release_channel_setting
);
157 mutex_unlock(<t_channel_mutex
);
160 //ust// EXPORT_SYMBOL_GPL(ltt_channels_unregister);
163 * ltt_channels_set_default - Set channel default behavior.
164 * @name: default channel name
165 * @subbuf_size: size of the subbuffers
166 * @subbuf_cnt: number of subbuffers
168 int ltt_channels_set_default(const char *name
,
169 unsigned int subbuf_size
,
170 unsigned int subbuf_cnt
)
172 struct ltt_channel_setting
*setting
;
175 mutex_lock(<t_channel_mutex
);
176 setting
= lookup_channel(name
);
177 if (!setting
|| atomic_read(&setting
->kref
.refcount
) == 0) {
181 setting
->subbuf_size
= subbuf_size
;
182 setting
->subbuf_cnt
= subbuf_cnt
;
184 mutex_unlock(<t_channel_mutex
);
187 //ust// EXPORT_SYMBOL_GPL(ltt_channels_set_default);
190 * ltt_channels_get_name_from_index - get channel name from channel index
191 * @index: channel index
193 * Allows to lookup the channel name given its index. Done to keep the name
194 * information outside of each trace channel instance.
196 const char *ltt_channels_get_name_from_index(unsigned int index
)
198 struct ltt_channel_setting
*iter
;
200 list_for_each_entry(iter
, <t_channels
, list
)
201 if (iter
->index
== index
&& atomic_read(&iter
->kref
.refcount
))
205 //ust// EXPORT_SYMBOL_GPL(ltt_channels_get_name_from_index);
207 static struct ltt_channel_setting
*
208 ltt_channels_get_setting_from_name(const char *name
)
210 struct ltt_channel_setting
*iter
;
212 list_for_each_entry(iter
, <t_channels
, list
)
213 if (!strcmp(iter
->name
, name
)
214 && atomic_read(&iter
->kref
.refcount
))
220 * ltt_channels_get_index_from_name - get channel index from channel name
221 * @name: channel name
223 * Allows to lookup the channel index given its name. Done to keep the name
224 * information outside of each trace channel instance.
225 * Returns -1 if not found.
227 int ltt_channels_get_index_from_name(const char *name
)
229 struct ltt_channel_setting
*setting
;
231 setting
= ltt_channels_get_setting_from_name(name
);
233 return setting
->index
;
237 //ust// EXPORT_SYMBOL_GPL(ltt_channels_get_index_from_name);
240 * ltt_channels_trace_alloc - Allocate channel structures for a trace
241 * @subbuf_size: subbuffer size. 0 uses default.
242 * @subbuf_cnt: number of subbuffers per per-cpu buffers. 0 uses default.
243 * @flags: Default channel flags
245 * Use the current channel list to allocate the channels for a trace.
246 * Called with trace lock held. Does not perform the trace buffer allocation,
247 * because we must let the user overwrite specific channel sizes.
249 struct ltt_channel_struct
*ltt_channels_trace_alloc(unsigned int *nr_channels
,
253 struct ltt_channel_struct
*channel
= NULL
;
254 struct ltt_channel_setting
*iter
;
256 mutex_lock(<t_channel_mutex
);
258 WARN("ltt_channels_trace_alloc: no free_index; are there any probes connected?");
261 if (!atomic_read(&index_kref
.refcount
))
262 kref_init(&index_kref
);
264 kref_get(&index_kref
);
265 *nr_channels
= free_index
;
266 channel
= kzalloc(sizeof(struct ltt_channel_struct
) * free_index
,
269 WARN("ltt_channel_struct: channel null after alloc");
272 list_for_each_entry(iter
, <t_channels
, list
) {
273 if (!atomic_read(&iter
->kref
.refcount
))
275 channel
[iter
->index
].subbuf_size
= iter
->subbuf_size
;
276 channel
[iter
->index
].subbuf_cnt
= iter
->subbuf_cnt
;
277 channel
[iter
->index
].overwrite
= overwrite
;
278 channel
[iter
->index
].active
= active
;
279 channel
[iter
->index
].channel_name
= iter
->name
;
282 mutex_unlock(<t_channel_mutex
);
285 //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc);
288 * ltt_channels_trace_free - Free one trace's channels
289 * @channels: channels to free
291 * Called with trace lock held. The actual channel buffers must be freed before
292 * this function is called.
294 void ltt_channels_trace_free(struct ltt_channel_struct
*channels
)
297 mutex_lock(<t_channel_mutex
);
299 kref_put(&index_kref
, release_trace_channel
);
300 mutex_unlock(<t_channel_mutex
);
303 //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_free);
306 * _ltt_channels_get_event_id - get next event ID for a marker
307 * @channel: channel name
310 * Returns a unique event ID (for this channel) or < 0 on error.
311 * Must be called with channels mutex held.
313 int _ltt_channels_get_event_id(const char *channel
, const char *name
)
315 struct ltt_channel_setting
*setting
;
318 setting
= ltt_channels_get_setting_from_name(channel
);
323 if (strcmp(channel
, "metadata") == 0) {
324 if (strcmp(name
, "core_marker_id") == 0)
326 else if (strcmp(name
, "core_marker_format") == 0)
328 else if (strcmp(name
, "testev") == 0)
334 if (setting
->free_event_id
== EVENTS_PER_CHANNEL
- 1) {
338 ret
= setting
->free_event_id
++;
344 * ltt_channels_get_event_id - get next event ID for a marker
345 * @channel: channel name
348 * Returns a unique event ID (for this channel) or < 0 on error.
350 int ltt_channels_get_event_id(const char *channel
, const char *name
)
354 mutex_lock(<t_channel_mutex
);
355 ret
= _ltt_channels_get_event_id(channel
, name
);
356 mutex_unlock(<t_channel_mutex
);
360 //ust// MODULE_LICENSE("GPL");
361 //ust// MODULE_AUTHOR("Mathieu Desnoyers");
362 //ust// MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Channel Management");
This page took 0.038457 seconds and 6 git commands to generate.