1 files changed, 130 insertions, 0 deletions

diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
new file mode 100644
index 000000000000..e097c2e6b6dc
--- /dev/null
+++ b/include/linux/ring_buffer.h
@@ -0,0 +1,130 @@
+#ifndef _LINUX_RING_BUFFER_H
+#define _LINUX_RING_BUFFER_H
+
+#include <linux/mm.h>
+#include <linux/seq_file.h>
+
+struct ring_buffer;
+struct ring_buffer_iter;
+
+/*
+ * Don't reference this struct directly, use functions below.
+ */
+struct ring_buffer_event {
+        u32             type:2, len:3, time_delta:27;
+        u32             array[];
+};
+
+/**
+ * enum ring_buffer_type - internal ring buffer types
+ *
+ * @RINGBUF_TYPE_PADDING:       Left over page padding
+ *                               array is ignored
+ *                               size is variable depending on how much
+ *                                padding is needed
+ *
+ * @RINGBUF_TYPE_TIME_EXTEND:   Extend the time delta
+ *                               array[0] = time delta (28 .. 59)
+ *                               size = 8 bytes
+ *
+ * @RINGBUF_TYPE_TIME_STAMP:    Sync time stamp with external clock
+ *                               array[0] = tv_nsec
+ *                               array[1] = tv_sec
+ *                               size = 16 bytes
+ *
+ * @RINGBUF_TYPE_DATA:          Data record
+ *                               If len is zero:
+ *                                array[0] holds the actual length
+ *                                array[1..(length+3)/4-1] holds data
+ *                               else
+ *                                length = len << 2
+ *                                array[0..(length+3)/4] holds data
+ */
+enum ring_buffer_type {
+        RINGBUF_TYPE_PADDING,
+        RINGBUF_TYPE_TIME_EXTEND,
+        /* FIXME: RINGBUF_TYPE_TIME_STAMP not implemented */
+        RINGBUF_TYPE_TIME_STAMP,
+        RINGBUF_TYPE_DATA,
+};
+
+unsigned ring_buffer_event_length(struct ring_buffer_event *event);
+void *ring_buffer_event_data(struct ring_buffer_event *event);
+
+/**
+ * ring_buffer_event_time_delta - return the delta timestamp of the event
+ * @event: the event to get the delta timestamp of
+ *
+ * The delta timestamp is the 27 bit timestamp since the last event.
+ */
+static inline unsigned
+ring_buffer_event_time_delta(struct ring_buffer_event *event)
+{
+        return event->time_delta;
+}
+
+/*
+ * size is in bytes for each per CPU buffer.
+ */
+struct ring_buffer *
+ring_buffer_alloc(unsigned long size, unsigned flags);
+void ring_buffer_free(struct ring_buffer *buffer);
+
+int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size);
+
+struct ring_buffer_event *
+ring_buffer_lock_reserve(struct ring_buffer *buffer,
+                         unsigned long length,
+                         unsigned long *flags);
+int ring_buffer_unlock_commit(struct ring_buffer *buffer,
+                              struct ring_buffer_event *event,
+                              unsigned long flags);
+int ring_buffer_write(struct ring_buffer *buffer,
+                      unsigned long length, void *data);
+
+struct ring_buffer_event *
+ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts);
+struct ring_buffer_event *
+ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts);
+
+struct ring_buffer_iter *
+ring_buffer_read_start(struct ring_buffer *buffer, int cpu);
+void ring_buffer_read_finish(struct ring_buffer_iter *iter);
+
+struct ring_buffer_event *
+ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts);
+struct ring_buffer_event *
+ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts);
+void ring_buffer_iter_reset(struct ring_buffer_iter *iter);
+int ring_buffer_iter_empty(struct ring_buffer_iter *iter);
+
+unsigned long ring_buffer_size(struct ring_buffer *buffer);
+
+void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu);
+void ring_buffer_reset(struct ring_buffer *buffer);
+
+int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
+                         struct ring_buffer *buffer_b, int cpu);
+
+int ring_buffer_empty(struct ring_buffer *buffer);
+int ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu);
+
+void ring_buffer_record_disable(struct ring_buffer *buffer);
+void ring_buffer_record_enable(struct ring_buffer *buffer);
+void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu);
+void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu);
+
+unsigned long ring_buffer_entries(struct ring_buffer *buffer);
+unsigned long ring_buffer_overruns(struct ring_buffer *buffer);
+
+u64 ring_buffer_time_stamp(int cpu);
+void ring_buffer_normalize_time_stamp(int cpu, u64 *ts);
+
+void tracing_on(void);
+void tracing_off(void);
+
+enum ring_buffer_flags {
+        RB_FL_OVERWRITE         = 1 << 0,
+};
+
+#endif /* _LINUX_RING_BUFFER_H */