Commit | Line | Data |
---|---|---|
99054cee PMF |
1 | /* |
2 | * ltt/ltt-channels.c | |
3 | * | |
4 | * (C) Copyright 2008 - Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca) | |
5 | * | |
6 | * LTTng channel management. | |
7 | * | |
8 | * Author: | |
9 | * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca) | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/ltt-channels.h> | |
14 | #include <linux/mutex.h> | |
15 | #include <linux/vmalloc.h> | |
16 | ||
17 | /* | |
18 | * ltt_channel_mutex may be nested inside the LTT trace mutex. | |
19 | * ltt_channel_mutex mutex may be nested inside markers mutex. | |
20 | */ | |
21 | static DEFINE_MUTEX(ltt_channel_mutex); | |
22 | static LIST_HEAD(ltt_channels); | |
23 | /* | |
24 | * Index of next channel in array. Makes sure that as long as a trace channel is | |
25 | * allocated, no array index will be re-used when a channel is freed and then | |
26 | * another channel is allocated. This index is cleared and the array indexeds | |
27 | * get reassigned when the index_kref goes back to 0, which indicates that no | |
28 | * more trace channels are allocated. | |
29 | */ | |
30 | static unsigned int free_index; | |
31 | static struct kref index_kref; /* Keeps track of allocated trace channels */ | |
32 | ||
33 | static struct ltt_channel_setting *lookup_channel(const char *name) | |
34 | { | |
35 | struct ltt_channel_setting *iter; | |
36 | ||
37 | list_for_each_entry(iter, <t_channels, list) | |
38 | if (strcmp(name, iter->name) == 0) | |
39 | return iter; | |
40 | return NULL; | |
41 | } | |
42 | ||
43 | /* | |
44 | * Must be called when channel refcount falls to 0 _and_ also when the last | |
45 | * trace is freed. This function is responsible for compacting the channel and | |
46 | * event IDs when no users are active. | |
47 | * | |
48 | * Called with lock_markers() and channels mutex held. | |
49 | */ | |
50 | static void release_channel_setting(struct kref *kref) | |
51 | { | |
52 | struct ltt_channel_setting *setting = container_of(kref, | |
53 | struct ltt_channel_setting, kref); | |
54 | struct ltt_channel_setting *iter; | |
55 | ||
56 | if (atomic_read(&index_kref.refcount) == 0 | |
57 | && atomic_read(&setting->kref.refcount) == 0) { | |
58 | list_del(&setting->list); | |
59 | kfree(setting); | |
60 | ||
61 | free_index = 0; | |
62 | list_for_each_entry(iter, <t_channels, list) { | |
63 | iter->index = free_index++; | |
64 | iter->free_event_id = 0; | |
65 | } | |
66 | markers_compact_event_ids(); | |
67 | } | |
68 | } | |
69 | ||
70 | /* | |
71 | * Perform channel index compaction when the last trace channel is freed. | |
72 | * | |
73 | * Called with lock_markers() and channels mutex held. | |
74 | */ | |
75 | static void release_trace_channel(struct kref *kref) | |
76 | { | |
77 | struct ltt_channel_setting *iter, *n; | |
78 | ||
79 | list_for_each_entry_safe(iter, n, <t_channels, list) | |
80 | release_channel_setting(&iter->kref); | |
81 | } | |
82 | ||
83 | /** | |
84 | * ltt_channels_register - Register a trace channel. | |
85 | * @name: channel name | |
86 | * | |
87 | * Uses refcounting. | |
88 | */ | |
89 | int ltt_channels_register(const char *name) | |
90 | { | |
91 | struct ltt_channel_setting *setting; | |
92 | int ret = 0; | |
93 | ||
94 | mutex_lock(<t_channel_mutex); | |
95 | setting = lookup_channel(name); | |
96 | if (setting) { | |
97 | if (atomic_read(&setting->kref.refcount) == 0) | |
98 | goto init_kref; | |
99 | else { | |
100 | kref_get(&setting->kref); | |
101 | goto end; | |
102 | } | |
103 | } | |
104 | setting = kzalloc(sizeof(*setting), GFP_KERNEL); | |
105 | if (!setting) { | |
106 | ret = -ENOMEM; | |
107 | goto end; | |
108 | } | |
109 | list_add(&setting->list, <t_channels); | |
110 | strncpy(setting->name, name, PATH_MAX-1); | |
111 | setting->index = free_index++; | |
112 | init_kref: | |
113 | kref_init(&setting->kref); | |
114 | end: | |
115 | mutex_unlock(<t_channel_mutex); | |
116 | return ret; | |
117 | } | |
118 | EXPORT_SYMBOL_GPL(ltt_channels_register); | |
119 | ||
120 | /** | |
121 | * ltt_channels_unregister - Unregister a trace channel. | |
122 | * @name: channel name | |
123 | * | |
124 | * Must be called with markers mutex held. | |
125 | */ | |
126 | int ltt_channels_unregister(const char *name) | |
127 | { | |
128 | struct ltt_channel_setting *setting; | |
129 | int ret = 0; | |
130 | ||
131 | mutex_lock(<t_channel_mutex); | |
132 | setting = lookup_channel(name); | |
133 | if (!setting || atomic_read(&setting->kref.refcount) == 0) { | |
134 | ret = -ENOENT; | |
135 | goto end; | |
136 | } | |
137 | kref_put(&setting->kref, release_channel_setting); | |
138 | end: | |
139 | mutex_unlock(<t_channel_mutex); | |
140 | return ret; | |
141 | } | |
142 | EXPORT_SYMBOL_GPL(ltt_channels_unregister); | |
143 | ||
144 | /** | |
145 | * ltt_channels_set_default - Set channel default behavior. | |
146 | * @name: default channel name | |
147 | * @subbuf_size: size of the subbuffers | |
148 | * @subbuf_cnt: number of subbuffers | |
149 | */ | |
150 | int ltt_channels_set_default(const char *name, | |
151 | unsigned int subbuf_size, | |
152 | unsigned int subbuf_cnt) | |
153 | { | |
154 | struct ltt_channel_setting *setting; | |
155 | int ret = 0; | |
156 | ||
157 | mutex_lock(<t_channel_mutex); | |
158 | setting = lookup_channel(name); | |
159 | if (!setting || atomic_read(&setting->kref.refcount) == 0) { | |
160 | ret = -ENOENT; | |
161 | goto end; | |
162 | } | |
163 | setting->subbuf_size = subbuf_size; | |
164 | setting->subbuf_cnt = subbuf_cnt; | |
165 | end: | |
166 | mutex_unlock(<t_channel_mutex); | |
167 | return ret; | |
168 | } | |
169 | EXPORT_SYMBOL_GPL(ltt_channels_set_default); | |
170 | ||
171 | /** | |
172 | * ltt_channels_get_name_from_index - get channel name from channel index | |
173 | * @index: channel index | |
174 | * | |
175 | * Allows to lookup the channel name given its index. Done to keep the name | |
176 | * information outside of each trace channel instance. | |
177 | */ | |
178 | const char *ltt_channels_get_name_from_index(unsigned int index) | |
179 | { | |
180 | struct ltt_channel_setting *iter; | |
181 | ||
182 | list_for_each_entry(iter, <t_channels, list) | |
183 | if (iter->index == index && atomic_read(&iter->kref.refcount)) | |
184 | return iter->name; | |
185 | return NULL; | |
186 | } | |
187 | EXPORT_SYMBOL_GPL(ltt_channels_get_name_from_index); | |
188 | ||
189 | static struct ltt_channel_setting * | |
190 | ltt_channels_get_setting_from_name(const char *name) | |
191 | { | |
192 | struct ltt_channel_setting *iter; | |
193 | ||
194 | list_for_each_entry(iter, <t_channels, list) | |
195 | if (!strcmp(iter->name, name) | |
196 | && atomic_read(&iter->kref.refcount)) | |
197 | return iter; | |
198 | return NULL; | |
199 | } | |
200 | ||
201 | /** | |
202 | * ltt_channels_get_index_from_name - get channel index from channel name | |
203 | * @name: channel name | |
204 | * | |
205 | * Allows to lookup the channel index given its name. Done to keep the name | |
206 | * information outside of each trace channel instance. | |
207 | * Returns -1 if not found. | |
208 | */ | |
209 | int ltt_channels_get_index_from_name(const char *name) | |
210 | { | |
211 | struct ltt_channel_setting *setting; | |
212 | ||
213 | setting = ltt_channels_get_setting_from_name(name); | |
214 | if (setting) | |
215 | return setting->index; | |
216 | else | |
217 | return -1; | |
218 | } | |
219 | EXPORT_SYMBOL_GPL(ltt_channels_get_index_from_name); | |
220 | ||
221 | /** | |
222 | * ltt_channels_trace_alloc - Allocate channel structures for a trace | |
223 | * @subbuf_size: subbuffer size. 0 uses default. | |
224 | * @subbuf_cnt: number of subbuffers per per-cpu buffers. 0 uses default. | |
225 | * @flags: Default channel flags | |
226 | * | |
227 | * Use the current channel list to allocate the channels for a trace. | |
228 | * Called with trace lock held. Does not perform the trace buffer allocation, | |
229 | * because we must let the user overwrite specific channel sizes. | |
230 | */ | |
231 | struct ltt_channel_struct *ltt_channels_trace_alloc(unsigned int *nr_channels, | |
232 | int overwrite, | |
233 | int active) | |
234 | { | |
235 | struct ltt_channel_struct *channel = NULL; | |
236 | struct ltt_channel_setting *iter; | |
237 | ||
238 | mutex_lock(<t_channel_mutex); | |
239 | if (!free_index) | |
240 | goto end; | |
241 | if (!atomic_read(&index_kref.refcount)) | |
242 | kref_init(&index_kref); | |
243 | else | |
244 | kref_get(&index_kref); | |
245 | *nr_channels = free_index; | |
246 | channel = kzalloc(sizeof(struct ltt_channel_struct) * free_index, | |
247 | GFP_KERNEL); | |
248 | if (!channel) | |
249 | goto end; | |
250 | list_for_each_entry(iter, <t_channels, list) { | |
251 | if (!atomic_read(&iter->kref.refcount)) | |
252 | continue; | |
253 | channel[iter->index].subbuf_size = iter->subbuf_size; | |
254 | channel[iter->index].subbuf_cnt = iter->subbuf_cnt; | |
255 | channel[iter->index].overwrite = overwrite; | |
256 | channel[iter->index].active = active; | |
257 | channel[iter->index].channel_name = iter->name; | |
258 | } | |
259 | end: | |
260 | mutex_unlock(<t_channel_mutex); | |
261 | return channel; | |
262 | } | |
263 | EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc); | |
264 | ||
265 | /** | |
266 | * ltt_channels_trace_free - Free one trace's channels | |
267 | * @channels: channels to free | |
268 | * | |
269 | * Called with trace lock held. The actual channel buffers must be freed before | |
270 | * this function is called. | |
271 | */ | |
272 | void ltt_channels_trace_free(struct ltt_channel_struct *channels) | |
273 | { | |
274 | lock_markers(); | |
275 | mutex_lock(<t_channel_mutex); | |
276 | kfree(channels); | |
277 | kref_put(&index_kref, release_trace_channel); | |
278 | mutex_unlock(<t_channel_mutex); | |
279 | unlock_markers(); | |
280 | } | |
281 | EXPORT_SYMBOL_GPL(ltt_channels_trace_free); | |
282 | ||
283 | /** | |
284 | * _ltt_channels_get_event_id - get next event ID for a marker | |
285 | * @channel: channel name | |
286 | * @name: event name | |
287 | * | |
288 | * Returns a unique event ID (for this channel) or < 0 on error. | |
289 | * Must be called with channels mutex held. | |
290 | */ | |
291 | int _ltt_channels_get_event_id(const char *channel, const char *name) | |
292 | { | |
293 | struct ltt_channel_setting *setting; | |
294 | int ret; | |
295 | ||
296 | setting = ltt_channels_get_setting_from_name(channel); | |
297 | if (!setting) { | |
298 | ret = -ENOENT; | |
299 | goto end; | |
300 | } | |
301 | if (strcmp(channel, "metadata") == 0) { | |
302 | if (strcmp(name, "core_marker_id") == 0) | |
303 | ret = 0; | |
304 | else if (strcmp(name, "core_marker_format") == 0) | |
305 | ret = 1; | |
306 | else | |
307 | ret = -ENOENT; | |
308 | goto end; | |
309 | } | |
310 | if (setting->free_event_id == EVENTS_PER_CHANNEL - 1) { | |
311 | ret = -ENOSPC; | |
312 | goto end; | |
313 | } | |
314 | ret = setting->free_event_id++; | |
315 | end: | |
316 | return ret; | |
317 | } | |
318 | ||
319 | /** | |
320 | * ltt_channels_get_event_id - get next event ID for a marker | |
321 | * @channel: channel name | |
322 | * @name: event name | |
323 | * | |
324 | * Returns a unique event ID (for this channel) or < 0 on error. | |
325 | */ | |
326 | int ltt_channels_get_event_id(const char *channel, const char *name) | |
327 | { | |
328 | int ret; | |
329 | ||
330 | mutex_lock(<t_channel_mutex); | |
331 | ret = _ltt_channels_get_event_id(channel, name); | |
332 | mutex_unlock(<t_channel_mutex); | |
333 | return ret; | |
334 | } | |
335 | ||
336 | MODULE_LICENSE("GPL"); | |
337 | MODULE_AUTHOR("Mathieu Desnoyers"); | |
338 | MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Channel Management"); |