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

include/xen/interface/io/ring.h

+158 −135

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/******************************************************************************
		* ring.h
		*
		* Shared producer-consumer ring macros.
		*
		* Permission is hereby granted, free of charge, to any person obtaining a copy
		* of this software and associated documentation files (the "Software"), to
		* deal in the Software without restriction, including without limitation the
		* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
		* sell copies of the Software, and to permit persons to whom the Software is
		* furnished to do so, subject to the following conditions:
		*
		* The above copyright notice and this permission notice shall be included in
		* all copies or substantial portions of the Software.
		*
		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
		* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
		* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
		* DEALINGS IN THE SOFTWARE.
		*
		* Tim Deegan and Andrew Warfield November 2004.
		*/

		#ifndef __XEN_PUBLIC_IO_RING_H__
		#define __XEN_PUBLIC_IO_RING_H__

		/*
		* When #include'ing this header, you need to provide the following
		* declaration upfront:
		* - standard integers types (uint8_t, uint16_t, etc)
		* They are provided by stdint.h of the standard headers.
		*
		* In addition, if you intend to use the FLEX macros, you also need to
		* provide the following, before invoking the FLEX macros:
		* - size_t
		* - memcpy
		* - grant_ref_t
		* These declarations are provided by string.h of the standard headers,
		* and grant_table.h from the Xen public headers.
		*/

		#include <xen/interface/grant_table.h>

		typedef unsigned int RING_IDX;
		@@ -30,45 +62,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) \
		@@ -83,7 +112,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 */ \
		}; \
		\
		@@ -101,8 +130,8 @@ struct __name##_back_ring { \
		RING_IDX req_cons; \
		unsigned int nr_ents; \
		struct __name##_sring *sring; \
		};

		}; \
		\
		/*
		* Macros for manipulating rings.
		*
		@@ -122,38 +151,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)
		@@ -172,8 +190,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); \
		@@ -184,22 +201,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) \
		@@ -209,6 +229,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 { \
		virt_wmb(); /* back sees requests /before/ updated producer index */\
		@@ -216,7 +239,7 @@ struct __name##_back_ring { \
		} while (0)

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

		@@ -263,9 +286,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; \
		virt_wmb(); /* front sees responses /before/ updated producer index */ \
		virt_wmb(); /* front sees resps /before/ updated producer index */ \
		(_r)->sring->rsp_prod = __new; \
		virt_mb(); /* front sees new responses /before/ we check rsp_event */ \
		virt_mb(); /* front sees new resps /before/ we check rsp_event */ \
		(_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \
		(RING_IDX)(__new - __old)); \
		} while (0)