X-Git-Url: http://git.liburcu.org/?p=ust.git;a=blobdiff_plain;f=libust%2Fchannels.c;h=85e5944e325db8010e556b5b94f3fa5cdfc32a52;hp=27ceefc6d6a1cd7921ebb09f91c6d585615348e3;hb=535b0d0af1b6421ceb83e22821e85bc6919d16d9;hpb=aa08b4413291fabcbd1b1144377d37034ad361de

diff --git a/libust/channels.c b/libust/channels.c
index 27ceefc..85e5944 100644
--- a/libust/channels.c
+++ b/libust/channels.c
@@ -23,37 +23,36 @@
  * 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 <ust/kernelcompat.h>
-#include "channels.h"
-#include "usterr.h"
+#include <stdlib.h>
 #include <ust/marker.h>
+#include <ust/marker-internal.h>
+#include "channels.h"
+#include "usterr_signal_safe.h"
 
 /*
  * ltt_channel_mutex may be nested inside the LTT trace mutex.
  * ltt_channel_mutex mutex may be nested inside markers mutex.
  */
 static DEFINE_MUTEX(ltt_channel_mutex);
-static LIST_HEAD(ltt_channels);
+static CDS_LIST_HEAD(ltt_channels);
 /*
  * Index of next channel in array. Makes sure that as long as a trace channel is
  * allocated, no array index will be re-used when a channel is freed and then
  * another channel is allocated. This index is cleared and the array indexeds
- * get reassigned when the index_kref goes back to 0, which indicates that no
+ * get reassigned when the index_urcu_ref goes back to 0, which indicates that no
  * more trace channels are allocated.
  */
 static unsigned int free_index;
-static struct kref index_kref;	/* Keeps track of allocated trace channels */
+static struct urcu_ref index_urcu_ref;	/* 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;
 
-	list_for_each_entry(iter, &ltt_channels, list)
+	cds_list_for_each_entry(iter, &ltt_channels, list)
 		if (strcmp(name, iter->name) == 0)
 			return iter;
 	return NULL;
@@ -66,22 +65,23 @@ static struct ltt_channel_setting *lookup_channel(const char *name)
  *
  * Called with lock_markers() and channels mutex held.
  */
-static void release_channel_setting(struct kref *kref)
+static void release_channel_setting(struct urcu_ref *urcu_ref)
 {
-	struct ltt_channel_setting *setting = container_of(kref,
-		struct ltt_channel_setting, kref);
+	struct ltt_channel_setting *setting = _ust_container_of(urcu_ref,
+		struct ltt_channel_setting, urcu_ref);
 	struct ltt_channel_setting *iter;
 
-	if (atomic_read(&index_kref.refcount) == 0
-	    && atomic_read(&setting->kref.refcount) == 0) {
-		list_del(&setting->list);
-		kfree(setting);
+	if (uatomic_read(&index_urcu_ref.refcount) == 0
+	    && uatomic_read(&setting->urcu_ref.refcount) == 0) {
+		cds_list_del(&setting->list);
+		free(setting);
 
 		free_index = 0;
-		list_for_each_entry(iter, &ltt_channels, list) {
+		cds_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();
 	}
 }
@@ -91,12 +91,12 @@ static void release_channel_setting(struct kref *kref)
  *
  * Called with lock_markers() and channels mutex held.
  */
-static void release_trace_channel(struct kref *kref)
+static void release_trace_channel(struct urcu_ref *urcu_ref)
 {
 	struct ltt_channel_setting *iter, *n;
 
-	list_for_each_entry_safe(iter, n, &ltt_channels, list)
-		release_channel_setting(&iter->kref);
+	cds_list_for_each_entry_safe(iter, n, &ltt_channels, list)
+		release_channel_setting(&iter->urcu_ref);
 }
 
 /**
@@ -110,28 +110,28 @@ 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)
-			goto init_kref;
+		if (uatomic_read(&setting->urcu_ref.refcount) == 0)
+			goto init_urcu_ref;
 		else {
-			kref_get(&setting->kref);
+			urcu_ref_get(&setting->urcu_ref);
 			goto end;
 		}
 	}
-	setting = kzalloc(sizeof(*setting), GFP_KERNEL);
+	setting = zmalloc(sizeof(*setting));
 	if (!setting) {
 		ret = -ENOMEM;
 		goto end;
 	}
-	list_add(&setting->list, &ltt_channels);
+	cds_list_add(&setting->list, &ltt_channels);
 	strncpy(setting->name, name, PATH_MAX-1);
 	setting->index = free_index++;
-init_kref:
-	kref_init(&setting->kref);
+init_urcu_ref:
+	urcu_ref_init(&setting->urcu_ref);
 end:
-	mutex_unlock(&ltt_channel_mutex);
+	pthread_mutex_unlock(&ltt_channel_mutex);
 	return ret;
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_register);
@@ -147,15 +147,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->urcu_ref.refcount) == 0) {
 		ret = -ENOENT;
 		goto end;
 	}
-	kref_put(&setting->kref, release_channel_setting);
+	urcu_ref_put(&setting->urcu_ref, 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 +173,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->urcu_ref.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);
@@ -198,8 +198,8 @@ 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))
+	cds_list_for_each_entry(iter, &ltt_channels, list)
+		if (iter->index == index && uatomic_read(&iter->urcu_ref.refcount))
 			return iter->name;
 	return NULL;
 }
@@ -210,9 +210,9 @@ ltt_channels_get_setting_from_name(const char *name)
 {
 	struct ltt_channel_setting *iter;
 
-	list_for_each_entry(iter, &ltt_channels, list)
+	cds_list_for_each_entry(iter, &ltt_channels, list)
 		if (!strcmp(iter->name, name)
-		    && atomic_read(&iter->kref.refcount))
+		    && uatomic_read(&iter->urcu_ref.refcount))
 			return iter;
 	return NULL;
 }
@@ -247,40 +247,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))
-		kref_init(&index_kref);
+	if (!uatomic_read(&index_urcu_ref.refcount))
+		urcu_ref_init(&index_urcu_ref);
 	else
-		kref_get(&index_kref);
+		urcu_ref_get(&index_urcu_ref);
 	*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))
+	cds_list_for_each_entry(iter, &ltt_channels, list) {
+		if (!uatomic_read(&iter->urcu_ref.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,14 +293,14 @@ 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);
-	kref_put(&index_kref, release_trace_channel);
-	mutex_unlock(&ltt_channel_mutex);
-	unlock_markers();
+	lock_ust_marker();
+	pthread_mutex_lock(&ltt_channel_mutex);
+	free(channels);
+	urcu_ref_put(&index_urcu_ref, release_trace_channel);
+	pthread_mutex_unlock(&ltt_channel_mutex);
+	unlock_ust_marker();
 }
 //ust// EXPORT_SYMBOL_GPL(ltt_channels_trace_free);
 
@@ -352,9 +353,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;
 }