X-Git-Url: http://git.lttng.org/?p=ust.git;a=blobdiff_plain;f=libust%2Fchannels.c;h=57e980104fd5ad40b3bbf9ed9841d53d69801bfb;hp=a8df3c48ad916a03661d786e6860491dec68aca0;hb=86699c2035dd69428706ade2d6dfb150ada757cb;hpb=b4512257eb71d0432554047acf6278dc42a15a75 diff --git a/libust/channels.c b/libust/channels.c index a8df3c4..57e9801 100644 --- a/libust/channels.c +++ b/libust/channels.c @@ -7,14 +7,24 @@ * * Author: * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -//ust// #include -//ust// #include -//ust// #include -//ust// #include - -#include "kernelcompat.h" +#include +#include #include "channels.h" #include "usterr.h" @@ -34,6 +44,9 @@ static LIST_HEAD(ltt_channels); static unsigned int free_index; static struct kref index_kref; /* Keeps track of allocated trace channels */ +int ust_channels_overwrite_by_default = 0; +int ust_channels_request_collection_by_default = 1; + static struct ltt_channel_setting *lookup_channel(const char *name) { struct ltt_channel_setting *iter; @@ -53,20 +66,21 @@ static struct ltt_channel_setting *lookup_channel(const char *name) */ static void release_channel_setting(struct kref *kref) { - struct ltt_channel_setting *setting = container_of(kref, + struct ltt_channel_setting *setting = _ust_container_of(kref, struct ltt_channel_setting, kref); struct ltt_channel_setting *iter; - if (atomic_read(&index_kref.refcount) == 0 - && atomic_read(&setting->kref.refcount) == 0) { + if (uatomic_read(&index_kref.refcount) == 0 + && uatomic_read(&setting->kref.refcount) == 0) { list_del(&setting->list); - kfree(setting); + free(setting); free_index = 0; list_for_each_entry(iter, <t_channels, list) { iter->index = free_index++; iter->free_event_id = 0; } + /* FIXME: why not run this? */ //ust// markers_compact_event_ids(); } } @@ -95,17 +109,17 @@ int ltt_channels_register(const char *name) struct ltt_channel_setting *setting; int ret = 0; - mutex_lock(<t_channel_mutex); + pthread_mutex_lock(<t_channel_mutex); setting = lookup_channel(name); if (setting) { - if (atomic_read(&setting->kref.refcount) == 0) + if (uatomic_read(&setting->kref.refcount) == 0) goto init_kref; else { kref_get(&setting->kref); goto end; } } - setting = kzalloc(sizeof(*setting), GFP_KERNEL); + setting = zmalloc(sizeof(*setting)); if (!setting) { ret = -ENOMEM; goto end; @@ -116,7 +130,7 @@ int ltt_channels_register(const char *name) init_kref: kref_init(&setting->kref); end: - mutex_unlock(<t_channel_mutex); + pthread_mutex_unlock(<t_channel_mutex); return ret; } //ust// EXPORT_SYMBOL_GPL(ltt_channels_register); @@ -132,15 +146,15 @@ int ltt_channels_unregister(const char *name) struct ltt_channel_setting *setting; int ret = 0; - mutex_lock(<t_channel_mutex); + pthread_mutex_lock(<t_channel_mutex); setting = lookup_channel(name); - if (!setting || atomic_read(&setting->kref.refcount) == 0) { + if (!setting || uatomic_read(&setting->kref.refcount) == 0) { ret = -ENOENT; goto end; } kref_put(&setting->kref, release_channel_setting); end: - mutex_unlock(<t_channel_mutex); + pthread_mutex_unlock(<t_channel_mutex); return ret; } //ust// EXPORT_SYMBOL_GPL(ltt_channels_unregister); @@ -158,16 +172,16 @@ int ltt_channels_set_default(const char *name, struct ltt_channel_setting *setting; int ret = 0; - mutex_lock(<t_channel_mutex); + pthread_mutex_lock(<t_channel_mutex); setting = lookup_channel(name); - if (!setting || atomic_read(&setting->kref.refcount) == 0) { + if (!setting || uatomic_read(&setting->kref.refcount) == 0) { ret = -ENOENT; goto end; } setting->subbuf_size = subbuf_size; setting->subbuf_cnt = subbuf_cnt; end: - mutex_unlock(<t_channel_mutex); + pthread_mutex_unlock(<t_channel_mutex); return ret; } //ust// EXPORT_SYMBOL_GPL(ltt_channels_set_default); @@ -184,7 +198,7 @@ const char *ltt_channels_get_name_from_index(unsigned int index) struct ltt_channel_setting *iter; list_for_each_entry(iter, <t_channels, list) - if (iter->index == index && atomic_read(&iter->kref.refcount)) + if (iter->index == index && uatomic_read(&iter->kref.refcount)) return iter->name; return NULL; } @@ -197,7 +211,7 @@ ltt_channels_get_setting_from_name(const char *name) list_for_each_entry(iter, <t_channels, list) if (!strcmp(iter->name, name) - && atomic_read(&iter->kref.refcount)) + && uatomic_read(&iter->kref.refcount)) return iter; return NULL; } @@ -232,40 +246,41 @@ int ltt_channels_get_index_from_name(const char *name) * Called with trace lock held. Does not perform the trace buffer allocation, * because we must let the user overwrite specific channel sizes. */ -struct ltt_channel_struct *ltt_channels_trace_alloc(unsigned int *nr_channels, +struct ust_channel *ltt_channels_trace_alloc(unsigned int *nr_channels, int overwrite, + int request_collection, int active) { - struct ltt_channel_struct *channel = NULL; + struct ust_channel *channel = NULL; struct ltt_channel_setting *iter; - mutex_lock(<t_channel_mutex); + pthread_mutex_lock(<t_channel_mutex); if (!free_index) { WARN("ltt_channels_trace_alloc: no free_index; are there any probes connected?"); goto end; } - if (!atomic_read(&index_kref.refcount)) + if (!uatomic_read(&index_kref.refcount)) kref_init(&index_kref); else kref_get(&index_kref); *nr_channels = free_index; - channel = kzalloc(sizeof(struct ltt_channel_struct) * free_index, - GFP_KERNEL); + channel = zmalloc(sizeof(struct ust_channel) * free_index); if (!channel) { WARN("ltt_channel_struct: channel null after alloc"); goto end; } list_for_each_entry(iter, <t_channels, list) { - if (!atomic_read(&iter->kref.refcount)) + if (!uatomic_read(&iter->kref.refcount)) continue; channel[iter->index].subbuf_size = iter->subbuf_size; channel[iter->index].subbuf_cnt = iter->subbuf_cnt; channel[iter->index].overwrite = overwrite; + channel[iter->index].request_collection = request_collection; channel[iter->index].active = active; channel[iter->index].channel_name = iter->name; } end: - mutex_unlock(<t_channel_mutex); + pthread_mutex_unlock(<t_channel_mutex); return channel; } //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc); @@ -277,13 +292,13 @@ end: * Called with trace lock held. The actual channel buffers must be freed before * this function is called. */ -void ltt_channels_trace_free(struct ltt_channel_struct *channels) +void ltt_channels_trace_free(struct ust_channel *channels) { lock_markers(); - mutex_lock(<t_channel_mutex); - kfree(channels); + pthread_mutex_lock(<t_channel_mutex); + free(channels); kref_put(&index_kref, release_trace_channel); - mutex_unlock(<t_channel_mutex); + pthread_mutex_unlock(<t_channel_mutex); unlock_markers(); } //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_free); @@ -337,9 +352,9 @@ int ltt_channels_get_event_id(const char *channel, const char *name) { int ret; - mutex_lock(<t_channel_mutex); + pthread_mutex_lock(<t_channel_mutex); ret = _ltt_channels_get_event_id(channel, name); - mutex_unlock(<t_channel_mutex); + pthread_mutex_unlock(<t_channel_mutex); return ret; }