tracectl cleanup v3

[ust.git] / libust / channels.c

diff --git a/libust/channels.c b/libust/channels.c
index 10ab587cb6ca969ad5669333e40b6cce75319de6..df1a9725735704b779abbdd06f93b204e4c28413 100644 (file)
--- a/libust/channels.c
+++ b/libust/channels.c
@@ -23,15 +23,10 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
 
-//ust// #include <linux/module.h>
-//ust// #include <linux/ltt-channels.h>
-//ust// #include <linux/mutex.h>
-//ust// #include <linux/vmalloc.h>
-
-#include "kernelcompat.h"
+#include <stdlib.h>
+#include <ust/marker.h>
 #include "channels.h"
 #include "usterr.h"
-#include "marker.h"
 
 /*
  * ltt_channel_mutex may be nested inside the LTT trace mutex.
@@ -49,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;
@@ -72,16 +70,17 @@ static void release_channel_setting(struct kref *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, &ltt_channels, list) {
                        iter->index = free_index++;
                        iter->free_event_id = 0;
                }
+               /* FIXME: why not run this? */
 //ust//                markers_compact_event_ids();
        }
 }
@@ -110,17 +109,17 @@ int ltt_channels_register(const char *name)
        struct ltt_channel_setting *setting;
        int ret = 0;
 
-       mutex_lock(&ltt_channel_mutex);
+       pthread_mutex_lock(&ltt_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;
@@ -131,7 +130,7 @@ int ltt_channels_register(const char *name)
 init_kref:
        kref_init(&setting->kref);
 end:
-       mutex_unlock(&ltt_channel_mutex);
+       pthread_mutex_unlock(&ltt_channel_mutex);
        return ret;
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_register);
@@ -147,15 +146,15 @@ int ltt_channels_unregister(const char *name)
        struct ltt_channel_setting *setting;
        int ret = 0;
 
-       mutex_lock(&ltt_channel_mutex);
+       pthread_mutex_lock(&ltt_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(&ltt_channel_mutex);
+       pthread_mutex_unlock(&ltt_channel_mutex);
        return ret;
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_unregister);
@@ -173,16 +172,16 @@ int ltt_channels_set_default(const char *name,
        struct ltt_channel_setting *setting;
        int ret = 0;
 
-       mutex_lock(&ltt_channel_mutex);
+       pthread_mutex_lock(&ltt_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(&ltt_channel_mutex);
+       pthread_mutex_unlock(&ltt_channel_mutex);
        return ret;
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_set_default);
@@ -199,7 +198,7 @@ const char *ltt_channels_get_name_from_index(unsigned int index)
        struct ltt_channel_setting *iter;
 
        list_for_each_entry(iter, &ltt_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;
 }
@@ -212,7 +211,7 @@ ltt_channels_get_setting_from_name(const char *name)
 
        list_for_each_entry(iter, &ltt_channels, list)
                if (!strcmp(iter->name, name)
-                   && atomic_read(&iter->kref.refcount))
+                   && uatomic_read(&iter->kref.refcount))
                        return iter;
        return NULL;
 }
@@ -247,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(&ltt_channel_mutex);
+       pthread_mutex_lock(&ltt_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, &ltt_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(&ltt_channel_mutex);
+       pthread_mutex_unlock(&ltt_channel_mutex);
        return channel;
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc);
@@ -292,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(&ltt_channel_mutex);
-       kfree(channels);
+       pthread_mutex_lock(&ltt_channel_mutex);
+       free(channels);
        kref_put(&index_kref, release_trace_channel);
-       mutex_unlock(&ltt_channel_mutex);
+       pthread_mutex_unlock(&ltt_channel_mutex);
        unlock_markers();
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_free);
@@ -352,9 +352,9 @@ int ltt_channels_get_event_id(const char *channel, const char *name)
 {
        int ret;
 
-       mutex_lock(&ltt_channel_mutex);
+       pthread_mutex_lock(&ltt_channel_mutex);
        ret = _ltt_channels_get_event_id(channel, name);
-       mutex_unlock(&ltt_channel_mutex);
+       pthread_mutex_unlock(&ltt_channel_mutex);
        return ret;
 }