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
27 #include <ust/marker.h>
28 #include <ust/marker-internal.h>
30 #include "usterr_signal_safe.h"
33 * ltt_channel_mutex may be nested inside the LTT trace mutex.
34 * ltt_channel_mutex mutex may be nested inside markers mutex.
36 static DEFINE_MUTEX(ltt_channel_mutex
);
37 static CDS_LIST_HEAD(ltt_channels
);
39 * Index of next channel in array. Makes sure that as long as a trace channel is
40 * allocated, no array index will be re-used when a channel is freed and then
41 * another channel is allocated. This index is cleared and the array indexeds
42 * get reassigned when the index_urcu_ref goes back to 0, which indicates that no
43 * more trace channels are allocated.
45 static unsigned int free_index
;
46 static struct urcu_ref index_urcu_ref
; /* Keeps track of allocated trace channels */
48 int ust_channels_overwrite_by_default
= 0;
49 int ust_channels_request_collection_by_default
= 1;
51 static struct ltt_channel_setting
*lookup_channel(const char *name
)
53 struct ltt_channel_setting
*iter
;
55 cds_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 urcu_ref
*urcu_ref
)
70 struct ltt_channel_setting
*setting
= _ust_container_of(urcu_ref
,
71 struct ltt_channel_setting
, urcu_ref
);
72 struct ltt_channel_setting
*iter
;
74 if (uatomic_read(&index_urcu_ref
.refcount
) == 0
75 && uatomic_read(&setting
->urcu_ref
.refcount
) == 0) {
76 cds_list_del(&setting
->list
);
80 cds_list_for_each_entry(iter
, <t_channels
, list
) {
81 iter
->index
= free_index
++;
82 iter
->free_event_id
= 0;
84 /* FIXME: why not run this? */
85 //ust// markers_compact_event_ids();
90 * Perform channel index compaction when the last trace channel is freed.
92 * Called with lock_markers() and channels mutex held.
94 static void release_trace_channel(struct urcu_ref
*urcu_ref
)
96 struct ltt_channel_setting
*iter
, *n
;
98 cds_list_for_each_entry_safe(iter
, n
, <t_channels
, list
)
99 release_channel_setting(&iter
->urcu_ref
);
103 * ltt_channels_register - Register a trace channel.
104 * @name: channel name
108 int ltt_channels_register(const char *name
)
110 struct ltt_channel_setting
*setting
;
113 pthread_mutex_lock(<t_channel_mutex
);
114 setting
= lookup_channel(name
);
116 if (uatomic_read(&setting
->urcu_ref
.refcount
) == 0)
119 urcu_ref_get(&setting
->urcu_ref
);
123 setting
= zmalloc(sizeof(*setting
));
128 cds_list_add(&setting
->list
, <t_channels
);
129 strncpy(setting
->name
, name
, PATH_MAX
-1);
130 setting
->index
= free_index
++;
132 urcu_ref_init(&setting
->urcu_ref
);
134 pthread_mutex_unlock(<t_channel_mutex
);
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 pthread_mutex_lock(<t_channel_mutex
);
150 setting
= lookup_channel(name
);
151 if (!setting
|| uatomic_read(&setting
->urcu_ref
.refcount
) == 0) {
155 urcu_ref_put(&setting
->urcu_ref
, release_channel_setting
);
157 pthread_mutex_unlock(<t_channel_mutex
);
162 * ltt_channels_set_default - Set channel default behavior.
163 * @name: default channel name
164 * @subbuf_size: size of the subbuffers
165 * @subbuf_cnt: number of subbuffers
167 int ltt_channels_set_default(const char *name
,
168 unsigned int subbuf_size
,
169 unsigned int subbuf_cnt
)
171 struct ltt_channel_setting
*setting
;
174 pthread_mutex_lock(<t_channel_mutex
);
175 setting
= lookup_channel(name
);
176 if (!setting
|| uatomic_read(&setting
->urcu_ref
.refcount
) == 0) {
180 setting
->subbuf_size
= subbuf_size
;
181 setting
->subbuf_cnt
= subbuf_cnt
;
183 pthread_mutex_unlock(<t_channel_mutex
);
188 * ltt_channels_get_name_from_index - get channel name from channel index
189 * @index: channel index
191 * Allows to lookup the channel name given its index. Done to keep the name
192 * information outside of each trace channel instance.
194 const char *ltt_channels_get_name_from_index(unsigned int index
)
196 struct ltt_channel_setting
*iter
;
198 cds_list_for_each_entry(iter
, <t_channels
, list
)
199 if (iter
->index
== index
&& uatomic_read(&iter
->urcu_ref
.refcount
))
204 static struct ltt_channel_setting
*
205 ltt_channels_get_setting_from_name(const char *name
)
207 struct ltt_channel_setting
*iter
;
209 cds_list_for_each_entry(iter
, <t_channels
, list
)
210 if (!strcmp(iter
->name
, name
)
211 && uatomic_read(&iter
->urcu_ref
.refcount
))
217 * ltt_channels_get_index_from_name - get channel index from channel name
218 * @name: channel name
220 * Allows to lookup the channel index given its name. Done to keep the name
221 * information outside of each trace channel instance.
222 * Returns -1 if not found.
224 int ltt_channels_get_index_from_name(const char *name
)
226 struct ltt_channel_setting
*setting
;
228 setting
= ltt_channels_get_setting_from_name(name
);
230 return setting
->index
;
236 * ltt_channels_trace_alloc - Allocate channel structures for a trace
237 * @subbuf_size: subbuffer size. 0 uses default.
238 * @subbuf_cnt: number of subbuffers per per-cpu buffers. 0 uses default.
239 * @flags: Default channel flags
241 * Use the current channel list to allocate the channels for a trace.
242 * Called with trace lock held. Does not perform the trace buffer allocation,
243 * because we must let the user overwrite specific channel sizes.
245 struct ust_channel
*ltt_channels_trace_alloc(unsigned int *nr_channels
,
247 int request_collection
,
250 struct ust_channel
*channel
= NULL
;
251 struct ltt_channel_setting
*iter
;
253 pthread_mutex_lock(<t_channel_mutex
);
255 WARN("ltt_channels_trace_alloc: no free_index; are there any probes connected?");
258 if (!uatomic_read(&index_urcu_ref
.refcount
))
259 urcu_ref_init(&index_urcu_ref
);
261 urcu_ref_get(&index_urcu_ref
);
262 *nr_channels
= free_index
;
263 channel
= zmalloc(sizeof(struct ust_channel
) * free_index
);
265 WARN("ltt_channel_struct: channel null after alloc");
268 cds_list_for_each_entry(iter
, <t_channels
, list
) {
269 if (!uatomic_read(&iter
->urcu_ref
.refcount
))
271 channel
[iter
->index
].subbuf_size
= iter
->subbuf_size
;
272 channel
[iter
->index
].subbuf_cnt
= iter
->subbuf_cnt
;
273 channel
[iter
->index
].overwrite
= overwrite
;
274 channel
[iter
->index
].request_collection
= request_collection
;
275 channel
[iter
->index
].active
= active
;
276 channel
[iter
->index
].channel_name
= iter
->name
;
279 pthread_mutex_unlock(<t_channel_mutex
);
284 * ltt_channels_trace_free - Free one trace's channels
285 * @channels: channels to free
287 * Called with trace lock held. The actual channel buffers must be freed before
288 * this function is called.
290 void ltt_channels_trace_free(struct ust_channel
*channels
)
293 pthread_mutex_lock(<t_channel_mutex
);
295 urcu_ref_put(&index_urcu_ref
, release_trace_channel
);
296 pthread_mutex_unlock(<t_channel_mutex
);
301 * _ltt_channels_get_event_id - get next event ID for a marker
302 * @channel: channel name
305 * Returns a unique event ID (for this channel) or < 0 on error.
306 * Must be called with channels mutex held.
308 int _ltt_channels_get_event_id(const char *channel
, const char *name
)
310 struct ltt_channel_setting
*setting
;
313 setting
= ltt_channels_get_setting_from_name(channel
);
318 if (strcmp(channel
, "metadata") == 0) {
319 if (strcmp(name
, "core_marker_id") == 0)
321 else if (strcmp(name
, "core_marker_format") == 0)
323 else if (strcmp(name
, "testev") == 0)
329 if (setting
->free_event_id
== EVENTS_PER_CHANNEL
- 1) {
333 ret
= setting
->free_event_id
++;
339 * ltt_channels_get_event_id - get next event ID for a marker
340 * @channel: channel name
343 * Returns a unique event ID (for this channel) or < 0 on error.
345 int ltt_channels_get_event_id(const char *channel
, const char *name
)
349 pthread_mutex_lock(<t_channel_mutex
);
350 ret
= _ltt_channels_get_event_id(channel
, name
);
351 pthread_mutex_unlock(<t_channel_mutex
);