intnetinline.h@ 69206

Last change on this file since 69206 was 69107, checked in by vboxsync, 7 years ago
include/VBox/: (C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.8 KB

Line
1	/* $Id: intnetinline.h 69107 2017-10-17 10:53:48Z vboxsync $ */
2	/** @file
3	* INTNET - Internal Networking, Inlined Code. (DEV,++)
4	*
5	* This is all inlined because it's too tedious to create 2-3 libraries to
6	* contain it all. Large parts of this header is only accessible from C++
7	* sources because of mixed code and variables.
8	*/
9
10	/*
11	* Copyright (C) 2006-2017 Oracle Corporation
12	*
13	* This file is part of VirtualBox Open Source Edition (OSE), as
14	* available from http://www.virtualbox.org. This file is free software;
15	* you can redistribute it and/or modify it under the terms of the GNU
16	* General Public License (GPL) as published by the Free Software
17	* Foundation, in version 2 as it comes in the "COPYING" file of the
18	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20	*
21	* The contents of this file may alternatively be used under the terms
22	* of the Common Development and Distribution License Version 1.0
23	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
24	* VirtualBox OSE distribution, in which case the provisions of the
25	* CDDL are applicable instead of those of the GPL.
26	*
27	* You may elect to license modified versions of this file under the
28	* terms and conditions of either the GPL or the CDDL or both.
29	*/
30
31	#ifndef ___VBox_intnetinline_h
32	#define ___VBox_intnetinline_h
33
34	#include <VBox/intnet.h>
35	#include <iprt/string.h>
36	#include <iprt/assert.h>
37	#include <iprt/err.h>
38	#include <VBox/log.h>
39
40
41
42	/**
43	* Valid internal networking frame type.
44	*
45	* @returns true / false.
46	* @param u8Type The frame type to check.
47	*/
48	DECLINLINE(bool) IntNetIsValidFrameType(uint8_t u8Type)
49	{
50	if (RT_LIKELY( u8Type == INTNETHDR_TYPE_FRAME
51	\|\| u8Type == INTNETHDR_TYPE_GSO
52	\|\| u8Type == INTNETHDR_TYPE_PADDING))
53	return true;
54	return false;
55	}
56
57
58	/**
59	* Partly initializes a scatter / gather buffer, leaving the segments to the
60	* caller.
61	*
62	* @returns Pointer to the start of the frame.
63	* @param pSG Pointer to the scatter / gather structure.
64	* @param cbTotal The total size.
65	* @param cSegs The number of segments.
66	* @param cSegsUsed The number of used segments.
67	*/
68	DECLINLINE(void) IntNetSgInitTempSegs(PINTNETSG pSG, uint32_t cbTotal, unsigned cSegs, unsigned cSegsUsed)
69	{
70	pSG->pvOwnerData = NULL;
71	pSG->pvUserData = NULL;
72	pSG->pvUserData2 = NULL;
73	pSG->cbTotal = cbTotal;
74	pSG->cUsers = 1;
75	pSG->fFlags = INTNETSG_FLAGS_TEMP;
76	pSG->GsoCtx.u8Type = (uint8_t)PDMNETWORKGSOTYPE_INVALID;
77	pSG->GsoCtx.cbHdrsTotal = 0;
78	pSG->GsoCtx.cbHdrsSeg = 0;
79	pSG->GsoCtx.cbMaxSeg= 0;
80	pSG->GsoCtx.offHdr1 = 0;
81	pSG->GsoCtx.offHdr2 = 0;
82	pSG->GsoCtx.u8Unused= 0;
83	#if ARCH_BITS == 64
84	pSG->uPadding = 0;
85	#endif
86	pSG->cSegsAlloc = (uint16_t)cSegs;
87	Assert(pSG->cSegsAlloc == cSegs);
88	pSG->cSegsUsed = (uint16_t)cSegsUsed;
89	Assert(pSG->cSegsUsed == cSegsUsed);
90	Assert(cSegs >= cSegsUsed);
91	}
92
93
94	/**
95	* Partly initializes a scatter / gather buffer w/ GSO, leaving the segments to
96	* the caller.
97	*
98	* @returns Pointer to the start of the frame.
99	* @param pSG Pointer to the scatter / gather structure.
100	* @param cbTotal The total size.
101	* @param cSegs The number of segments.
102	* @param cSegsUsed The number of used segments.
103	* @param pGso The GSO context.
104	*/
105	DECLINLINE(void) IntNetSgInitTempSegsGso(PINTNETSG pSG, uint32_t cbTotal, unsigned cSegs,
106	unsigned cSegsUsed, PCPDMNETWORKGSO pGso)
107	{
108	pSG->pvOwnerData = NULL;
109	pSG->pvUserData = NULL;
110	pSG->pvUserData2 = NULL;
111	pSG->cbTotal = cbTotal;
112	pSG->cUsers = 1;
113	pSG->fFlags = INTNETSG_FLAGS_TEMP;
114	pSG->GsoCtx.u8Type = pGso->u8Type;
115	pSG->GsoCtx.cbHdrsTotal = pGso->cbHdrsTotal;
116	pSG->GsoCtx.cbHdrsSeg = pGso->cbHdrsSeg;
117	pSG->GsoCtx.cbMaxSeg= pGso->cbMaxSeg;
118	pSG->GsoCtx.offHdr1 = pGso->offHdr1;
119	pSG->GsoCtx.offHdr2 = pGso->offHdr2;
120	pSG->GsoCtx.u8Unused= 0;
121	#if ARCH_BITS == 64
122	pSG->uPadding = 0;
123	#endif
124	pSG->cSegsAlloc = (uint16_t)cSegs;
125	Assert(pSG->cSegsAlloc == cSegs);
126	pSG->cSegsUsed = (uint16_t)cSegsUsed;
127	Assert(pSG->cSegsUsed == cSegsUsed);
128	Assert(cSegs >= cSegsUsed);
129	}
130
131
132
133	/**
134	* Initializes a scatter / gather buffer describing a simple linear buffer.
135	*
136	* @returns Pointer to the start of the frame.
137	* @param pSG Pointer to the scatter / gather structure.
138	* @param pvFrame Pointer to the frame
139	* @param cbFrame The size of the frame.
140	*/
141	DECLINLINE(void) IntNetSgInitTemp(PINTNETSG pSG, void *pvFrame, uint32_t cbFrame)
142	{
143	IntNetSgInitTempSegs(pSG, cbFrame, 1, 1);
144	pSG->aSegs[0].Phys = NIL_RTHCPHYS;
145	pSG->aSegs[0].pv = pvFrame;
146	pSG->aSegs[0].cb = cbFrame;
147	}
148
149	/**
150	* Initializes a scatter / gather buffer describing a simple linear buffer.
151	*
152	* @returns Pointer to the start of the frame.
153	* @param pSG Pointer to the scatter / gather structure.
154	* @param pvFrame Pointer to the frame
155	* @param cbFrame The size of the frame.
156	* @param pGso The GSO context.
157	*/
158	DECLINLINE(void) IntNetSgInitTempGso(PINTNETSG pSG, void *pvFrame, uint32_t cbFrame, PCPDMNETWORKGSO pGso)
159	{
160	IntNetSgInitTempSegsGso(pSG, cbFrame, 1, 1, pGso);
161	pSG->aSegs[0].Phys = NIL_RTHCPHYS;
162	pSG->aSegs[0].pv = pvFrame;
163	pSG->aSegs[0].cb = cbFrame;
164	}
165
166
167	/**
168	* Reads an entire SG into a fittingly size buffer.
169	*
170	* @param pSG The SG list to read.
171	* @param pvBuf The buffer to read into (at least pSG->cbTotal in size).
172	*/
173	DECLINLINE(void) IntNetSgRead(PCINTNETSG pSG, void *pvBuf)
174	{
175	memcpy(pvBuf, pSG->aSegs[0].pv, pSG->aSegs[0].cb);
176	if (pSG->cSegsUsed == 1)
177	Assert(pSG->cbTotal == pSG->aSegs[0].cb);
178	else
179	{
180	uint8_t pbDst = (uint8_t )pvBuf + pSG->aSegs[0].cb;
181	unsigned iSeg = 0;
182	unsigned const cSegs = pSG->cSegsUsed;
183	while (++iSeg < cSegs)
184	{
185	uint32_t cbSeg = pSG->aSegs[iSeg].cb;
186	Assert((uintptr_t)pbDst - (uintptr_t)pvBuf + cbSeg <= pSG->cbTotal);
187	memcpy(pbDst, pSG->aSegs[iSeg].pv, cbSeg);
188	pbDst += cbSeg;
189	}
190	}
191	}
192
193
194	/**
195	* Reads a portion of an SG into a buffer.
196	*
197	* @param pSG The SG list to read.
198	* @param offSrc The offset to start start copying from.
199	* @param cbToRead The number of bytes to copy.
200	* @param pvBuf The buffer to read into, cb or more in size.
201	*/
202	DECLINLINE(void) IntNetSgReadEx(PCINTNETSG pSG, uint32_t offSrc, uint32_t cbToRead, void *pvBuf)
203	{
204	uint8_t pbDst = (uint8_t )pvBuf;
205	uint32_t iSeg = 0;
206
207	/* validate assumptions */
208	Assert(cbToRead <= pSG->cbTotal);
209	Assert(offSrc <= pSG->cbTotal);
210	Assert(offSrc + cbToRead <= pSG->cbTotal);
211
212	/* Find the right segment and copy any bits from within the segment. */
213	while (offSrc)
214	{
215	uint32_t cbSeg = pSG->aSegs[iSeg].cb;
216	if (offSrc < cbSeg)
217	{
218	uint32_t cbChunk = cbSeg - offSrc;
219	if (cbChunk >= cbToRead)
220	{
221	memcpy(pbDst, (uint8_t const *)pSG->aSegs[iSeg].pv + offSrc, cbToRead);
222	return;
223	}
224
225	memcpy(pbDst, (uint8_t const *)pSG->aSegs[iSeg].pv + offSrc, cbChunk);
226	pbDst += cbChunk;
227	cbToRead -= cbChunk;
228	break;
229	}
230
231	/* advance */
232	offSrc -= cbSeg;
233	iSeg++;
234	}
235
236	/* We're not at the start of a segment, copy until we're done. */
237	for (;;)
238	{
239	uint32_t cbSeg = pSG->aSegs[iSeg].cb;
240	if (cbSeg >= cbToRead)
241	{
242	memcpy(pbDst, pSG->aSegs[iSeg].pv, cbToRead);
243	return;
244	}
245
246	memcpy(pbDst, pSG->aSegs[iSeg].pv, cbSeg);
247	pbDst += cbSeg;
248	cbToRead -= cbSeg;
249	iSeg++;
250	Assert(iSeg < pSG->cSegsUsed);
251	}
252	}
253
254	#ifdef __cplusplus
255
256	/**
257	* Get the amount of space available for writing.
258	*
259	* @returns Number of available bytes.
260	* @param pRingBuf The ring buffer.
261	*/
262	DECLINLINE(uint32_t) IntNetRingGetWritable(PINTNETRINGBUF pRingBuf)
263	{
264	uint32_t const offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
265	uint32_t const offWriteInt = ASMAtomicUoReadU32(&pRingBuf->offWriteInt);
266	return offRead <= offWriteInt
267	? pRingBuf->offEnd - offWriteInt + offRead - pRingBuf->offStart - 1
268	: offRead - offWriteInt - 1;
269	}
270
271
272	/**
273	* Checks if the ring has more for us to read.
274	*
275	* @returns Number of ready bytes.
276	* @param pRingBuf The ring buffer.
277	*/
278	DECLINLINE(bool) IntNetRingHasMoreToRead(PINTNETRINGBUF pRingBuf)
279	{
280	uint32_t const offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
281	uint32_t const offWriteCom = ASMAtomicUoReadU32(&pRingBuf->offWriteCom);
282	return offRead != offWriteCom;
283	}
284
285
286	/**
287	* Gets the next frame to read.
288	*
289	* @returns Pointer to the next frame. NULL if done.
290	* @param pRingBuf The ring buffer.
291	*/
292	DECLINLINE(PINTNETHDR) IntNetRingGetNextFrameToRead(PINTNETRINGBUF pRingBuf)
293	{
294	uint32_t const offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
295	uint32_t const offWriteCom = ASMAtomicUoReadU32(&pRingBuf->offWriteCom);
296	if (offRead == offWriteCom)
297	return NULL;
298	return (PINTNETHDR)((uint8_t *)pRingBuf + offRead);
299	}
300
301
302	/**
303	* Get the amount of data ready for reading.
304	*
305	* @returns Number of ready bytes.
306	* @param pRingBuf The ring buffer.
307	*/
308	DECLINLINE(uint32_t) IntNetRingGetReadable(PINTNETRINGBUF pRingBuf)
309	{
310	uint32_t const offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
311	uint32_t const offWriteCom = ASMAtomicUoReadU32(&pRingBuf->offWriteCom);
312	return offRead <= offWriteCom
313	? offWriteCom - offRead
314	: pRingBuf->offEnd - offRead + offWriteCom - pRingBuf->offStart;
315	}
316
317
318	/**
319	* Calculates the pointer to the frame.
320	*
321	* @returns Pointer to the start of the frame.
322	* @param pHdr Pointer to the packet header
323	* @param pBuf The buffer the header is within. Only used in strict builds.
324	*/
325	DECLINLINE(void *) IntNetHdrGetFramePtr(PCINTNETHDR pHdr, PCINTNETBUF pBuf)
326	{
327	uint8_t pu8 = (uint8_t )pHdr + pHdr->offFrame;
328	#ifdef VBOX_STRICT
329	const uintptr_t off = (uintptr_t)pu8 - (uintptr_t)pBuf;
330	Assert(IntNetIsValidFrameType(pHdr->u8Type));
331	Assert(off < pBuf->cbBuf);
332	Assert(off + pHdr->cbFrame <= pBuf->cbBuf);
333	#endif
334	NOREF(pBuf);
335	return pu8;
336	}
337
338
339	/**
340	* Calculates the pointer to the GSO context.
341	*
342	* ASSUMES the frame is a GSO frame.
343	*
344	* The GSO context is immediately followed by the headers and payload. The size
345	* is INTNETBUF::cbFrame - sizeof(PDMNETWORKGSO).
346	*
347	* @returns Pointer to the GSO context.
348	* @param pHdr Pointer to the packet header
349	* @param pBuf The buffer the header is within. Only used in strict builds.
350	*/
351	DECLINLINE(PPDMNETWORKGSO) IntNetHdrGetGsoContext(PCINTNETHDR pHdr, PCINTNETBUF pBuf)
352	{
353	PPDMNETWORKGSO pGso = (PPDMNETWORKGSO)((uint8_t *)pHdr + pHdr->offFrame);
354	#ifdef VBOX_STRICT
355	const uintptr_t off = (uintptr_t)pGso - (uintptr_t)pBuf;
356	Assert(pHdr->u8Type == INTNETHDR_TYPE_GSO);
357	Assert(off < pBuf->cbBuf);
358	Assert(off + pHdr->cbFrame <= pBuf->cbBuf);
359	#endif
360	NOREF(pBuf);
361	return pGso;
362	}
363
364
365	/**
366	* Skips to the next (read) frame in the buffer.
367	*
368	* @param pRingBuf The ring buffer in question.
369	*/
370	DECLINLINE(void) IntNetRingSkipFrame(PINTNETRINGBUF pRingBuf)
371	{
372	uint32_t const offReadOld = ASMAtomicUoReadU32(&pRingBuf->offReadX);
373	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offReadOld);
374	Assert(offReadOld >= pRingBuf->offStart);
375	Assert(offReadOld < pRingBuf->offEnd);
376	Assert(RT_ALIGN_PT(pHdr, INTNETHDR_ALIGNMENT, INTNETHDR *) == pHdr);
377	Assert(IntNetIsValidFrameType(pHdr->u8Type));
378
379	/* skip the frame */
380	uint32_t offReadNew = offReadOld + pHdr->offFrame + pHdr->cbFrame;
381	offReadNew = RT_ALIGN_32(offReadNew, INTNETHDR_ALIGNMENT);
382	Assert(offReadNew <= pRingBuf->offEnd && offReadNew >= pRingBuf->offStart);
383	if (offReadNew >= pRingBuf->offEnd)
384	offReadNew = pRingBuf->offStart;
385	Log2(("IntNetRingSkipFrame: offReadX: %#x -> %#x (1)\n", offReadOld, offReadNew));
386	#ifdef INTNET_POISON_READ_FRAMES
387	memset((uint8_t *)pHdr + pHdr->offFrame, 0xfe, RT_ALIGN_32(pHdr->cbFrame, INTNETHDR_ALIGNMENT));
388	memset(pHdr, 0xef, sizeof(*pHdr));
389	#endif
390	ASMAtomicWriteU32(&pRingBuf->offReadX, offReadNew);
391	}
392
393
394	/**
395	* Allocates a frame in the specified ring.
396	*
397	* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW.
398	* @param pRingBuf The ring buffer.
399	* @param cbFrame The frame size.
400	* @param u8Type The header type.
401	* @param ppHdr Where to return the frame header.
402	* Don't touch this!
403	* @param ppvFrame Where to return the frame pointer.
404	*/
405	DECLINLINE(int) intnetRingAllocateFrameInternal(PINTNETRINGBUF pRingBuf, uint32_t cbFrame, uint8_t u8Type,
406	PINTNETHDR ppHdr, void *ppvFrame)
407	{
408	/*
409	* Validate input and adjust the input.
410	*/
411	INTNETRINGBUF_ASSERT_SANITY(pRingBuf);
412	Assert(cbFrame >= sizeof(RTMAC) * 2);
413
414	const uint32_t cb = RT_ALIGN_32(cbFrame, INTNETHDR_ALIGNMENT);
415	uint32_t offWriteInt = ASMAtomicUoReadU32(&pRingBuf->offWriteInt);
416	uint32_t offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
417	if (offRead <= offWriteInt)
418	{
419	/*
420	* Try fit it all before the end of the buffer.
421	*/
422	if (pRingBuf->offEnd - offWriteInt >= cb + sizeof(INTNETHDR))
423	{
424	uint32_t offNew = offWriteInt + cb + sizeof(INTNETHDR);
425	if (offNew >= pRingBuf->offEnd)
426	offNew = pRingBuf->offStart;
427	if (RT_LIKELY(ASMAtomicCmpXchgU32(&pRingBuf->offWriteInt, offNew, offWriteInt)))
428	{ /* likely / } else return VERR_WRONG_ORDER; / race */
429	Log2(("intnetRingAllocateFrameInternal: offWriteInt: %#x -> %#x (1) (R=%#x T=%#x S=%#x)\n", offWriteInt, offNew, offRead, u8Type, cbFrame));
430
431	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offWriteInt);
432	pHdr->u8Type = u8Type;
433	pHdr->cbFrame = cbFrame; Assert(pHdr->cbFrame == cbFrame);
434	pHdr->offFrame = sizeof(INTNETHDR);
435
436	*ppHdr = pHdr;
437	*ppvFrame = pHdr + 1;
438	return VINF_SUCCESS;
439	}
440	/*
441	* Try fit the frame at the start of the buffer.
442	* (The header fits before the end of the buffer because of alignment.)
443	*/
444	AssertMsg(pRingBuf->offEnd - offWriteInt >= sizeof(INTNETHDR), ("offEnd=%x offWriteInt=%x\n", pRingBuf->offEnd, offWriteInt));
445	if (offRead - pRingBuf->offStart > cb) /* not >= ! */
446	{
447	uint32_t offNew = pRingBuf->offStart + cb;
448	if (RT_LIKELY(ASMAtomicCmpXchgU32(&pRingBuf->offWriteInt, offNew, offWriteInt)))
449	{ /* likely / } else return VERR_WRONG_ORDER; / race */
450	Log2(("intnetRingAllocateFrameInternal: offWriteInt: %#x -> %#x (2) (R=%#x T=%#x S=%#x)\n", offWriteInt, offNew, offRead, u8Type, cbFrame));
451
452	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offWriteInt);
453	pHdr->u8Type = u8Type;
454	pHdr->cbFrame = cbFrame; Assert(pHdr->cbFrame == cbFrame);
455	pHdr->offFrame = pRingBuf->offStart - offWriteInt;
456
457	*ppHdr = pHdr;
458	ppvFrame = (uint8_t )pRingBuf + pRingBuf->offStart;
459	return VINF_SUCCESS;
460	}
461	}
462	/*
463	* The reader is ahead of the writer, try fit it into that space.
464	*/
465	else if (offRead - offWriteInt > cb + sizeof(INTNETHDR)) /* not >= ! */
466	{
467	uint32_t offNew = offWriteInt + cb + sizeof(INTNETHDR);
468	if (RT_LIKELY(ASMAtomicCmpXchgU32(&pRingBuf->offWriteInt, offNew, offWriteInt)))
469	{ /* likely / } else return VERR_WRONG_ORDER; / race */
470	Log2(("intnetRingAllocateFrameInternal: offWriteInt: %#x -> %#x (3) (R=%#x T=%#x S=%#x)\n", offWriteInt, offNew, offRead, u8Type, cbFrame));
471
472	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offWriteInt);
473	pHdr->u8Type = u8Type;
474	pHdr->cbFrame = cbFrame; Assert(pHdr->cbFrame == cbFrame);
475	pHdr->offFrame = sizeof(INTNETHDR);
476
477	*ppHdr = pHdr;
478	*ppvFrame = pHdr + 1;
479	return VINF_SUCCESS;
480	}
481
482	/* (it didn't fit) */
483	ppHdr = NULL; / shut up gcc, */
484	ppvFrame = NULL; / ditto. */
485	STAM_REL_COUNTER_INC(&pRingBuf->cOverflows);
486	return VERR_BUFFER_OVERFLOW;
487	}
488
489
490	/**
491	* Allocates a normal frame in the specified ring.
492	*
493	* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW.
494	* @param pRingBuf The ring buffer.
495	* @param cbFrame The frame size.
496	* @param ppHdr Where to return the frame header.
497	* Don't touch this!
498	* @param ppvFrame Where to return the frame pointer.
499	*/
500	DECLINLINE(int) IntNetRingAllocateFrame(PINTNETRINGBUF pRingBuf, uint32_t cbFrame, PINTNETHDR ppHdr, void *ppvFrame)
501	{
502	return intnetRingAllocateFrameInternal(pRingBuf, cbFrame, INTNETHDR_TYPE_FRAME, ppHdr, ppvFrame);
503	}
504
505
506	/**
507	* Allocates a GSO frame in the specified ring.
508	*
509	* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW.
510	* @param pRingBuf The ring buffer.
511	* @param cbFrame The frame size.
512	* @param pGso Pointer to the GSO context.
513	* @param ppHdr Where to return the frame header.
514	* Don't touch this!
515	* @param ppvFrame Where to return the frame pointer.
516	*/
517	DECLINLINE(int) IntNetRingAllocateGsoFrame(PINTNETRINGBUF pRingBuf, uint32_t cbFrame, PCPDMNETWORKGSO pGso,
518	PINTNETHDR ppHdr, void *ppvFrame)
519	{
520	void pvFrame = NULL; / gcc maybe used uninitialized */
521	int rc = intnetRingAllocateFrameInternal(pRingBuf, cbFrame + sizeof(*pGso), INTNETHDR_TYPE_GSO, ppHdr, &pvFrame);
522	if (RT_SUCCESS(rc))
523	{
524	PPDMNETWORKGSO pGsoCopy = (PPDMNETWORKGSO)pvFrame;
525	pGsoCopy = pGso;
526	*ppvFrame = pGsoCopy + 1;
527	}
528	return rc;
529	}
530
531
532	/**
533	* Commits a frame.
534	*
535	* Make sure to commit the frames in the order they've been allocated!
536	*
537	* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW.
538	* @param pRingBuf The ring buffer.
539	* @param pHdr The frame header returned by
540	* IntNetRingAllocateFrame.
541	*/
542	DECLINLINE(void) IntNetRingCommitFrame(PINTNETRINGBUF pRingBuf, PINTNETHDR pHdr)
543	{
544	/*
545	* Validate input and commit order.
546	*/
547	INTNETRINGBUF_ASSERT_SANITY(pRingBuf);
548	INTNETHDR_ASSERT_SANITY(pHdr, pRingBuf);
549	Assert(pRingBuf->offWriteCom == ((uintptr_t)pHdr - (uintptr_t)pRingBuf));
550
551	/*
552	* Figure out the offWriteCom for this packet and update the ring.
553	*/
554	const uint32_t cbFrame = pHdr->cbFrame;
555	const uint32_t cb = RT_ALIGN_32(cbFrame, INTNETHDR_ALIGNMENT);
556	uint32_t offWriteCom = (uint32_t)((uintptr_t)pHdr - (uintptr_t)pRingBuf)
557	+ pHdr->offFrame
558	+ cb;
559	if (offWriteCom >= pRingBuf->offEnd)
560	{
561	Assert(offWriteCom == pRingBuf->offEnd);
562	offWriteCom = pRingBuf->offStart;
563	}
564	Log2(("IntNetRingCommitFrame: offWriteCom: %#x -> %#x (R=%#x T=%#x S=%#x)\n", pRingBuf->offWriteCom, offWriteCom, pRingBuf->offReadX, pHdr->u8Type, cbFrame));
565	ASMAtomicWriteU32(&pRingBuf->offWriteCom, offWriteCom);
566	STAM_REL_COUNTER_ADD(&pRingBuf->cbStatWritten, cbFrame);
567	STAM_REL_COUNTER_INC(&pRingBuf->cStatFrames);
568	}
569
570
571	/**
572	* Commits a frame and injects a filler frame if not all of the buffer was used.
573	*
574	* Make sure to commit the frames in the order they've been allocated!
575	*
576	* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW.
577	* @param pRingBuf The ring buffer.
578	* @param pHdr The frame header returned by
579	* IntNetRingAllocateFrame.
580	* @param cbUsed The amount of space actually used. This does
581	* not include the GSO part.
582	*/
583	DECLINLINE(void) IntNetRingCommitFrameEx(PINTNETRINGBUF pRingBuf, PINTNETHDR pHdr, size_t cbUsed)
584	{
585	/*
586	* Validate input and commit order.
587	*/
588	INTNETRINGBUF_ASSERT_SANITY(pRingBuf);
589	INTNETHDR_ASSERT_SANITY(pHdr, pRingBuf);
590	Assert(pRingBuf->offWriteCom == ((uintptr_t)pHdr - (uintptr_t)pRingBuf));
591
592	if (pHdr->u8Type == INTNETHDR_TYPE_GSO)
593	cbUsed += sizeof(PDMNETWORKGSO);
594
595	/*
596	* Calc the new write commit offset.
597	*/
598	const uint32_t cbAlignedFrame = RT_ALIGN_32(pHdr->cbFrame, INTNETHDR_ALIGNMENT);
599	const uint32_t cbAlignedUsed = RT_ALIGN_32(cbUsed, INTNETHDR_ALIGNMENT);
600	uint32_t offWriteCom = (uint32_t)((uintptr_t)pHdr - (uintptr_t)pRingBuf)
601	+ pHdr->offFrame
602	+ cbAlignedFrame;
603	if (offWriteCom >= pRingBuf->offEnd)
604	{
605	Assert(offWriteCom == pRingBuf->offEnd);
606	offWriteCom = pRingBuf->offStart;
607	}
608
609	/*
610	* Insert a dummy frame to pad any unused space.
611	*/
612	if (cbAlignedFrame != cbAlignedUsed)
613	{
614	/** @todo Later: Try unallocate the extra memory. */
615	PINTNETHDR pHdrPadding = (PINTNETHDR)((uint8_t *)pHdr + pHdr->offFrame + cbAlignedUsed);
616	pHdrPadding->u8Type = INTNETHDR_TYPE_PADDING;
617	pHdrPadding->cbFrame = cbAlignedFrame - cbAlignedUsed - sizeof(INTNETHDR);
618	Assert(pHdrPadding->cbFrame == cbAlignedFrame - cbAlignedUsed - sizeof(INTNETHDR));
619	pHdrPadding->offFrame = sizeof(INTNETHDR);
620	pHdr->cbFrame = cbUsed; Assert(pHdr->cbFrame == cbUsed);
621	}
622
623	Log2(("IntNetRingCommitFrameEx: offWriteCom: %#x -> %#x (R=%#x T=%#x S=%#x P=%#x)\n", pRingBuf->offWriteCom, offWriteCom, pRingBuf->offReadX, pHdr->u8Type, pHdr->cbFrame, cbAlignedFrame - cbAlignedUsed));
624	ASMAtomicWriteU32(&pRingBuf->offWriteCom, offWriteCom);
625	STAM_REL_COUNTER_ADD(&pRingBuf->cbStatWritten, cbUsed);
626	STAM_REL_COUNTER_INC(&pRingBuf->cStatFrames);
627	}
628
629
630	/**
631	* Writes a frame to the specified ring.
632	*
633	* Make sure you don't have any uncommitted frames when calling this function!
634	*
635	* @returns VINF_SUCCESS or VERR_BUFFER_OVERFLOW.
636	* @param pRingBuf The ring buffer.
637	* @param pvFrame The bits to write.
638	* @param cbFrame How much to write.
639	*/
640	DECLINLINE(int) IntNetRingWriteFrame(PINTNETRINGBUF pRingBuf, const void *pvFrame, size_t cbFrame)
641	{
642	/*
643	* Validate input.
644	*/
645	INTNETRINGBUF_ASSERT_SANITY(pRingBuf);
646	Assert(cbFrame >= sizeof(RTMAC) * 2);
647
648	/*
649	* Align the size and read the volatile ring buffer variables.
650	*/
651	const uint32_t cb = RT_ALIGN_32(cbFrame, INTNETHDR_ALIGNMENT);
652	uint32_t offWriteInt = ASMAtomicUoReadU32(&pRingBuf->offWriteInt);
653	uint32_t offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
654	if (offRead <= offWriteInt)
655	{
656	/*
657	* Try fit it all before the end of the buffer.
658	*/
659	if (pRingBuf->offEnd - offWriteInt >= cb + sizeof(INTNETHDR))
660	{
661	uint32_t offNew = offWriteInt + cb + sizeof(INTNETHDR);
662	if (offNew >= pRingBuf->offEnd)
663	offNew = pRingBuf->offStart;
664	if (RT_LIKELY(ASMAtomicCmpXchgU32(&pRingBuf->offWriteInt, offNew, offWriteInt)))
665	{ /* likely / } else return VERR_WRONG_ORDER; / race */
666	Log2(("IntNetRingWriteFrame: offWriteInt: %#x -> %#x (1)\n", offWriteInt, offNew));
667
668	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offWriteInt);
669	pHdr->u8Type = INTNETHDR_TYPE_FRAME;
670	pHdr->cbFrame = cbFrame; Assert(pHdr->cbFrame == cbFrame);
671	pHdr->offFrame = sizeof(INTNETHDR);
672
673	memcpy(pHdr + 1, pvFrame, cbFrame);
674
675	Log2(("IntNetRingWriteFrame: offWriteCom: %#x -> %#x (1)\n", pRingBuf->offWriteCom, offNew));
676	ASMAtomicWriteU32(&pRingBuf->offWriteCom, offNew);
677	STAM_REL_COUNTER_ADD(&pRingBuf->cbStatWritten, cbFrame);
678	STAM_REL_COUNTER_INC(&pRingBuf->cStatFrames);
679	return VINF_SUCCESS;
680	}
681	/*
682	* Try fit the frame at the start of the buffer.
683	* (The header fits before the end of the buffer because of alignment.)
684	*/
685	AssertMsg(pRingBuf->offEnd - offWriteInt >= sizeof(INTNETHDR), ("offEnd=%x offWriteInt=%x\n", pRingBuf->offEnd, offWriteInt));
686	if (offRead - pRingBuf->offStart > cb) /* not >= ! */
687	{
688	uint32_t offNew = pRingBuf->offStart + cb;
689	if (RT_LIKELY(ASMAtomicCmpXchgU32(&pRingBuf->offWriteInt, offNew, offWriteInt)))
690	{ /* likely / } else return VERR_WRONG_ORDER; / race */
691	Log2(("IntNetRingWriteFrame: offWriteInt: %#x -> %#x (2)\n", offWriteInt, offNew));
692
693	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offWriteInt);
694	pHdr->u8Type = INTNETHDR_TYPE_FRAME;
695	pHdr->cbFrame = cbFrame; Assert(pHdr->cbFrame == cbFrame);
696	pHdr->offFrame = pRingBuf->offStart - offWriteInt;
697
698	memcpy((uint8_t *)pRingBuf + pRingBuf->offStart, pvFrame, cbFrame);
699
700	Log2(("IntNetRingWriteFrame: offWriteCom: %#x -> %#x (2)\n", pRingBuf->offWriteCom, offNew));
701	ASMAtomicWriteU32(&pRingBuf->offWriteCom, offNew);
702	STAM_REL_COUNTER_ADD(&pRingBuf->cbStatWritten, cbFrame);
703	STAM_REL_COUNTER_INC(&pRingBuf->cStatFrames);
704	return VINF_SUCCESS;
705	}
706	}
707	/*
708	* The reader is ahead of the writer, try fit it into that space.
709	*/
710	else if (offRead - offWriteInt > cb + sizeof(INTNETHDR)) /* not >= ! */
711	{
712	uint32_t offNew = offWriteInt + cb + sizeof(INTNETHDR);
713	if (RT_LIKELY(ASMAtomicCmpXchgU32(&pRingBuf->offWriteInt, offNew, offWriteInt)))
714	{ /* likely / } else return VERR_WRONG_ORDER; / race */
715	Log2(("IntNetRingWriteFrame: offWriteInt: %#x -> %#x (3)\n", offWriteInt, offNew));
716
717	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offWriteInt);
718	pHdr->u8Type = INTNETHDR_TYPE_FRAME;
719	pHdr->cbFrame = cbFrame; Assert(pHdr->cbFrame == cbFrame);
720	pHdr->offFrame = sizeof(INTNETHDR);
721
722	memcpy(pHdr + 1, pvFrame, cbFrame);
723
724	Log2(("IntNetRingWriteFrame: offWriteCom: %#x -> %#x (3)\n", pRingBuf->offWriteCom, offNew));
725	ASMAtomicWriteU32(&pRingBuf->offWriteCom, offNew);
726	STAM_REL_COUNTER_ADD(&pRingBuf->cbStatWritten, cbFrame);
727	STAM_REL_COUNTER_INC(&pRingBuf->cStatFrames);
728	return VINF_SUCCESS;
729	}
730
731	/* (it didn't fit) */
732	STAM_REL_COUNTER_INC(&pRingBuf->cOverflows);
733	return VERR_BUFFER_OVERFLOW;
734	}
735
736
737	/**
738	* Reads the next frame in the buffer and moves the read cursor past it.
739	*
740	* @returns Size of the frame in bytes. 0 is returned if nothing in the buffer.
741	* @param pRingBuf The ring buffer to read from.
742	* @param pvFrameDst Where to put the frame. The caller is responsible for
743	* ensuring that there is sufficient space for the frame.
744	*
745	* @deprecated Bad interface, do NOT use it! Only for tstIntNetR0.
746	*/
747	DECLINLINE(uint32_t) IntNetRingReadAndSkipFrame(PINTNETRINGBUF pRingBuf, void *pvFrameDst)
748	{
749	INTNETRINGBUF_ASSERT_SANITY(pRingBuf);
750
751	uint32_t offRead = ASMAtomicUoReadU32(&pRingBuf->offReadX);
752	uint32_t const offWriteCom = ASMAtomicUoReadU32(&pRingBuf->offWriteCom);
753	if (offRead == offWriteCom)
754	return 0;
755
756	PINTNETHDR pHdr = (PINTNETHDR)((uint8_t *)pRingBuf + offRead);
757	INTNETHDR_ASSERT_SANITY(pHdr, pRingBuf);
758
759	uint32_t const cbFrame = pHdr->cbFrame;
760	int32_t const offFrame = pHdr->offFrame;
761	const void pvFrameSrc = (uint8_t )pHdr + offFrame;
762	memcpy(pvFrameDst, pvFrameSrc, cbFrame);
763	#ifdef INTNET_POISON_READ_FRAMES
764	memset((void *)pvFrameSrc, 0xfe, RT_ALIGN_32(cbFrame, INTNETHDR_ALIGNMENT));
765	memset(pHdr, 0xef, sizeof(*pHdr));
766	#endif
767
768	/* skip the frame */
769	offRead += offFrame + cbFrame;
770	offRead = RT_ALIGN_32(offRead, INTNETHDR_ALIGNMENT);
771	Assert(offRead <= pRingBuf->offEnd && offRead >= pRingBuf->offStart);
772	if (offRead >= pRingBuf->offEnd)
773	offRead = pRingBuf->offStart;
774	ASMAtomicWriteU32(&pRingBuf->offReadX, offRead);
775	return cbFrame;
776	}
777
778
779	/**
780	* Initializes a buffer structure.
781	*
782	* @param pIntBuf The internal networking interface buffer. This
783	* expected to be cleared prior to calling this
784	* function.
785	* @param cbBuf The size of the whole buffer.
786	* @param cbRecv The receive size.
787	* @param cbSend The send size.
788	*/
789	DECLINLINE(void) IntNetBufInit(PINTNETBUF pIntBuf, uint32_t cbBuf, uint32_t cbRecv, uint32_t cbSend)
790	{
791	AssertCompileSizeAlignment(INTNETBUF, INTNETHDR_ALIGNMENT);
792	AssertCompileSizeAlignment(INTNETBUF, INTNETRINGBUF_ALIGNMENT);
793	Assert(cbBuf >= sizeof(INTNETBUF) + cbRecv + cbSend);
794	Assert(RT_ALIGN_32(cbRecv, INTNETRINGBUF_ALIGNMENT) == cbRecv);
795	Assert(RT_ALIGN_32(cbSend, INTNETRINGBUF_ALIGNMENT) == cbSend);
796	Assert(ASMMemIsZero(pIntBuf, cbBuf));
797
798	pIntBuf->u32Magic = INTNETBUF_MAGIC;
799	pIntBuf->cbBuf = cbBuf;
800	pIntBuf->cbRecv = cbRecv;
801	pIntBuf->cbSend = cbSend;
802
803	/* receive ring buffer. */
804	uint32_t offBuf = RT_ALIGN_32(sizeof(INTNETBUF), INTNETRINGBUF_ALIGNMENT) - RT_OFFSETOF(INTNETBUF, Recv);
805	pIntBuf->Recv.offStart = offBuf;
806	pIntBuf->Recv.offReadX = offBuf;
807	pIntBuf->Recv.offWriteInt = offBuf;
808	pIntBuf->Recv.offWriteCom = offBuf;
809	pIntBuf->Recv.offEnd = offBuf + cbRecv;
810
811	/* send ring buffer. */
812	offBuf += cbRecv + RT_OFFSETOF(INTNETBUF, Recv) - RT_OFFSETOF(INTNETBUF, Send);
813	pIntBuf->Send.offStart = offBuf;
814	pIntBuf->Send.offReadX = offBuf;
815	pIntBuf->Send.offWriteCom = offBuf;
816	pIntBuf->Send.offWriteInt = offBuf;
817	pIntBuf->Send.offEnd = offBuf + cbSend;
818	Assert(cbBuf >= offBuf + cbSend);
819	}
820
821	#endif /* __cplusplus */
822
823	#endif
824

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/include/VBox/intnetinline.h@ 69206

Download in other formats: