xen: sync include/xen/interface/io/ring.h with Xen's newest version (4f5a2093) · Commits · e / devices / android_kernel_sony_msm8998

include/xen/interface/io/ring.h

+124 −133

Original line number	Diff line number	Diff line
		@@ -27,45 +27,42 @@ typedef unsigned int RING_IDX;
		#define __CONST_RING_SIZE(_s, _sz) \
		(__RD32(((_sz) - offsetof(struct _s##_sring, ring)) / \
		sizeof(((struct _s##_sring *)0)->ring[0])))

		/*
		* The same for passing in an actual pointer instead of a name tag.
		*/
		#define __RING_SIZE(_s, _sz) \
		(__RD32(((_sz) - (long)&(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0])))
		(__RD32(((_sz) - (long)(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0])))

		/*
		* Macros to make the correct C datatypes for a new kind of ring.
		*
		* To make a new ring datatype, you need to have two message structures,
		* let's say struct request, and struct response already defined.
		* let's say request_t, and response_t already defined.
		*
		* In a header where you want the ring datatype declared, you then do:
		*
		* DEFINE_RING_TYPES(mytag, struct request, struct response);
		* DEFINE_RING_TYPES(mytag, request_t, response_t);
		*
		* These expand out to give you a set of types, as you can see below.
		* The most important of these are:
		*
		* struct mytag_sring - The shared ring.
		* struct mytag_front_ring - The 'front' half of the ring.
		* struct mytag_back_ring - The 'back' half of the ring.
		* mytag_sring_t - The shared ring.
		* mytag_front_ring_t - The 'front' half of the ring.
		* mytag_back_ring_t - The 'back' half of the ring.
		*
		* To initialize a ring in your code you need to know the location and size
		* of the shared memory area (PAGE_SIZE, for instance). To initialise
		* the front half:
		*
		* struct mytag_front_ring front_ring;
		* SHARED_RING_INIT((struct mytag_sring *)shared_page);
		* FRONT_RING_INIT(&front_ring, (struct mytag_sring *)shared_page,
		* PAGE_SIZE);
		* mytag_front_ring_t front_ring;
		* SHARED_RING_INIT((mytag_sring_t *)shared_page);
		* FRONT_RING_INIT(&front_ring, (mytag_sring_t *)shared_page, PAGE_SIZE);
		*
		* Initializing the back follows similarly (note that only the front
		* initializes the shared ring):
		*
		* struct mytag_back_ring back_ring;
		* BACK_RING_INIT(&back_ring, (struct mytag_sring *)shared_page,
		* PAGE_SIZE);
		* mytag_back_ring_t back_ring;
		* BACK_RING_INIT(&back_ring, (mytag_sring_t *)shared_page, PAGE_SIZE);
		*/

		#define DEFINE_RING_TYPES(__name, __req_t, __rsp_t) \
		@@ -80,7 +77,7 @@ union __name##_sring_entry { \
		struct __name##_sring { \
		RING_IDX req_prod, req_event; \
		RING_IDX rsp_prod, rsp_event; \
		uint8_t pad[48]; \
		uint8_t __pad[48]; \
		union __name##_sring_entry ring[1]; /* variable-length */ \
		}; \
		\
		@@ -98,8 +95,8 @@ struct __name##_back_ring { \
		RING_IDX req_cons; \
		unsigned int nr_ents; \
		struct __name##_sring *sring; \
		};

		}; \
		\
		/*
		* Macros for manipulating rings.
		*
		@@ -119,38 +116,27 @@ struct __name##_back_ring { \
		#define SHARED_RING_INIT(_s) do { \
		(_s)->req_prod = (_s)->rsp_prod = 0; \
		(_s)->req_event = (_s)->rsp_event = 1; \
		memset((_s)->pad, 0, sizeof((_s)->pad)); \
		(void)memset((_s)->__pad, 0, sizeof((_s)->__pad)); \
		} while(0)

		#define FRONT_RING_INIT(_r, _s, __size) do { \
		(_r)->req_prod_pvt = 0; \
		(_r)->rsp_cons = 0; \
		#define FRONT_RING_ATTACH(_r, _s, _i, __size) do { \
		(_r)->req_prod_pvt = (_i); \
		(_r)->rsp_cons = (_i); \
		(_r)->nr_ents = __RING_SIZE(_s, __size); \
		(_r)->sring = (_s); \
		} while (0)

		#define BACK_RING_INIT(_r, _s, __size) do { \
		(_r)->rsp_prod_pvt = 0; \
		(_r)->req_cons = 0; \
		(_r)->nr_ents = __RING_SIZE(_s, __size); \
		(_r)->sring = (_s); \
		} while (0)
		#define FRONT_RING_INIT(_r, _s, __size) FRONT_RING_ATTACH(_r, _s, 0, __size)

		/* Initialize to existing shared indexes -- for recovery */
		#define FRONT_RING_ATTACH(_r, _s, __size) do { \
		(_r)->sring = (_s); \
		(_r)->req_prod_pvt = (_s)->req_prod; \
		(_r)->rsp_cons = (_s)->rsp_prod; \
		#define BACK_RING_ATTACH(_r, _s, _i, __size) do { \
		(_r)->rsp_prod_pvt = (_i); \
		(_r)->req_cons = (_i); \
		(_r)->nr_ents = __RING_SIZE(_s, __size); \
		} while (0)

		#define BACK_RING_ATTACH(_r, _s, __size) do { \
		(_r)->sring = (_s); \
		(_r)->rsp_prod_pvt = (_s)->rsp_prod; \
		(_r)->req_cons = (_s)->req_prod; \
		(_r)->nr_ents = __RING_SIZE(_s, __size); \
		} while (0)

		#define BACK_RING_INIT(_r, _s, __size) BACK_RING_ATTACH(_r, _s, 0, __size)

		/* How big is this ring? */
		#define RING_SIZE(_r) \
		((_r)->nr_ents)
		@@ -169,8 +155,7 @@ struct __name##_back_ring { \
		#define RING_HAS_UNCONSUMED_RESPONSES(_r) \
		((_r)->sring->rsp_prod - (_r)->rsp_cons)

		#define RING_HAS_UNCONSUMED_REQUESTS(_r) \
		({ \
		#define RING_HAS_UNCONSUMED_REQUESTS(_r) ({ \
		unsigned int req = (_r)->sring->req_prod - (_r)->req_cons; \
		unsigned int rsp = RING_SIZE(_r) - \
		((_r)->req_cons - (_r)->rsp_prod_pvt); \
		@@ -181,22 +166,25 @@ struct __name##_back_ring { \
		#define RING_GET_REQUEST(_r, _idx) \
		(&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].req))

		#define RING_GET_RESPONSE(_r, _idx) \
		(&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].rsp))

		/*
		* Get a local copy of a request.
		* Get a local copy of a request/response.
		*
		* Use this in preference to RING_GET_REQUEST() so all processing is
		* Use this in preference to RING_GET_{REQUEST,RESPONSE}() so all processing is
		* done on a local copy that cannot be modified by the other end.
		*
		* Note that https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58145 may cause this
		* to be ineffective where _req is a struct which consists of only bitfields.
		* to be ineffective where dest is a struct which consists of only bitfields.
		*/
		#define RING_COPY_REQUEST(_r, _idx, _req) do { \
		/* Use volatile to force the copy into _req. */ \
		(_req) = (volatile typeof(_req))RING_GET_REQUEST(_r, _idx); \
		#define RING_COPY_(type, r, idx, dest) do { \
		/* Use volatile to force the copy into dest. */ \
		(dest) = (volatile typeof(dest))RING_GET_##type(r, idx); \
		} while (0)

		#define RING_GET_RESPONSE(_r, _idx) \
		(&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].rsp))
		#define RING_COPY_REQUEST(r, idx, req) RING_COPY_(REQUEST, r, idx, req)
		#define RING_COPY_RESPONSE(r, idx, rsp) RING_COPY_(RESPONSE, r, idx, rsp)

		/* Loop termination condition: Would the specified index overflow the ring? */
		#define RING_REQUEST_CONS_OVERFLOW(_r, _cons) \
		@@ -206,6 +194,9 @@ struct __name##_back_ring { \
		#define RING_REQUEST_PROD_OVERFLOW(_r, _prod) \
		(((_prod) - (_r)->rsp_prod_pvt) > RING_SIZE(_r))

		/* Ill-behaved backend determination: Can there be this many responses? */
		#define RING_RESPONSE_PROD_OVERFLOW(_r, _prod) \
		(((_prod) - (_r)->rsp_cons) > RING_SIZE(_r))

		#define RING_PUSH_REQUESTS(_r) do { \
		wmb(); /* back sees requests /before/ updated producer index */ \
		@@ -213,7 +204,7 @@ struct __name##_back_ring { \
		} while (0)

		#define RING_PUSH_RESPONSES(_r) do { \
		wmb(); /* front sees responses /before/ updated producer index */ \
		wmb(); /* front sees resps /before/ updated producer index */ \
		(_r)->sring->rsp_prod = (_r)->rsp_prod_pvt; \
		} while (0)

		@@ -260,9 +251,9 @@ struct __name##_back_ring { \
		#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(_r, _notify) do { \
		RING_IDX __old = (_r)->sring->rsp_prod; \
		RING_IDX __new = (_r)->rsp_prod_pvt; \
		wmb(); /* front sees responses /before/ updated producer index */ \
		wmb(); /* front sees resps /before/ updated producer index */ \
		(_r)->sring->rsp_prod = __new; \
		mb(); /* front sees new responses /before/ we check rsp_event */ \
		mb(); /* front sees new resps /before/ we check rsp_event */ \
		(_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \
		(RING_IDX)(__new - __old)); \
		} while (0)