Add trace-seq

The trace-seq is a nice utility I wrote for Linux. It makes a page size
buffer that that can be written to with a printf,puts,putc interface.
This is perfect for having the same routine write the same type of
output, and used separately.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

3 files changed, 202 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index a8dbce1..0291dab 100644
--- a/Makefile
+++ b/Makefile
@@ -13,8 +13,9 @@ all: $(TARGETS)
 parse-events.o::        parse-events.h
 trace-read.o::          parse-events.h
 trace-cmd.o::           parse-events.h
+trace-seq.o::           parse-events.h trace-seq.h
 
-trace-cmd: trace-cmd.o trace-read.o parse-events.o
+trace-cmd: trace-cmd.o trace-read.o parse-events.o trace-seq.o
         $(CC) $^ -o $@
 
 clean:
diff --git a/trace-seq.c b/trace-seq.c
new file mode 100644
index 0000000..0201582
--- /dev/null
+++ b/trace-seq.c
@@ -0,0 +1,160 @@
+/*
+ * trace_seq.c
+ *
+ * Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "parse-events.h"
+#include "trace-seq.h"
+
+/**
+ * trace_seq_printf - sequence printing of trace information
+ * @s: trace sequence descriptor
+ * @fmt: printf format string
+ *
+ * It returns 0 if the trace oversizes the buffer's free
+ * space, 1 otherwise.
+ *
+ * The tracer may use either sequence operations or its own
+ * copy to user routines. To simplify formating of a trace
+ * trace_seq_printf is used to store strings into a special
+ * buffer (@s). Then the output may be either used by
+ * the sequencer or pulled into another buffer.
+ */
+int
+trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+{
+        int len = (PAGE_SIZE - 1) - s->len;
+        va_list ap;
+        int ret;
+
+        if (!len)
+                return 0;
+
+        va_start(ap, fmt);
+        ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
+        va_end(ap);
+
+        /* If we can't write it all, don't bother writing anything */
+        if (ret >= len)
+                return 0;
+
+        s->len += ret;
+
+        return 1;
+}
+
+/**
+ * trace_seq_vprintf - sequence printing of trace information
+ * @s: trace sequence descriptor
+ * @fmt: printf format string
+ *
+ * The tracer may use either sequence operations or its own
+ * copy to user routines. To simplify formating of a trace
+ * trace_seq_printf is used to store strings into a special
+ * buffer (@s). Then the output may be either used by
+ * the sequencer or pulled into another buffer.
+ */
+int
+trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+{
+        int len = (PAGE_SIZE - 1) - s->len;
+        int ret;
+
+        if (!len)
+                return 0;
+
+        ret = vsnprintf(s->buffer + s->len, len, fmt, args);
+
+        /* If we can't write it all, don't bother writing anything */
+        if (ret >= len)
+                return 0;
+
+        s->len += ret;
+
+        return len;
+}
+
+/**
+ * trace_seq_puts - trace sequence printing of simple string
+ * @s: trace sequence descriptor
+ * @str: simple string to record
+ *
+ * The tracer may use either the sequence operations or its own
+ * copy to user routines. This function records a simple string
+ * into a special buffer (@s) for later retrieval by a sequencer
+ * or other mechanism.
+ */
+int trace_seq_puts(struct trace_seq *s, const char *str)
+{
+        int len = strlen(str);
+
+        if (len > ((PAGE_SIZE - 1) - s->len))
+                return 0;
+
+        memcpy(s->buffer + s->len, str, len);
+        s->len += len;
+
+        return len;
+}
+
+int trace_seq_putc(struct trace_seq *s, unsigned char c)
+{
+        if (s->len >= (PAGE_SIZE - 1))
+                return 0;
+
+        s->buffer[s->len++] = c;
+
+        return 1;
+}
+
+int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len)
+{
+        if (len > ((PAGE_SIZE - 1) - s->len))
+                return 0;
+
+        memcpy(s->buffer + s->len, mem, len);
+        s->len += len;
+
+        return len;
+}
+
+void *trace_seq_reserve(struct trace_seq *s, size_t len)
+{
+        void *ret;
+
+        if (len > ((PAGE_SIZE - 1) - s->len))
+                return NULL;
+
+        ret = s->buffer + s->len;
+        s->len += len;
+
+        return ret;
+}
+
+int trace_seq_do_printf(struct trace_seq *s)
+{
+        char *buf;
+        int ret;
+
+        if (!s->len)
+                return 0;
+
+        if (s->len < PAGE_SIZE) {
+                s->buffer[s->len] = 0;
+                return printf("%s", s->buffer);
+        }
+
+        buf = malloc_or_die(s->len + 1);
+        memcpy(buf, s->buffer, s->len);
+        buf[s->len] = 0;
+        ret = printf("%s", buf);
+        free(buf);
+
+        return ret;
+}
diff --git a/trace-seq.h b/trace-seq.h
new file mode 100644
index 0000000..f6f0339
--- /dev/null
+++ b/trace-seq.h
@@ -0,0 +1,40 @@
+#ifndef _TRACE_SEQ_H
+#define _TRACE_SEQ_H
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 4096
+#endif
+
+/*
+ * Trace sequences are used to allow a function to call several other functions
+ * to create a string of data to use (up to a max of PAGE_SIZE).
+ */
+
+struct trace_seq {
+        char                    buffer[PAGE_SIZE];
+        unsigned int            len;
+        unsigned int            readpos;
+};
+
+static inline void
+trace_seq_init(struct trace_seq *s)
+{
+        s->len = 0;
+        s->readpos = 0;
+}
+
+extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+        __attribute__ ((format (printf, 2, 0)));
+
+extern int trace_seq_puts(struct trace_seq *s, const char *str);
+extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
+extern int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len);
+extern int trace_seq_putmem_hex(struct trace_seq *s, const void *mem,
+                                size_t len);
+extern void *trace_seq_reserve(struct trace_seq *s, size_t len);
+
+extern int trace_seq_do_printf(struct trace_seq *s);
+
+#endif /* _TRACE_SEQ_H */