iPXE
Macros | Typedefs | Functions
ring.h File Reference
#include "../xen.h"
#include "../xen-compat.h"

Go to the source code of this file.

Macros

#define XENPV_FLEX_ARRAY_DIM   1 /* variable size */
#define xen_mb()
#define xen_rmb()
#define xen_wmb()
#define __RD2(x)
#define __RD4(x)
#define __RD8(x)
#define __RD16(x)
#define __RD32(x)
#define __CONST_RING_SIZE(_s, _sz)
#define __RING_SIZE(_s, _sz)
#define DEFINE_RING_TYPES(__name, __req_t, __rsp_t)
#define SHARED_RING_INIT(_s)
#define FRONT_RING_ATTACH(_r, _s, _i, __size)
#define FRONT_RING_INIT(_r, _s, __size)
#define XEN_FRONT_RING_INIT(r, s, size)
#define BACK_RING_ATTACH(_r, _s, _i, __size)
#define BACK_RING_INIT(_r, _s, __size)
#define RING_SIZE(_r)
#define RING_FREE_REQUESTS(_r)
#define RING_FULL(_r)
#define XEN_RING_NR_UNCONSUMED_RESPONSES(_r)
#define XEN_RING_NR_UNCONSUMED_REQUESTS(_r)
#define RING_HAS_UNCONSUMED_RESPONSES(_r)
#define RING_HAS_UNCONSUMED_REQUESTS(_r)
#define RING_GET_REQUEST(_r, _idx)
#define RING_GET_RESPONSE(_r, _idx)
#define RING_COPY_(type, r, idx, dest)
#define RING_COPY_REQUEST(r, idx, req)
#define RING_COPY_RESPONSE(r, idx, rsp)
#define RING_REQUEST_CONS_OVERFLOW(_r, _cons)
#define RING_REQUEST_PROD_OVERFLOW(_r, _prod)
#define RING_RESPONSE_PROD_OVERFLOW(_r, _prod)
#define RING_PUSH_REQUESTS(_r)
#define RING_PUSH_RESPONSES(_r)
#define RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(_r, _notify)
#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(_r, _notify)
#define RING_FINAL_CHECK_FOR_REQUESTS(_r, _work_to_do)
#define RING_FINAL_CHECK_FOR_RESPONSES(_r, _work_to_do)
#define XEN_PAGE_SHIFT   12
#define XEN_FLEX_RING_SIZE(order)
#define DEFINE_XEN_FLEX_RING(name)
#define DEFINE_XEN_FLEX_RING_AND_INTF(name)

Typedefs

typedef unsigned int RING_IDX

Functions

 FILE_LICENCE (MIT)
 FILE_SECBOOT (PERMITTED)

Macro Definition Documentation

◆ XENPV_FLEX_ARRAY_DIM

#define XENPV_FLEX_ARRAY_DIM   1 /* variable size */

Definition at line 36 of file ring.h.

◆ xen_mb

#define xen_mb ( )
Value:
mb()
mb
void mb(void)
Memory barrier.

Definition at line 42 of file ring.h.

◆ xen_rmb

#define xen_rmb ( )
Value:
rmb()
rmb
#define rmb()
Definition io.h:545

Definition at line 43 of file ring.h.

◆ xen_wmb

#define xen_wmb ( )
Value:
wmb()
wmb
#define wmb()
Definition io.h:546

Definition at line 44 of file ring.h.

◆ __RD2

#define __RD2 ( x)
Value:
(((x) & 0x00000002U) ? 0x2 : ((x) & 0x1))
x
static unsigned int x
Definition pixbuf.h:63

Definition at line 50 of file ring.h.

◆ __RD4

#define __RD4 ( x)
Value:
(((x) & 0x0000000cU) ? __RD2((x) >> 2) << 2 : __RD2(x))
__RD2
#define __RD2(x)
Definition ring.h:50

Definition at line 51 of file ring.h.

◆ __RD8

#define __RD8 ( x)
Value:
(((x) & 0x000000f0U) ? __RD4((x) >> 4) << 4 : __RD4(x))
__RD4
#define __RD4(x)
Definition ring.h:51

Definition at line 52 of file ring.h.

◆ __RD16

#define __RD16 ( x)
Value:
(((x) & 0x0000ff00U) ? __RD8((x) >> 8) << 8 : __RD8(x))
__RD8
#define __RD8(x)
Definition ring.h:52

Definition at line 53 of file ring.h.

◆ __RD32

#define __RD32 ( x)
Value:
(((x) & 0xffff0000U) ? __RD16((x) >> 16) << 16 : __RD16(x))
__RD16
#define __RD16(x)
Definition ring.h:53

Definition at line 54 of file ring.h.

◆ __CONST_RING_SIZE

#define __CONST_RING_SIZE ( _s,
_sz )
Value:
(__RD32(((_sz) - offsetof(struct _s##_sring, ring)) / \
sizeof(((struct _s##_sring *)0)->ring[0])))
__RD32
#define __RD32(x)
Definition ring.h:54
offsetof
#define offsetof(type, field)
Get offset of a field within a structure.
Definition stddef.h:25

Definition at line 62 of file ring.h.

62#define __CONST_RING_SIZE(_s, _sz) \
63 (__RD32(((_sz) - offsetof(struct _s##_sring, ring)) / \
64 sizeof(((struct _s##_sring *)0)->ring[0])))

◆ __RING_SIZE

#define __RING_SIZE ( _s,
_sz )
Value:
(__RD32(((_sz) - (long)(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0])))

Definition at line 68 of file ring.h.

68#define __RING_SIZE(_s, _sz) \
69 (__RD32(((_sz) - (long)(_s)->ring + (long)(_s)) / sizeof((_s)->ring[0])))

◆ DEFINE_RING_TYPES

#define DEFINE_RING_TYPES ( __name,
__req_t,
__rsp_t )

Definition at line 102 of file ring.h.

102#define DEFINE_RING_TYPES(__name, __req_t, __rsp_t) \
103 \
104/* Shared ring entry */ \
105union __name##_sring_entry { \
106 __req_t req; \
107 __rsp_t rsp; \
108}; \
109 \
110/* Shared ring page */ \
111struct __name##_sring { \
112 RING_IDX req_prod, req_event; \
113 RING_IDX rsp_prod, rsp_event; \
114 union { \
115 struct { \
116 uint8_t smartpoll_active; \
117 } netif; \
118 struct { \
119 uint8_t msg; \
120 } tapif_user; \
121 uint8_t pvt_pad[4]; \
122 } pvt; \
123 uint8_t __pad[44]; \
124 union __name##_sring_entry ring[XENPV_FLEX_ARRAY_DIM]; \
125}; \
126 \
127/* "Front" end's private variables */ \
128struct __name##_front_ring { \
129 RING_IDX req_prod_pvt; \
130 RING_IDX rsp_cons; \
131 unsigned int nr_ents; \
132 struct __name##_sring *sring; \
133}; \
134 \
135/* "Back" end's private variables */ \
136struct __name##_back_ring { \
137 RING_IDX rsp_prod_pvt; \
138 RING_IDX req_cons; \
139 unsigned int nr_ents; \
140 struct __name##_sring *sring; \
141}; \
142 \
143/* Syntactic sugar */ \
144typedef struct __name##_sring __name##_sring_t; \
145typedef struct __name##_front_ring __name##_front_ring_t; \
146typedef struct __name##_back_ring __name##_back_ring_t

◆ SHARED_RING_INIT

#define SHARED_RING_INIT ( _s)
Value:
do { \
(_s)->req_prod = (_s)->rsp_prod = 0; \
(_s)->req_event = (_s)->rsp_event = 1; \
(void)memset((_s)->pvt.pvt_pad, 0, sizeof((_s)->pvt.pvt_pad)); \
(void)memset((_s)->__pad, 0, sizeof((_s)->__pad)); \
} while(0)
memset
void * memset(void *dest, int character, size_t len) __nonnull

Definition at line 164 of file ring.h.

164#define SHARED_RING_INIT(_s) do { \
165 (_s)->req_prod = (_s)->rsp_prod = 0; \
166 (_s)->req_event = (_s)->rsp_event = 1; \
167 (void)memset((_s)->pvt.pvt_pad, 0, sizeof((_s)->pvt.pvt_pad)); \
168 (void)memset((_s)->__pad, 0, sizeof((_s)->__pad)); \
169} while(0)

Referenced by netfront_open().

◆ FRONT_RING_ATTACH

#define FRONT_RING_ATTACH ( _r,
_s,
_i,
__size )
Value:
do { \
(_r)->req_prod_pvt = (_i); \
(_r)->rsp_cons = (_i); \
(_r)->nr_ents = __RING_SIZE(_s, __size); \
(_r)->sring = (_s); \
} while (0)
__RING_SIZE
#define __RING_SIZE(_s, _sz)
Definition ring.h:68

Definition at line 171 of file ring.h.

171#define FRONT_RING_ATTACH(_r, _s, _i, __size) do { \
172 (_r)->req_prod_pvt = (_i); \
173 (_r)->rsp_cons = (_i); \
174 (_r)->nr_ents = __RING_SIZE(_s, __size); \
175 (_r)->sring = (_s); \
176} while (0)

◆ FRONT_RING_INIT

#define FRONT_RING_INIT ( _r,
_s,
__size )
Value:
FRONT_RING_ATTACH(_r, _s, 0, __size)
FRONT_RING_ATTACH
#define FRONT_RING_ATTACH(_r, _s, _i, __size)
Definition ring.h:171

Definition at line 178 of file ring.h.

Referenced by netfront_open().

◆ XEN_FRONT_RING_INIT

#define XEN_FRONT_RING_INIT ( r,
s,
size )
Value:
do { \
SHARED_RING_INIT(s); \
FRONT_RING_INIT(r, s, size); \
} while (0)
size
uint16_t size
Buffer size.
Definition dwmac.h:3
r
static const uint8_t r[3][4]
MD4 shift amounts.
Definition md4.c:54

Definition at line 180 of file ring.h.

180#define XEN_FRONT_RING_INIT(r, s, size) do { \
181 SHARED_RING_INIT(s); \
182 FRONT_RING_INIT(r, s, size); \
183} while (0)

◆ BACK_RING_ATTACH

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

Definition at line 185 of file ring.h.

185#define BACK_RING_ATTACH(_r, _s, _i, __size) do { \
186 (_r)->rsp_prod_pvt = (_i); \
187 (_r)->req_cons = (_i); \
188 (_r)->nr_ents = __RING_SIZE(_s, __size); \
189 (_r)->sring = (_s); \
190} while (0)

◆ BACK_RING_INIT

#define BACK_RING_INIT ( _r,
_s,
__size )
Value:
BACK_RING_ATTACH(_r, _s, 0, __size)
BACK_RING_ATTACH
#define BACK_RING_ATTACH(_r, _s, _i, __size)
Definition ring.h:185

Definition at line 192 of file ring.h.

◆ RING_SIZE

#define RING_SIZE ( _r)
Value:
((_r)->nr_ents)

Definition at line 195 of file ring.h.

195#define RING_SIZE(_r) \
196 ((_r)->nr_ents)

◆ RING_FREE_REQUESTS

#define RING_FREE_REQUESTS ( _r)
Value:
(RING_SIZE(_r) - ((_r)->req_prod_pvt - (_r)->rsp_cons))
RING_SIZE
#define RING_SIZE
Definition skge.h:32

Definition at line 199 of file ring.h.

199#define RING_FREE_REQUESTS(_r) \
200 (RING_SIZE(_r) - ((_r)->req_prod_pvt - (_r)->rsp_cons))

◆ RING_FULL

#define RING_FULL ( _r)
Value:
(RING_FREE_REQUESTS(_r) == 0)
RING_FREE_REQUESTS
#define RING_FREE_REQUESTS(_r)
Definition ring.h:199

Definition at line 205 of file ring.h.

205#define RING_FULL(_r) \
206 (RING_FREE_REQUESTS(_r) == 0)

◆ XEN_RING_NR_UNCONSUMED_RESPONSES

#define XEN_RING_NR_UNCONSUMED_RESPONSES ( _r)
Value:
((_r)->sring->rsp_prod - (_r)->rsp_cons)

Definition at line 209 of file ring.h.

209#define XEN_RING_NR_UNCONSUMED_RESPONSES(_r) \
210 ((_r)->sring->rsp_prod - (_r)->rsp_cons)

◆ XEN_RING_NR_UNCONSUMED_REQUESTS

#define XEN_RING_NR_UNCONSUMED_REQUESTS ( _r)
Value:
((((_r)->sring->req_prod - (_r)->req_cons) < \
(RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt))) ? \
((_r)->sring->req_prod - (_r)->req_cons) : \
(RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt)))

Definition at line 221 of file ring.h.

221#define XEN_RING_NR_UNCONSUMED_REQUESTS(_r) \
222 ((((_r)->sring->req_prod - (_r)->req_cons) < \
223 (RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt))) ? \
224 ((_r)->sring->req_prod - (_r)->req_cons) : \
225 (RING_SIZE(_r) - ((_r)->req_cons - (_r)->rsp_prod_pvt)))

◆ RING_HAS_UNCONSUMED_RESPONSES

#define RING_HAS_UNCONSUMED_RESPONSES ( _r)
Value:
XEN_RING_NR_UNCONSUMED_RESPONSES(_r)
XEN_RING_NR_UNCONSUMED_RESPONSES
#define XEN_RING_NR_UNCONSUMED_RESPONSES(_r)
Definition ring.h:209

Definition at line 238 of file ring.h.

Referenced by netfront_poll_rx(), and netfront_poll_tx().

◆ RING_HAS_UNCONSUMED_REQUESTS

#define RING_HAS_UNCONSUMED_REQUESTS ( _r)
Value:
XEN_RING_NR_UNCONSUMED_REQUESTS(_r)
XEN_RING_NR_UNCONSUMED_REQUESTS
#define XEN_RING_NR_UNCONSUMED_REQUESTS(_r)
Definition ring.h:221

Definition at line 239 of file ring.h.

◆ RING_GET_REQUEST

#define RING_GET_REQUEST ( _r,
_idx )
Value:
(&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].req))

Definition at line 243 of file ring.h.

243#define RING_GET_REQUEST(_r, _idx) \
244 (&((_r)->sring->ring[((_idx) & (RING_SIZE(_r) - 1))].req))

Referenced by netfront_refill_rx(), and netfront_transmit().

◆ RING_GET_RESPONSE

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

Definition at line 246 of file ring.h.

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

Referenced by netfront_poll_rx(), and netfront_poll_tx().

◆ RING_COPY_

#define RING_COPY_ ( type,
r,
idx,
dest )
Value:
do { \
/* Use volatile to force the copy into dest. */ \
*(dest) = *(volatile __typeof__(dest))RING_GET_##type(r, idx); \
} while (0)
dest
if(len >=6 *4) __asm__ __volatile__("movsl" if(len >=5 *4) __asm__ __volatile__("movsl" if(len >=4 *4) __asm__ __volatile__("movsl" if(len >=3 *4) __asm__ __volatile__("movsl" if(len >=2 *4) __asm__ __volatile__("movsl" if(len >=1 *4) __asm__ __volatile__("movsl" if((len % 4) >=2) __asm__ __volatile__("movsw" if((len % 2) >=1) __asm__ __volatile__("movsb" retur dest)
Definition string.h:151
type
uint32_t type
Operating system type.
Definition ena.h:1

Definition at line 258 of file ring.h.

258#define RING_COPY_(type, r, idx, dest) do { \
259 /* Use volatile to force the copy into dest. */ \
260 *(dest) = *(volatile __typeof__(dest))RING_GET_##type(r, idx); \
261} while (0)

◆ RING_COPY_REQUEST

#define RING_COPY_REQUEST ( r,
idx,
req )
Value:
RING_COPY_(REQUEST, r, idx, req)
RING_COPY_
#define RING_COPY_(type, r, idx, dest)
Definition ring.h:258

Definition at line 263 of file ring.h.

◆ RING_COPY_RESPONSE

#define RING_COPY_RESPONSE ( r,
idx,
rsp )
Value:
RING_COPY_(RESPONSE, r, idx, rsp)
rsp
uint64_t rsp
Definition librm.h:18

Definition at line 264 of file ring.h.

◆ RING_REQUEST_CONS_OVERFLOW

#define RING_REQUEST_CONS_OVERFLOW ( _r,
_cons )
Value:
(((_cons) - (_r)->rsp_prod_pvt) >= RING_SIZE(_r))

Definition at line 267 of file ring.h.

267#define RING_REQUEST_CONS_OVERFLOW(_r, _cons) \
268 (((_cons) - (_r)->rsp_prod_pvt) >= RING_SIZE(_r))

◆ RING_REQUEST_PROD_OVERFLOW

#define RING_REQUEST_PROD_OVERFLOW ( _r,
_prod )
Value:
(((_prod) - (_r)->rsp_prod_pvt) > RING_SIZE(_r))

Definition at line 271 of file ring.h.

271#define RING_REQUEST_PROD_OVERFLOW(_r, _prod) \
272 (((_prod) - (_r)->rsp_prod_pvt) > RING_SIZE(_r))

◆ RING_RESPONSE_PROD_OVERFLOW

#define RING_RESPONSE_PROD_OVERFLOW ( _r,
_prod )
Value:
(((_prod) - (_r)->rsp_cons) > RING_SIZE(_r))

Definition at line 275 of file ring.h.

275#define RING_RESPONSE_PROD_OVERFLOW(_r, _prod) \
276 (((_prod) - (_r)->rsp_cons) > RING_SIZE(_r))

◆ RING_PUSH_REQUESTS

#define RING_PUSH_REQUESTS ( _r)
Value:
do { \
xen_wmb(); /* back sees requests /before/ updated producer index */ \
(_r)->sring->req_prod = (_r)->req_prod_pvt; \
} while (0)

Definition at line 278 of file ring.h.

278#define RING_PUSH_REQUESTS(_r) do { \
279 xen_wmb(); /* back sees requests /before/ updated producer index */ \
280 (_r)->sring->req_prod = (_r)->req_prod_pvt; \
281} while (0)

◆ RING_PUSH_RESPONSES

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

Definition at line 283 of file ring.h.

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

◆ RING_PUSH_REQUESTS_AND_CHECK_NOTIFY

#define RING_PUSH_REQUESTS_AND_CHECK_NOTIFY ( _r,
_notify )
Value:
do { \
RING_IDX __old = (_r)->sring->req_prod; \
RING_IDX __new = (_r)->req_prod_pvt; \
xen_wmb(); /* back sees requests /before/ updated producer index */ \
(_r)->sring->req_prod = __new; \
xen_mb(); /* back sees new requests /before/ we check req_event */ \
(_notify) = ((RING_IDX)(__new - (_r)->sring->req_event) < \
(RING_IDX)(__new - __old)); \
} while (0)
RING_IDX
unsigned int RING_IDX
Definition ring.h:47

Definition at line 318 of file ring.h.

318#define RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(_r, _notify) do { \
319 RING_IDX __old = (_r)->sring->req_prod; \
320 RING_IDX __new = (_r)->req_prod_pvt; \
321 xen_wmb(); /* back sees requests /before/ updated producer index */ \
322 (_r)->sring->req_prod = __new; \
323 xen_mb(); /* back sees new requests /before/ we check req_event */ \
324 (_notify) = ((RING_IDX)(__new - (_r)->sring->req_event) < \
325 (RING_IDX)(__new - __old)); \
326} while (0)

Referenced by netfront_refill_rx(), and netfront_transmit().

◆ RING_PUSH_RESPONSES_AND_CHECK_NOTIFY

#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY ( _r,
_notify )
Value:
do { \
RING_IDX __old = (_r)->sring->rsp_prod; \
RING_IDX __new = (_r)->rsp_prod_pvt; \
xen_wmb(); /* front sees resps /before/ updated producer index */ \
(_r)->sring->rsp_prod = __new; \
xen_mb(); /* front sees new resps /before/ we check rsp_event */ \
(_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \
(RING_IDX)(__new - __old)); \
} while (0)

Definition at line 328 of file ring.h.

328#define RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(_r, _notify) do { \
329 RING_IDX __old = (_r)->sring->rsp_prod; \
330 RING_IDX __new = (_r)->rsp_prod_pvt; \
331 xen_wmb(); /* front sees resps /before/ updated producer index */ \
332 (_r)->sring->rsp_prod = __new; \
333 xen_mb(); /* front sees new resps /before/ we check rsp_event */ \
334 (_notify) = ((RING_IDX)(__new - (_r)->sring->rsp_event) < \
335 (RING_IDX)(__new - __old)); \
336} while (0)

◆ RING_FINAL_CHECK_FOR_REQUESTS

#define RING_FINAL_CHECK_FOR_REQUESTS ( _r,
_work_to_do )
Value:
do { \
(_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
if (_work_to_do) break; \
(_r)->sring->req_event = (_r)->req_cons + 1; \
xen_mb(); \
(_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
} while (0)
RING_HAS_UNCONSUMED_REQUESTS
#define RING_HAS_UNCONSUMED_REQUESTS(_r)
Definition ring.h:239

Definition at line 338 of file ring.h.

338#define RING_FINAL_CHECK_FOR_REQUESTS(_r, _work_to_do) do { \
339 (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
340 if (_work_to_do) break; \
341 (_r)->sring->req_event = (_r)->req_cons + 1; \
342 xen_mb(); \
343 (_work_to_do) = RING_HAS_UNCONSUMED_REQUESTS(_r); \
344} while (0)

◆ RING_FINAL_CHECK_FOR_RESPONSES

#define RING_FINAL_CHECK_FOR_RESPONSES ( _r,
_work_to_do )
Value:
do { \
(_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
if (_work_to_do) break; \
(_r)->sring->rsp_event = (_r)->rsp_cons + 1; \
xen_mb(); \
(_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
} while (0)
RING_HAS_UNCONSUMED_RESPONSES
#define RING_HAS_UNCONSUMED_RESPONSES(_r)
Definition ring.h:238

Definition at line 346 of file ring.h.

346#define RING_FINAL_CHECK_FOR_RESPONSES(_r, _work_to_do) do { \
347 (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
348 if (_work_to_do) break; \
349 (_r)->sring->rsp_event = (_r)->rsp_cons + 1; \
350 xen_mb(); \
351 (_work_to_do) = RING_HAS_UNCONSUMED_RESPONSES(_r); \
352} while (0)

◆ XEN_PAGE_SHIFT

#define XEN_PAGE_SHIFT   12

Definition at line 401 of file ring.h.

◆ XEN_FLEX_RING_SIZE

#define XEN_FLEX_RING_SIZE ( order)
Value:
(1UL << ((order) + XEN_PAGE_SHIFT - 1))
XEN_PAGE_SHIFT
#define XEN_PAGE_SHIFT
Definition ring.h:401

Definition at line 403 of file ring.h.

403#define XEN_FLEX_RING_SIZE(order) \
404 (1UL << ((order) + XEN_PAGE_SHIFT - 1))

◆ DEFINE_XEN_FLEX_RING

#define DEFINE_XEN_FLEX_RING ( name)

Definition at line 406 of file ring.h.

406#define DEFINE_XEN_FLEX_RING(name) \
407static inline RING_IDX name##_mask(RING_IDX idx, RING_IDX ring_size) \
408{ \
409 return idx & (ring_size - 1); \
410} \
411 \
412static inline unsigned char *name##_get_ring_ptr(unsigned char *buf, \
413 RING_IDX idx, \
414 RING_IDX ring_size) \
415{ \
416 return buf + name##_mask(idx, ring_size); \
417} \
418 \
419static inline void name##_read_packet(void *opaque, \
420 const unsigned char *buf, \
421 size_t size, \
422 RING_IDX masked_prod, \
423 RING_IDX *masked_cons, \
424 RING_IDX ring_size) \
425{ \
426 if (*masked_cons < masked_prod || \
427 size <= ring_size - *masked_cons) { \
428 memcpy(opaque, buf + *masked_cons, size); \
429 } else { \
430 memcpy(opaque, buf + *masked_cons, ring_size - *masked_cons); \
431 memcpy((unsigned char *)opaque + ring_size - *masked_cons, buf, \
432 size - (ring_size - *masked_cons)); \
433 } \
434 *masked_cons = name##_mask(*masked_cons + size, ring_size); \
435} \
436 \
437static inline void name##_write_packet(unsigned char *buf, \
438 const void *opaque, \
439 size_t size, \
440 RING_IDX *masked_prod, \
441 RING_IDX masked_cons, \
442 RING_IDX ring_size) \
443{ \
444 if (*masked_prod < masked_cons || \
445 size <= ring_size - *masked_prod) { \
446 memcpy(buf + *masked_prod, opaque, size); \
447 } else { \
448 memcpy(buf + *masked_prod, opaque, ring_size - *masked_prod); \
449 memcpy(buf, (unsigned char *)opaque + (ring_size - *masked_prod), \
450 size - (ring_size - *masked_prod)); \
451 } \
452 *masked_prod = name##_mask(*masked_prod + size, ring_size); \
453} \
454 \
455static inline RING_IDX name##_queued(RING_IDX prod, \
456 RING_IDX cons, \
457 RING_IDX ring_size) \
458{ \
459 RING_IDX size; \
460 \
461 if (prod == cons) \
462 return 0; \
463 \
464 prod = name##_mask(prod, ring_size); \
465 cons = name##_mask(cons, ring_size); \
466 \
467 if (prod == cons) \
468 return ring_size; \
469 \
470 if (prod > cons) \
471 size = prod - cons; \
472 else \
473 size = ring_size - (cons - prod); \
474 return size; \
475} \
476 \
477struct name##_data { \
478 unsigned char *in; /* half of the allocation */ \
479 unsigned char *out; /* half of the allocation */ \
480}

◆ DEFINE_XEN_FLEX_RING_AND_INTF

#define DEFINE_XEN_FLEX_RING_AND_INTF ( name)
Value:
struct name##_data_intf { \
RING_IDX in_cons, in_prod; \
\
uint8_t pad1[56]; \
\
RING_IDX out_cons, out_prod; \
\
uint8_t pad2[56]; \
\
RING_IDX ring_order; \
grant_ref_t ref[XEN_FLEX_ARRAY_DIM]; \
}; \
DEFINE_XEN_FLEX_RING(name)
uint8_t
unsigned char uint8_t
Definition stdint.h:10
name
const char * name
Definition ath9k_hw.c:1986
pad2
uint8_t pad2[3]
Unused.
Definition bzimage.h:58
pad1
uint16_t pad1
Unused.
Definition bzimage.h:48
grant_ref_t
uint32_t grant_ref_t
Definition grant_table.h:100
XEN_FLEX_ARRAY_DIM
#define XEN_FLEX_ARRAY_DIM
Definition xen.h:52
ref
static const char grant_ref_t ref
Definition netfront.h:93

Definition at line 482 of file ring.h.

482#define DEFINE_XEN_FLEX_RING_AND_INTF(name) \
483struct name##_data_intf { \
484 RING_IDX in_cons, in_prod; \
485 \
486 uint8_t pad1[56]; \
487 \
488 RING_IDX out_cons, out_prod; \
489 \
490 uint8_t pad2[56]; \
491 \
492 RING_IDX ring_order; \
493 grant_ref_t ref[XEN_FLEX_ARRAY_DIM]; \
494}; \
495DEFINE_XEN_FLEX_RING(name)

Typedef Documentation

◆ RING_IDX

typedef unsigned int RING_IDX

Definition at line 47 of file ring.h.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( MIT )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )
Generated by doxygen 1.14.0