Start at supporting the original transport (STP_TRANSPORT_VERSION=1).

* runtime/print.c: Only use print_new.c.
* runtime/print_new.c (stp_print_flush): Add STP_TRANSPORT_VERSION 1 support.
* runtime/transport/transport.c: Removed inclusion of procfs.c.
* runtime/transport/procfs.c (_stp_proc_read): Adapt to new interface.
  (_stp_proc_write): Ditto.
* runtime/transport/relayfs.c: Ditto.

5 files changed, 100 insertions, 114 deletions

diff --git a/runtime/print.c b/runtime/print.c
index 2e205f10..c1fff306 100644
--- a/runtime/print.c
+++ b/runtime/print.c
@@ -87,14 +87,8 @@ static void _stp_print_cleanup (void)
 #endif
 
 #if !defined(RELAY_GUEST)
-/* The relayfs API changed between 2.6.15 and 2.6.16. */
-/* Use the appropriate print flush function. */
 
-#if STP_TRANSPORT_VERSION == 1
-#include "print_old.c"
-#else
 #include "print_new.c"
-#endif
 #if defined(RELAY_HOST)
 EXPORT_SYMBOL_GPL(EXPORT_FN(stp_print_flush));
 #endif
diff --git a/runtime/print_new.c b/runtime/print_new.c
index b6187978..2d5a6e10 100644
--- a/runtime/print_new.c
+++ b/runtime/print_new.c
@@ -92,7 +92,15 @@ void EXPORT_FN(stp_print_flush)(_stp_pbuf *pb)
 		}
 	}
 #endif /* !NO_PERCPU_HEADERS */
+
 #else  /* !STP_BULKMODE */
+
+#if STP_TRANSPORT_VERSION == 1
+
+	if (unlikely(_stp_ctl_write(STP_REALTIME_DATA, pb->buf, len) <= 0))
+		atomic_inc (&_stp_transport_failures);
+
+#else  /* STP_TRANSPORT_VERSION != 1 */
 	{
 		unsigned long flags;
 		char *bufp = pb->buf;
@@ -117,5 +125,6 @@ void EXPORT_FN(stp_print_flush)(_stp_pbuf *pb)
 		}
 		spin_unlock_irqrestore(&_stp_print_lock, flags);
 	}
+#endif /* STP_TRANSPORT_VERSION != 1 */
 #endif /* !STP_BULKMODE */
 }
diff --git a/runtime/transport/procfs.c b/runtime/transport/procfs.c
index 6afbdea1..9e05cc14 100644
--- a/runtime/transport/procfs.c
+++ b/runtime/transport/procfs.c
@@ -14,7 +14,6 @@
 #define STP_DEFAULT_BUFFERS 256
 
 #ifdef STP_BULKMODE
-extern int _stp_relay_flushing;
 /* handle the per-cpu subbuf info read for relayfs */
 static ssize_t _stp_proc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 {
@@ -23,13 +22,13 @@ static ssize_t _stp_proc_read(struct file *file, char __user *buf, size_t count,
 
 	int cpu = *(int *)(PDE(file->f_dentry->d_inode)->data);
 
-	if (!_stp_utt->rchan)
+	if (!_stp_relay_data.rchan)
 		return -EINVAL;
 
 	out.cpu = cpu;
-	out.produced = atomic_read(&_stp_utt->rchan->buf[cpu]->subbufs_produced);
-	out.consumed = atomic_read(&_stp_utt->rchan->buf[cpu]->subbufs_consumed);
-	out.flushing = _stp_relay_flushing;
+	out.produced = atomic_read(&_stp_relay_data.rchan->buf[cpu]->subbufs_produced);
+	out.consumed = atomic_read(&_stp_relay_data.rchan->buf[cpu]->subbufs_consumed);
+	out.flushing = _stp_relay_data.flushing;
 
 	num = sizeof(out);
 	if (copy_to_user(buf, &out, num))
@@ -46,7 +45,7 @@ static ssize_t _stp_proc_write(struct file *file, const char __user *buf, size_t
 	if (copy_from_user(&info, buf, count))
 		return -EFAULT;
 
-	relay_subbufs_consumed(_stp_utt->rchan, cpu, info.consumed);
+	relay_subbufs_consumed(_stp_relay_data.rchan, cpu, info.consumed);
 	return count;
 }
 
diff --git a/runtime/transport/relayfs.c b/runtime/transport/relayfs.c
index 42be4283..dac6db1d 100644
--- a/runtime/transport/relayfs.c
+++ b/runtime/transport/relayfs.c
@@ -22,17 +22,33 @@
 #include <linux/init.h>
 #include <linux/relayfs_fs.h>
 #include <linux/namei.h>
-#include "utt.h"
 
-static int _stp_relay_flushing = 0;
+enum _stp_transport_state {
+	STP_TRANSPORT_STOPPED,
+	STP_TRANSPORT_INITIALIZED,
+	STP_TRANSPORT_RUNNING,
+};
+
+struct _stp_relay_data_type {
+	enum _stp_transport_state transport_state;
+	struct rchan *rchan;
+	int flushing;
+};
+struct _stp_relay_data_type _stp_relay_data;
+
+/* We need to include procfs.c here so that it can see the
+ * _stp_relay_data_type definition. */
+#include "procfs.c"
 
 /**
- *	_stp_subbuf_start - subbuf_start() relayfs callback implementation
+ *	__stp_relay_subbuf_start_callback - subbuf_start() relayfs
+ *	callback implementation
  */
-static int _stp_subbuf_start(struct rchan_buf *buf,
-			     void *subbuf,
-			     unsigned prev_subbuf_idx,
-			     void *prev_subbuf)
+static int
+__stp_relay_subbuf_start_callback(struct rchan_buf *buf,
+				  void *subbuf,
+				  unsigned prev_subbuf_idx,
+				  void *prev_subbuf)
 {
 	unsigned padding = buf->padding[prev_subbuf_idx];
 	if (prev_subbuf)
@@ -42,11 +58,12 @@ static int _stp_subbuf_start(struct rchan_buf *buf,
 }
 
 /**
- *	_stp_buf_full - buf_full() relayfs callback implementation
+ *	__stp_relay_buf_full_callback - buf_full() relayfs callback
+ *	implementation
  */
-static void _stp_buf_full(struct rchan_buf *buf,
-			  unsigned subbuf_idx,
-			  void *subbuf)
+static void __stp_relay_buf_full_callback(struct rchan_buf *buf,
+					  unsigned subbuf_idx,
+					  void *subbuf)
 {
 	unsigned padding = buf->padding[subbuf_idx];
 	*((unsigned *)subbuf) = padding;
@@ -54,126 +71,94 @@ static void _stp_buf_full(struct rchan_buf *buf,
 
 static struct rchan_callbacks stp_rchan_callbacks =
 {
-	.subbuf_start = _stp_subbuf_start,
-	.buf_full = _stp_buf_full,
+	.subbuf_start = __stp_relay_subbuf_start_callback,
+	.buf_full = __stp_relay_buf_full_callback,
 };
 
-
-static void _stp_remove_relay_dir(struct dentry *dir)
-{
-	if (dir)
-		relayfs_remove_dir(dir);
-}
-
-static void _stp_remove_relay_root(struct dentry *root)
+static void _stp_transport_data_fs_close(void)
 {
-	if (root) {
-		if (!_stp_lock_transport_dir()) {
-			errk("Unable to lock transport directory.\n");
-			return;
-		}
-		_stp_remove_relay_dir(root);
-		_stp_unlock_transport_dir();
+	if (_stp_relay_data.rchan) {
+		_stp_relay_data.flushing = 1;
+		relay_flush(_stp_relay_data.rchan);
+		relay_close(_stp_relay_data.rchan);
 	}
+	_stp_relay_data.transport_state = STP_TRANSPORT_STOPPED;
 }
 
-static struct utt_trace *utt_trace_setup(struct utt_trace_setup *utts)
+static int _stp_transport_data_fs_init(void)
 {
-	struct utt_trace *utt;
+	int rc = 0;
 	int i;
 
-	utt = _stp_kzalloc(sizeof(*utt));
-	if (!utt)
-		return NULL;
-
-	utt->utt_tree_root = _stp_get_root_dir();
-	if (!utt->utt_tree_root)
-		goto err;
-
-	utt->dir = relayfs_create_dir(utts->name, utt->utt_tree_root);
-	if (!utt->dir)
-		goto err;
-
-	dbug_trans(1, "relay_open %d %d\n",  utts->buf_size, utts->buf_nr);
+	dbug_trans(1, "relay_open %d %d\n", _stp_subbuf_size, _stp_nsubbufs);
+	_stp_relay_data.transport_state = STP_TRANSPORT_STOPPED;
+	_stp_relay_data.flushing = 0;
 
-	utt->rchan = relay_open("trace", utt->dir, utts->buf_size,
-				utts->buf_nr, 0, &stp_rchan_callbacks);
-	if (!utt->rchan)
+	/* Create "trace" file. */
+	_stp_relay_data.rchan = relay_open("trace", _stp_get_module_dir(),
+					   _stp_subbuf_size, _stp_nsubbufs,
+					   0, &stp_rchan_callbacks);
+	if (!_stp_relay_data.rchan) {
+		rc = -ENOENT;
 		goto err;
+	}
 
 	/* now set ownership */
 	for_each_online_cpu(i) {
-		utt->rchan->buf[i]->dentry->d_inode->i_uid = _stp_uid;
-		utt->rchan->buf[i]->dentry->d_inode->i_gid = _stp_gid;
+		_stp_relay_data.rchan->buf[i]->dentry->d_inode->i_uid
+			= _stp_uid;
+		_stp_relay_data.rchan->buf[i]->dentry->d_inode->i_gid
+			= _stp_gid;
 	}
 
-	utt->rchan->private_data = utt;
-	utt->trace_state = Utt_trace_setup;
-	utts->err = 0;
-	return utt;
+	/* We're off and running. */
+	smp_mb();
+	_stp_relay_data.transport_state = STP_TRANSPORT_RUNNING;
+	return rc;
 
 err:
 	errk("couldn't create relay channel.\n");
-	if (utt->dir)
-		_stp_remove_relay_dir(utt->dir);
-	if (utt->utt_tree_root)
-		_stp_remove_relay_root(utt->utt_tree_root);
-	_stp_kfree(utt);
-	return NULL;
+	_stp_transport_data_fs_close();
+	return rc;
 }
 
-static void utt_set_overwrite(int overwrite)
+static void stp_relay_set_overwrite(int overwrite)
 {
-	if (_stp_utt)
-		_stp_utt->rchan->overwrite = overwrite;
+	_stp_relay_data.rchan->overwrite = overwrite;
 }
 
-static int utt_trace_startstop(struct utt_trace *utt, int start,
-			unsigned int *trace_seq)
+/**
+ *      _stp_data_write_reserve - try to reserve size_request bytes
+ *      @size_request: number of bytes to attempt to reserve
+ *      @entry: entry is returned here
+ *
+ *      Returns number of bytes reserved, 0 if full.  On return, entry
+ *      will point to allocated opaque pointer.  Use
+ *      _stp_data_entry_data() to get pointer to copy data into.
+ *
+ *	(For this code's purposes, entry is filled in with the actual
+ *	data pointer, but the caller doesn't know that.)
+ */
+static size_t
+_stp_data_write_reserve(size_t size_request, void **entry)
 {
-	int ret;
+	if (entry == NULL)
+		return -EINVAL;
 
-	if (!utt)
+	*entry = relay_reserve(_stp_relay_data.rchan, size_request);
+	if (*entry == NULL)
 		return 0;
-
-	/*
-	 * For starting a trace, we can transition from a setup or stopped
-	 * trace. For stopping a trace, the state must be running
-	 */
-	ret = -EINVAL;
-	if (start) {
-		if (utt->trace_state == Utt_trace_setup ||
-		    utt->trace_state == Utt_trace_stopped) {
-			if (trace_seq)
-				(*trace_seq)++;
-			smp_mb();
-			utt->trace_state = Utt_trace_running;
-			ret = 0;
-		}
-	} else {
-		if (utt->trace_state == Utt_trace_running) {
-			utt->trace_state = Utt_trace_stopped;
-			_stp_relay_flushing = 1;
-			relay_flush(utt->rchan);
-			ret = 0;
-		}
-	}
-
-	return ret;
+	return size_request;
 }
 
+static unsigned char *_stp_data_entry_data(void *entry)
+{
+	/* Nothing to do here. */
+	return entry;
+}
 
-static int utt_trace_remove(struct utt_trace *utt)
+static int _stp_data_write_commit(void *entry)
 {
-  	dbug_trans(1, "removing relayfs files. %d\n", utt->trace_state);
-	if (utt && (utt->trace_state == Utt_trace_setup || utt->trace_state == Utt_trace_stopped)) {
-		if (utt->rchan)
-			relay_close(utt->rchan);
-		if (utt->dir)
-			_stp_remove_relay_dir(utt->dir);
-		if (utt->utt_tree_root)
-			_stp_remove_relay_root(utt->utt_tree_root);
-		_stp_kfree(utt);
-	}
+	/* Nothing to do here. */
 	return 0;
 }
diff --git a/runtime/transport/transport.c b/runtime/transport/transport.c
index 5a499e8d..3d0453bf 100644
--- a/runtime/transport/transport.c
+++ b/runtime/transport/transport.c
@@ -44,7 +44,6 @@ static int _stp_probes_started = 0;
 #include "control.h"
 #if STP_TRANSPORT_VERSION == 1
 #include "relayfs.c"
-#include "procfs.c"
 #elif STP_TRANSPORT_VERSION == 2
 #include "relay_v2.c"
 #include "debugfs.c"