[lttng-ust.git] / libringbuffer / frontend_types.h

#ifndef _LINUX_RING_BUFFER_FRONTEND_TYPES_H
#define _LINUX_RING_BUFFER_FRONTEND_TYPES_H

/*
 * linux/ringbuffer/frontend_types.h
 *
 * (C) Copyright 2005-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * Ring Buffer Library Synchronization Header (types).
 *
 * Author:
 *	Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * See ring_buffer_frontend.c for more information on wait-free algorithms.
 *
 * Dual LGPL v2.1/GPL v2 license.
 */

#include <string.h>

#include <urcu/list.h>
#include <urcu/uatomic.h>

#include "ust/core.h"

#include <ust/usterr-signal-safe.h>
#include <ust/ringbuffer-config.h>
#include "backend_types.h"
#include "shm.h"

/*
 * A switch is done during tracing or as a final flush after tracing (so it
 * won't write in the new sub-buffer).
 */
enum switch_mode { SWITCH_ACTIVE, SWITCH_FLUSH };

/* channel: collection of per-cpu ring buffers. */
struct channel {
	int record_disabled;
	unsigned long commit_count_mask;	/*
						 * Commit count mask, removing
						 * the MSBs corresponding to
						 * bits used to represent the
						 * subbuffer index.
						 */

	struct channel_backend backend;		/* Associated backend */

	unsigned long switch_timer_interval;	/* Buffer flush (jiffies) */
	unsigned long read_timer_interval;	/* Reader wakeup (jiffies) */
	//wait_queue_head_t read_wait;		/* reader wait queue */
	int finalized;				/* Has channel been finalized */
	DECLARE_SHMP(struct shm_header, shm_header);
} ____cacheline_aligned;

/* Per-subbuffer commit counters used on the hot path */
struct commit_counters_hot {
	union v_atomic cc;		/* Commit counter */
	union v_atomic seq;		/* Consecutive commits */
} ____cacheline_aligned;

/* Per-subbuffer commit counters used only on cold paths */
struct commit_counters_cold {
	union v_atomic cc_sb;		/* Incremented _once_ at sb switch */
} ____cacheline_aligned;

/* ring buffer state */
struct lib_ring_buffer {
	/* First 32 bytes cache-hot cacheline */
	union v_atomic offset;		/* Current offset in the buffer */
	DECLARE_SHMP(struct commit_counters_hot, commit_hot);
					/* Commit count per sub-buffer */
	long consumed;			/*
					 * Current offset in the buffer
					 * standard atomic access (shared)
					 */
	int record_disabled;
	/* End of first 32 bytes cacheline */
	union v_atomic last_tsc;	/*
					 * Last timestamp written in the buffer.
					 */

	struct lib_ring_buffer_backend backend;	/* Associated backend */

	DECLARE_SHMP(struct commit_counters_cold, commit_cold);
					/* Commit count per sub-buffer */
	long active_readers;		/*
					 * Active readers count
					 * standard atomic access (shared)
					 */
					/* Dropped records */
	union v_atomic records_lost_full;	/* Buffer full */
	union v_atomic records_lost_wrap;	/* Nested wrap-around */
	union v_atomic records_lost_big;	/* Events too big */
	union v_atomic records_count;	/* Number of records written */
	union v_atomic records_overrun;	/* Number of overwritten records */
	//wait_queue_head_t read_wait;	/* reader buffer-level wait queue */
	int finalized;			/* buffer has been finalized */
	//struct timer_list switch_timer;	/* timer for periodical switch */
	//struct timer_list read_timer;	/* timer for read poll */
	unsigned long get_subbuf_consumed;	/* Read-side consumed */
	unsigned long prod_snapshot;	/* Producer count snapshot */
	unsigned long cons_snapshot;	/* Consumer count snapshot */
	int get_subbuf:1;		/* Sub-buffer being held by reader */
	int switch_timer_enabled:1;	/* Protected by ring_buffer_nohz_lock */
	int read_timer_enabled:1;	/* Protected by ring_buffer_nohz_lock */
} ____cacheline_aligned;

static inline
void *channel_get_private(struct channel *chan)
{
	return chan->backend.priv;
}

/*
 * Issue warnings and disable channels upon internal error.
 * Can receive struct lib_ring_buffer or struct lib_ring_buffer_backend
 * parameters.
 */
#define CHAN_WARN_ON(c, cond)						\
	({								\
		struct channel *__chan;					\
		int _____ret = unlikely(cond);				\
		if (_____ret) {						\
			if (__same_type(*(c), struct channel_backend))	\
				__chan = caa_container_of((void *) (c),	\
							struct channel, \
							backend);	\
			else if (__same_type(*(c), struct channel))	\
				__chan = (void *) (c);			\
			else						\
				BUG_ON(1);				\
			uatomic_inc(&__chan->record_disabled);		\
			WARN_ON(1);					\
		}							\
		_____ret;						\
	})

#endif /* _LINUX_RING_BUFFER_FRONTEND_TYPES_H */
Commit	Line	Data
852c2936 MD	1	#ifndef _LINUX_RING_BUFFER_FRONTEND_TYPES_H
	2	#define _LINUX_RING_BUFFER_FRONTEND_TYPES_H
	3
	4	/*
	5	* linux/ringbuffer/frontend_types.h
	6	*
	7	* (C) Copyright 2005-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	8	*
	9	* Ring Buffer Library Synchronization Header (types).
	10	*
	11	* Author:
	12	* Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	13	*
	14	* See ring_buffer_frontend.c for more information on wait-free algorithms.
	15	*
	16	* Dual LGPL v2.1/GPL v2 license.
	17	*/
	18
a6352fd4 MD	19	#include <string.h>
a6352fd4 MD	20
14641deb MD	21	#include <urcu/list.h>
14641deb MD	22	#include <urcu/uatomic.h>
14641deb MD	23
	24	#include "ust/core.h"
	25
1dbfff0c	26	#include <ust/usterr-signal-safe.h>
8d8a24c8	27	#include <ust/ringbuffer-config.h>
4931a13e	28	#include "backend_types.h"
a6352fd4	29	#include "shm.h"
852c2936 MD	30
	31	/*
	32	* A switch is done during tracing or as a final flush after tracing (so it
	33	* won't write in the new sub-buffer).
	34	*/
	35	enum switch_mode { SWITCH_ACTIVE, SWITCH_FLUSH };
	36
852c2936 MD	37	/* channel: collection of per-cpu ring buffers. */
852c2936 MD	38	struct channel {
14641deb	39	int record_disabled;
852c2936 MD	40	unsigned long commit_count_mask; /*
	41	* Commit count mask, removing
	42	* the MSBs corresponding to
	43	* bits used to represent the
	44	* subbuffer index.
	45	*/
	46
	47	struct channel_backend backend; /* Associated backend */
	48
	49	unsigned long switch_timer_interval; /* Buffer flush (jiffies) */
	50	unsigned long read_timer_interval; /* Reader wakeup (jiffies) */
14641deb	51	//wait_queue_head_t read_wait; /* reader wait queue */
852c2936	52	int finalized; /* Has channel been finalized */
a6352fd4 MD	53	DECLARE_SHMP(struct shm_header, shm_header);
a6352fd4 MD	54	} ____cacheline_aligned;
852c2936 MD	55
	56	/* Per-subbuffer commit counters used on the hot path */
	57	struct commit_counters_hot {
	58	union v_atomic cc; /* Commit counter */
	59	union v_atomic seq; /* Consecutive commits */
a6352fd4	60	} ____cacheline_aligned;
852c2936 MD	61
	62	/* Per-subbuffer commit counters used only on cold paths */
	63	struct commit_counters_cold {
	64	union v_atomic cc_sb; /* Incremented _once_ at sb switch */
a6352fd4	65	} ____cacheline_aligned;
852c2936	66
852c2936 MD	67	/* ring buffer state */
	68	struct lib_ring_buffer {
	69	/* First 32 bytes cache-hot cacheline */
	70	union v_atomic offset; /* Current offset in the buffer */
a6352fd4	71	DECLARE_SHMP(struct commit_counters_hot, commit_hot);
852c2936	72	/* Commit count per sub-buffer */
14641deb	73	long consumed; /*
852c2936 MD	74	* Current offset in the buffer
	75	* standard atomic access (shared)
	76	*/
14641deb	77	int record_disabled;
852c2936 MD	78	/* End of first 32 bytes cacheline */
	79	union v_atomic last_tsc; /*
	80	* Last timestamp written in the buffer.
	81	*/
	82
	83	struct lib_ring_buffer_backend backend; /* Associated backend */
	84
a6352fd4	85	DECLARE_SHMP(struct commit_counters_cold, commit_cold);
852c2936	86	/* Commit count per sub-buffer */
14641deb	87	long active_readers; /*
852c2936 MD	88	* Active readers count
	89	* standard atomic access (shared)
	90	*/
	91	/* Dropped records */
	92	union v_atomic records_lost_full; /* Buffer full */
	93	union v_atomic records_lost_wrap; /* Nested wrap-around */
	94	union v_atomic records_lost_big; /* Events too big */
	95	union v_atomic records_count; /* Number of records written */
	96	union v_atomic records_overrun; /* Number of overwritten records */
14641deb	97	//wait_queue_head_t read_wait; /* reader buffer-level wait queue */
852c2936	98	int finalized; /* buffer has been finalized */
14641deb MD	99	//struct timer_list switch_timer; /* timer for periodical switch */
14641deb MD	100	//struct timer_list read_timer; /* timer for read poll */
852c2936 MD	101	unsigned long get_subbuf_consumed; /* Read-side consumed */
	102	unsigned long prod_snapshot; /* Producer count snapshot */
	103	unsigned long cons_snapshot; /* Consumer count snapshot */
	104	int get_subbuf:1; /* Sub-buffer being held by reader */
	105	int switch_timer_enabled:1; /* Protected by ring_buffer_nohz_lock */
	106	int read_timer_enabled:1; /* Protected by ring_buffer_nohz_lock */
a6352fd4	107	} ____cacheline_aligned;
852c2936 MD	108
	109	static inline
	110	void channel_get_private(struct channel chan)
	111	{
	112	return chan->backend.priv;
	113	}
	114
	115	/*
	116	* Issue warnings and disable channels upon internal error.
	117	* Can receive struct lib_ring_buffer or struct lib_ring_buffer_backend
	118	* parameters.
	119	*/
	120	#define CHAN_WARN_ON(c, cond) \
	121	({ \
	122	struct channel *__chan; \
	123	int _____ret = unlikely(cond); \
	124	if (_____ret) { \
	125	if (__same_type(*(c), struct channel_backend)) \
14641deb	126	__chan = caa_container_of((void *) (c), \
852c2936 MD	127	struct channel, \
	128	backend); \
	129	else if (__same_type(*(c), struct channel)) \
	130	__chan = (void *) (c); \
	131	else \
	132	BUG_ON(1); \
14641deb	133	uatomic_inc(&__chan->record_disabled); \
852c2936 MD	134	WARN_ON(1); \
	135	} \
	136	_____ret; \
	137	})
	138
	139	#endif /* _LINUX_RING_BUFFER_FRONTEND_TYPES_H */