tstIntNetR0.cpp@ 16444

Last change on this file since 16444 was 15842, checked in by vboxsync, 16 years ago
SrvIntNetR0: Rewrote r41325 so it fixes the problem without leaking memory.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.0 KB

Line
1	/* $Id: tstIntNetR0.cpp 15842 2009-01-07 16:41:48Z vboxsync $ */
2	/** @file
3	* Internal networking - Usermode testcase for the kernel mode bits.
4	*
5	* This is a bit hackish as we're mixing context here, however it is
6	* very useful when making changes to the internal networking service.
7	*/
8
9	/*
10	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
11	*
12	* This file is part of VirtualBox Open Source Edition (OSE), as
13	* available from http://www.virtualbox.org. This file is free software;
14	* you can redistribute it and/or modify it under the terms of the GNU
15	* General Public License (GPL) as published by the Free Software
16	* Foundation, in version 2 as it comes in the "COPYING" file of the
17	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
18	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
19	*
20	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
21	* Clara, CA 95054 USA or visit http://www.sun.com if you need
22	* additional information or have any questions.
23	*/
24
25
26	/*******************************************************************************
27	* Header Files *
28	*******************************************************************************/
29	#define IN_INTNET_TESTCASE
30	#define IN_INTNET_R3
31	#include <VBox/cdefs.h>
32	#undef INTNETR0DECL
33	#define INTNETR0DECL INTNETR3DECL
34	#undef DECLR0CALLBACKMEMBER
35	#define DECLR0CALLBACKMEMBER(type, name, args) DECLR3CALLBACKMEMBER(type, name, args)
36	#include <VBox/types.h>
37	typedef void *MYPSUPDRVSESSION;
38	#define PSUPDRVSESSION MYPSUPDRVSESSION
39
40	#include <VBox/intnet.h>
41	#include <VBox/sup.h>
42	#include <VBox/err.h>
43	#include <iprt/stream.h>
44	#include <iprt/alloc.h>
45	#include <iprt/initterm.h>
46	#include <iprt/thread.h>
47	#include <iprt/time.h>
48	#include <iprt/asm.h>
49	#include <iprt/getopt.h>
50
51
52	/*******************************************************************************
53	* Structures and Typedefs *
54	*******************************************************************************/
55	/**
56	* Security objectype.
57	*/
58	typedef enum SUPDRVOBJTYPE
59	{
60	/** The usual invalid object. */
61	SUPDRVOBJTYPE_INVALID = 0,
62	/** Internal network. */
63	SUPDRVOBJTYPE_INTERNAL_NETWORK,
64	/** Internal network interface. */
65	SUPDRVOBJTYPE_INTERNAL_NETWORK_INTERFACE,
66	/** The first invalid object type in this end. */
67	SUPDRVOBJTYPE_END,
68	/** The usual 32-bit type size hack. */
69	SUPDRVOBJTYPE_32_BIT_HACK = 0x7ffffff
70	} SUPDRVOBJTYPE;
71
72	/**
73	* Object destructor callback.
74	* This is called for reference counted objectes when the count reaches 0.
75	*
76	* @param pvObj The object pointer.
77	* @param pvUser1 The first user argument.
78	* @param pvUser2 The second user argument.
79	*/
80	typedef DECLCALLBACK(void) FNSUPDRVDESTRUCTOR(void pvObj, void pvUser1, void *pvUser2);
81	/** Pointer to a FNSUPDRVDESTRUCTOR(). */
82	typedef FNSUPDRVDESTRUCTOR *PFNSUPDRVDESTRUCTOR;
83
84
85	/**
86	* Dummy
87	*/
88	typedef struct OBJREF
89	{
90	PFNSUPDRVDESTRUCTOR pfnDestructor;
91	void *pvUser1;
92	void *pvUser2;
93	uint32_t volatile cRefs;
94	} OBJREF, *POBJREF;
95
96
97	/*******************************************************************************
98	* Global Variables *
99	*******************************************************************************/
100	/** The error count. */
101	unsigned g_cErrors = 0;
102
103	/** Fake session handle. */
104	const PSUPDRVSESSION g_pSession = (PSUPDRVSESSION)0xdeadface;
105
106	/** Testframe 0 */
107	struct TESTFRAME
108	{
109	uint16_t au16[7];
110	} g_TestFrame0 = { { /* dst:/ 0xffff, 0xffff, 0xffff, /src:*/0x8086, 0, 0, 0x0800 } },
111	g_TestFrame1 = { { /* dst:/ 0, 0, 0, /src:*/0x8086, 0, 1, 0x0800 } };
112
113
114	INTNETR3DECL(void ) SUPR0ObjRegister(PSUPDRVSESSION pSession, SUPDRVOBJTYPE enmType, PFNSUPDRVDESTRUCTOR pfnDestructor, void pvUser1, void *pvUser2)
115	{
116	if (pSession != g_pSession)
117	{
118	RTPrintf("tstIntNetR0: Invalid session pointer %p, %s!\n", pSession, __FUNCTION__);
119	g_cErrors++;
120	return NULL;
121	}
122	POBJREF pRef = (POBJREF)RTMemAlloc(sizeof(OBJREF));
123	if (!pRef)
124	return NULL;
125	pRef->cRefs = 1;
126	pRef->pfnDestructor = pfnDestructor;
127	pRef->pvUser1 = pvUser1;
128	pRef->pvUser2 = pvUser2;
129	return pRef;
130	}
131
132	INTNETR3DECL(int) SUPR0ObjAddRefEx(void *pvObj, PSUPDRVSESSION pSession, bool fNoBlocking)
133	{
134	if (pSession != g_pSession)
135	{
136	RTPrintf("tstIntNetR0: Invalid session pointer %p, %s!\n", pSession, __FUNCTION__);
137	g_cErrors++;
138	return VERR_INVALID_PARAMETER;
139	}
140	POBJREF pRef = (POBJREF)pvObj;
141	ASMAtomicIncU32(&pRef->cRefs);
142	return VINF_SUCCESS;
143	}
144
145	INTNETR3DECL(int) SUPR0ObjAddRef(void *pvObj, PSUPDRVSESSION pSession)
146	{
147	return SUPR0ObjAddRefEx(pvObj, pSession, false);
148	}
149
150	INTNETR3DECL(int) SUPR0ObjRelease(void *pvObj, PSUPDRVSESSION pSession)
151	{
152	if (pSession != g_pSession)
153	{
154	RTPrintf("tstIntNetR0: Invalid session pointer %p, %s!\n", pSession, __FUNCTION__);
155	g_cErrors++;
156	return VERR_INVALID_PARAMETER;
157	}
158	POBJREF pRef = (POBJREF)pvObj;
159	if (!ASMAtomicDecU32(&pRef->cRefs))
160	{
161	pRef->pfnDestructor(pRef, pRef->pvUser1, pRef->pvUser2);
162	RTMemFree(pRef);
163	return VINF_OBJECT_DESTROYED;
164	}
165	return VINF_SUCCESS;
166	}
167
168	INTNETR3DECL(int) SUPR0ObjVerifyAccess(void pvObj, PSUPDRVSESSION pSession, const char pszObjName)
169	{
170	if (pSession != g_pSession)
171	{
172	RTPrintf("tstIntNetR0: Invalid session pointer %p, %s!\n", pSession, __FUNCTION__);
173	g_cErrors++;
174	return VERR_INVALID_PARAMETER;
175	}
176	return VINF_SUCCESS;
177	}
178
179	INTNETR3DECL(int) SUPR0MemAlloc(PSUPDRVSESSION pSession, uint32_t cb, PRTR0PTR ppvR0, PRTR3PTR ppvR3)
180	{
181	if (pSession != g_pSession)
182	{
183	RTPrintf("tstIntNetR0: Invalid session pointer %p, %s!\n", pSession, __FUNCTION__);
184	g_cErrors++;
185	return VERR_INVALID_PARAMETER;
186	}
187	void *pv = RTMemAlloc(cb);
188	if (!pv)
189	return VERR_NO_MEMORY;
190	*ppvR0 = (RTR0PTR)pv;
191	if (ppvR3)
192	*ppvR3 = pv;
193	return VINF_SUCCESS;
194	}
195
196	INTNETR3DECL(int) SUPR0MemFree(PSUPDRVSESSION pSession, RTHCUINTPTR uPtr)
197	{
198	if (pSession != g_pSession)
199	{
200	RTPrintf("tstIntNetR0: Invalid session pointer %p, %s!\n", pSession, __FUNCTION__);
201	g_cErrors++;
202	return VERR_INVALID_PARAMETER;
203	}
204	RTMemFree((void *)uPtr);
205	return VINF_SUCCESS;
206	}
207
208
209
210	/* ugly but necessary for making R0 code compilable for R3. */
211	#undef LOG_GROUP
212	#include "../SrvIntNetR0.cpp"
213
214	typedef struct ARGS
215	{
216	PINTNET pIntNet;
217	PINTNETBUF pBuf;
218	INTNETIFHANDLE hIf;
219	RTMAC Mac;
220	uint64_t u64Start;
221	uint64_t u64End;
222	} ARGS, *PARGS;
223
224
225	#define TEST_TRANSFER_SIZE (_1M*384)
226
227	/**
228	* Send thread.
229	* This is constantly broadcasting frames to the network.
230	*/
231	DECLCALLBACK(int) SendThread(RTTHREAD Thread, void *pvArg)
232	{
233	PARGS pArgs = (PARGS)pvArg;
234
235	/*
236	* Send 64 MB of data.
237	*/
238	uint8_t abBuf[4096] = {0};
239	PRTMAC pMacSrc = (PRTMAC)&abBuf[0];
240	PRTMAC pMacDst = pMacSrc + 1;
241	*pMacSrc = pArgs->Mac;
242	*pMacDst = pArgs->Mac;
243	pMacDst->au16[2] = pArgs->Mac.au16[2] ? 0 : 1;
244	unsigned puFrame = (unsigned )(pMacDst + 1);
245	unsigned iFrame = 0;
246	unsigned cbSent = 0;
247	pArgs->u64Start = RTTimeNanoTS();
248	for (; cbSent < TEST_TRANSFER_SIZE; iFrame++)
249	{
250	const unsigned cb = iFrame % 1519 + 12 + sizeof(unsigned);
251	*puFrame = iFrame;
252	#if 0
253	int rc = INTNETR0IfSend(pArgs->pIntNet, pArgs->hIf, g_pSession, abBuf, cb);
254	#else
255	INTNETSG Sg;
256	intnetR0SgInitTemp(&Sg, abBuf, cb);
257	int rc = intnetR0RingWriteFrame(pArgs->pBuf, &pArgs->pBuf->Send, &Sg, NULL);
258	if (RT_SUCCESS(rc))
259	rc = INTNETR0IfSend(pArgs->pIntNet, pArgs->hIf, g_pSession, NULL, 0);
260	#endif
261	if (RT_FAILURE(rc))
262	{
263	g_cErrors++;
264	RTPrintf("tstIntNetR0: Failed sending %d bytes, rc=%Rrc (%d)\n", cb, rc, INTNETRingGetWritable(&pArgs->pBuf->Send));
265	}
266	cbSent += cb;
267	}
268
269	/*
270	* Termination frames.
271	*/
272	puFrame[0] = 0xffffdead;
273	puFrame[1] = 0xffffdead;
274	puFrame[2] = 0xffffdead;
275	puFrame[3] = 0xffffdead;
276	for (unsigned c = 0; c < 20; c++)
277	{
278	int rc = INTNETR0IfSend(pArgs->pIntNet, pArgs->hIf, g_pSession, abBuf, sizeof(RTMAC) * 2 + sizeof(unsigned) * 4);
279	if (RT_FAILURE(rc))
280	{
281	g_cErrors++;
282	RTPrintf("tstIntNetR0: send failed, rc=%Rrc\n", rc);
283	}
284	RTThreadSleep(1);
285	}
286
287	RTPrintf("tstIntNetR0: sender thread %.6Rhxs terminating. iFrame=%d cbSent=%d\n", &pArgs->Mac, iFrame, cbSent);
288	return 0;
289	}
290
291
292	/** Ignore lost frames. It only makes things worse to bitch about it. */
293	#define IGNORE_LOST_FRAMES
294
295	/**
296	* Receive thread.
297	* This is reading stuff from the network.
298	*/
299	DECLCALLBACK(int) ReceiveThread(RTTHREAD Thread, void *pvArg)
300	{
301	unsigned cbReceived = 0;
302	unsigned cLostFrames = 0;
303	unsigned iFrame = ~0;
304	PARGS pArgs = (PARGS)pvArg;
305	for (;;)
306	{
307	/*
308	* Wait for data.
309	*/
310	int rc = INTNETR0IfWait(pArgs->pIntNet, pArgs->hIf, g_pSession, RT_INDEFINITE_WAIT);
311	switch (rc)
312	{
313	case VERR_INTERRUPTED:
314	case VINF_SUCCESS:
315	break;
316	case VERR_SEM_DESTROYED:
317	RTPrintf("tstIntNetR0: receiver thread %.6Rhxs terminating. cbReceived=%u cLostFrames=%u iFrame=%u\n",
318	&pArgs->Mac, cbReceived, cLostFrames, iFrame);
319	return VINF_SUCCESS;
320
321	default:
322	RTPrintf("tstIntNetR0: receiver thread %.6Rhxs got odd return value %Rrc! cbReceived=%u cLostFrames=%u iFrame=%u\n",
323	&pArgs->Mac, rc, cbReceived, cLostFrames, iFrame);
324	g_cErrors++;
325	return rc;
326	}
327
328	/*
329	* Read data.
330	*/
331	while (INTNETRingGetReadable(&pArgs->pBuf->Recv))
332	{
333	uint8_t abBuf[16384];
334	unsigned cb = intnetR0RingReadFrame(pArgs->pBuf, &pArgs->pBuf->Recv, abBuf);
335	unsigned puFrame = (unsigned )&abBuf[sizeof(RTMAC) * 2];
336
337	/* check for termination frame. */
338	if ( cb == sizeof(RTMAC) * 2 + sizeof(unsigned) * 4
339	&& puFrame[0] == 0xffffdead
340	&& puFrame[1] == 0xffffdead
341	&& puFrame[2] == 0xffffdead
342	&& puFrame[3] == 0xffffdead)
343	{
344	RTPrintf("tstIntNetR0: receiver thread %.6Rhxs terminating. cbReceived=%u cLostFrames=%u iFrame=%u\n",
345	&pArgs->Mac, cbReceived, cLostFrames, iFrame);
346	pArgs->u64End = RTTimeNanoTS();
347	return VINF_SUCCESS;
348	}
349
350	/* validate frame header */
351	PRTMAC pMacSrc = (PRTMAC)&abBuf[0];
352	PRTMAC pMacDst = pMacSrc + 1;
353	if ( pMacDst->au16[0] != 0x8086
354	\|\| pMacDst->au16[1] != 0
355	\|\| pMacDst->au16[2] != pArgs->Mac.au16[2]
356	\|\| pMacSrc->au16[0] != 0x8086
357	\|\| pMacSrc->au16[1] != 0
358	\|\| pMacSrc->au16[2] == pArgs->Mac.au16[2])
359	{
360	RTPrintf("tstIntNetR0: receiver thread %.6Rhxs received frame header: %.16Rhxs\n",
361	&pArgs->Mac, abBuf);
362	g_cErrors++;
363	}
364
365	/* frame stuff and stats. */
366	int off = iFrame + 1 - *puFrame;
367	if (off)
368	{
369	if (off > 0)
370	{
371	RTPrintf("tstIntNetR0: receiver thread %.6Rhxs: iFrame=%d *puFrame=%d off=%d\n",
372	&pArgs->Mac, iFrame, *puFrame, off);
373	g_cErrors++;
374	cLostFrames++;
375	}
376	else
377	{
378	cLostFrames += -off;
379	#ifndef IGNORE_LOST_FRAMES
380	if (off < 50)
381	{
382	RTPrintf("tstIntNetR0: receiver thread %.6Rhxs: iFrame=%d *puFrame=%d off=%d\n",
383	&pArgs->Mac, iFrame, *puFrame, off);
384	g_cErrors++;
385	}
386	#endif
387	}
388	}
389	iFrame = *puFrame;
390	cbReceived += cb;
391	}
392	}
393	}
394
395	int main(int argc, char **argv)
396	{
397	/*
398	* Init the runtime and parse arguments.
399	*/
400	RTR3Init();
401
402	static RTOPTIONDEF const s_aOptions[] =
403	{
404	{ "--recv-buffer", 'r', RTGETOPT_REQ_UINT32 },
405	{ "--send-buffer", 's', RTGETOPT_REQ_UINT32 },
406	};
407
408	uint32_t cbRecv = 32 * _1K;
409	uint32_t cbSend = 1536*2;
410
411	int ch;
412	int iArg = 1;
413	RTOPTIONUNION Value;
414	while ((ch = RTGetOpt(argc,argv, &s_aOptions[0], RT_ELEMENTS(s_aOptions), &iArg, &Value)))
415	switch (ch)
416	{
417	case 'r':
418	cbRecv = Value.u32;
419	break;
420
421	case 's':
422	cbSend = Value.u32;
423	break;
424
425	default:
426	RTPrintf("tstIntNetR0: invalid argument: %s\n", Value.psz);
427	return 1;
428	}
429	if (iArg < argc)
430	{
431	RTPrintf("tstIntNetR0: invalid argument: %s\n", argv[iArg]);
432	return 1;
433	}
434
435	/*
436	* Create an INTNET instance.
437	*/
438	RTPrintf("tstIntNetR0: TESTING cbSend=%d cbRecv=%d ...\n", cbSend, cbRecv);
439	PINTNET pIntNet;
440	int rc = INTNETR0Create(&pIntNet);
441	if (RT_FAILURE(rc))
442	{
443	RTPrintf("tstIntNetR0: INTNETR0Create failed, rc=%Rrc\n");
444	return 1;
445	}
446
447	/*
448	* Create two interfaces.
449	*/
450	INTNETIFHANDLE hIf0 = INTNET_HANDLE_INVALID;
451	rc = INTNETR0Open(pIntNet, g_pSession, "test", kIntNetTrunkType_None, "", 0, 1536*2 + 4, 0x8000, &hIf0);
452	if (RT_SUCCESS(rc))
453	{
454	if (hIf0 != INTNET_HANDLE_INVALID)
455	{
456	INTNETIFHANDLE hIf1 = INTNET_HANDLE_INVALID;
457	rc = INTNETR0Open(pIntNet, g_pSession, "test", kIntNetTrunkType_None, NULL, 0, 1536*2 + 4, 0x8000, &hIf1);
458	if (RT_SUCCESS(rc))
459	{
460	if (hIf1 != INTNET_HANDLE_INVALID)
461	{
462	PINTNETBUF pBuf0;
463	rc = INTNETR0IfGetRing0Buffer(pIntNet, hIf0, g_pSession, &pBuf0);
464	if (RT_FAILURE(rc) \|\| !pBuf0)
465	{
466	RTPrintf("tstIntNetR0: INTNETIfGetRing0Buffer failed! pBuf0=%p rc=%Rrc\n", pBuf0, rc);
467	g_cErrors++;
468	}
469	PINTNETBUF pBuf1;
470	rc = INTNETR0IfGetRing0Buffer(pIntNet, hIf1, g_pSession, &pBuf1);
471	if (RT_FAILURE(rc))
472	{
473	RTPrintf("tstIntNetR0: INTNETIfGetRing0Buffer failed! pBuf1=%p rc=%Rrc\n", pBuf1, rc);
474	g_cErrors++;
475	}
476
477	rc = INTNETR0IfSetActive(pIntNet, hIf0, g_pSession, true);
478	if (RT_FAILURE(rc))
479	{
480	RTPrintf("tstIntNetR0: INTNETR0IfSetActive failed! rc=%Rrc\n", rc);
481	g_cErrors++;
482	}
483	rc = INTNETR0IfSetActive(pIntNet, hIf1, g_pSession, true);
484	if (RT_FAILURE(rc))
485	{
486	RTPrintf("tstIntNetR0: INTNETR0IfSetActive failed! rc=%Rrc\n", rc);
487	g_cErrors++;
488	}
489
490
491	/*
492	* Test basic waiting.
493	*/
494	rc = INTNETR0IfWait(pIntNet, hIf0, g_pSession, 1);
495	if (rc != VERR_TIMEOUT)
496	{
497	RTPrintf("tstIntNetR0: INTNETIfWait returned %Rrc expected VERR_TIMEOUT (hIf0)\n", rc);
498	g_cErrors++;
499	}
500	rc = INTNETR0IfWait(pIntNet, hIf1, g_pSession, 0);
501	if (rc != VERR_TIMEOUT)
502	{
503	RTPrintf("tstIntNetR0: INTNETIfWait returned %Rrc expected VERR_TIMEOUT (hIf1)\n", rc);
504	g_cErrors++;
505	}
506
507	/*
508	* Send and receive.
509	*/
510	rc = INTNETR0IfSend(pIntNet, hIf0, g_pSession, &g_TestFrame0, sizeof(g_TestFrame0));
511	if (RT_SUCCESS(rc))
512	{
513	rc = INTNETR0IfWait(pIntNet, hIf0, g_pSession, 1);
514	if (rc != VERR_TIMEOUT)
515	{
516	RTPrintf("tstIntNetR0: INTNETIfWait returned %Rrc expected VERR_TIMEOUT (hIf0, 2nd)\n", rc);
517	g_cErrors++;
518	}
519	rc = INTNETR0IfWait(pIntNet, hIf1, g_pSession, 0);
520	if (rc == VINF_SUCCESS)
521	{
522	/* receive it */
523	uint8_t abBuf[sizeof(g_TestFrame0)];
524	const unsigned cbExpect = RT_ALIGN(sizeof(g_TestFrame0) + sizeof(INTNETHDR), sizeof(INTNETHDR));
525	if (INTNETRingGetReadable(&pBuf1->Recv) != cbExpect)
526	{
527	RTPrintf("tstIntNetR0: %d readable bytes, expected %d!\n", INTNETRingGetReadable(&pBuf1->Recv), cbExpect);
528	g_cErrors++;
529	}
530	unsigned cb = intnetR0RingReadFrame(pBuf1, &pBuf1->Recv, abBuf);
531	if (cb != sizeof(g_TestFrame0))
532	{
533	RTPrintf("tstIntNetR0: read %d frame bytes, expected %d!\n", cb, sizeof(g_TestFrame0));
534	g_cErrors++;
535	}
536	else if (memcmp(abBuf, &g_TestFrame0, sizeof(g_TestFrame0)))
537	{
538	RTPrintf("tstIntNetR0: Got invalid data!\n"
539	"received: %.*Rhxs\n"
540	"expected: %.*Rhxs\n",
541	cb, abBuf, sizeof(g_TestFrame0), &g_TestFrame0);
542	g_cErrors++;
543	}
544
545	/*
546	* Send a packet from If1 just to set its MAC address.
547	*/
548	rc = INTNETR0IfSend(pIntNet, hIf1, g_pSession, &g_TestFrame1, sizeof(g_TestFrame1));
549	if (RT_FAILURE(rc))
550	{
551	RTPrintf("tstIntNetR0: INTNETIfSend returned %Rrc! (hIf1)\n", rc);
552	g_cErrors++;
553	}
554
555
556	/*
557	* Start threaded testcase.
558	* Give it 5 mins to finish.
559	*/
560	if (!g_cErrors)
561	{
562	ARGS Args0 = {0};
563	Args0.hIf = hIf0;
564	Args0.pBuf = pBuf0;
565	Args0.pIntNet = pIntNet;
566	Args0.Mac.au16[0] = 0x8086;
567	Args0.Mac.au16[1] = 0;
568	Args0.Mac.au16[2] = 0;
569
570	ARGS Args1 = {0};
571	Args1.hIf = hIf1;
572	Args1.pBuf = pBuf1;
573	Args1.pIntNet = pIntNet;
574	Args1.Mac.au16[0] = 0x8086;
575	Args1.Mac.au16[1] = 0;
576	Args1.Mac.au16[2] = 1;
577
578	RTTHREAD ThreadRecv0 = NIL_RTTHREAD;
579	RTTHREAD ThreadRecv1 = NIL_RTTHREAD;
580	RTTHREAD ThreadSend0 = NIL_RTTHREAD;
581	RTTHREAD ThreadSend1 = NIL_RTTHREAD;
582	rc = RTThreadCreate(&ThreadRecv0, ReceiveThread, &Args0, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV0");
583	if (RT_SUCCESS(rc))
584	rc = RTThreadCreate(&ThreadRecv1, ReceiveThread, &Args1, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "RECV1");
585	if (RT_SUCCESS(rc))
586	rc = RTThreadCreate(&ThreadSend0, SendThread, &Args0, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND0");
587	if (RT_SUCCESS(rc))
588	rc = RTThreadCreate(&ThreadSend1, SendThread, &Args1, 0, RTTHREADTYPE_EMULATION, RTTHREADFLAGS_WAITABLE, "SEND1");
589	if (RT_SUCCESS(rc))
590	{
591	int rc2 = VINF_SUCCESS;
592	rc = RTThreadWait(ThreadSend0, 5601000, &rc2);
593	#if 1 /** @todo it looks like I'm subject to some false wakeup calls here (2.6.23-gentoo-r3 amd64). See #3023.*/
594	for (int cTries = 100; rc == VERR_TIMEOUT && cTries > 0; cTries--)
595	{
596	RTThreadSleep(1);
597	rc = RTThreadWait(ThreadSend0, 1, &rc2);
598	}
599	#endif
600	AssertRC(rc);
601	if (RT_SUCCESS(rc))
602	{
603	ThreadSend0 = NIL_RTTHREAD;
604	rc = RTThreadWait(ThreadSend1, 5601000, RT_SUCCESS(rc2) ? &rc2 : NULL);
605	#if 1 /** @todo it looks like I'm subject to some false wakeup calls here (2.6.23-gentoo-r3 amd64). See #3023.*/
606	for (int cTries = 100; rc == VERR_TIMEOUT && cTries > 0; cTries--)
607	{
608	RTThreadSleep(1);
609	rc = RTThreadWait(ThreadSend1, 1, &rc2);
610	}
611	#endif
612	AssertRC(rc);
613	if (RT_SUCCESS(rc))
614	ThreadSend1 = NIL_RTTHREAD;
615	}
616	if ( RT_SUCCESS(rc)
617	&& RT_SUCCESS(rc2))
618	{
619	/*
620	* Wait a bit for the receivers to finish up.
621	*/
622	unsigned cYields = 100000;
623	while ( ( INTNETRingGetReadable(&pBuf0->Recv)
624	\|\| INTNETRingGetReadable(&pBuf1->Recv))
625	&& cYields-- > 0)
626	RTThreadYield();
627
628	uint64_t u64Elapsed = RT_MAX(Args0.u64End, Args1.u64End) - RT_MIN(Args0.u64Start, Args1.u64Start);
629	uint64_t u64Speed = (uint64_t)((2 * TEST_TRANSFER_SIZE / 1024) / (u64Elapsed / 1000000000.0));
630	RTPrintf("tstIntNetR0: transfered %d bytes in %RU64 ns (%RU64 KB/s)\n",
631	2 * TEST_TRANSFER_SIZE, u64Elapsed, u64Speed);
632
633	/*
634	* Closing time...
635	*/
636	rc = RTThreadWait(ThreadRecv0, 5000, &rc2);
637	if (RT_SUCCESS(rc))
638	ThreadRecv0 = NIL_RTTHREAD;
639	if (RT_FAILURE(rc) \|\| RT_FAILURE(rc2))
640	{
641	RTPrintf("tstIntNetR0: Failed waiting on receiver thread 0, rc=%Rrc, rc2=%Rrc\n", rc, rc2);
642	g_cErrors++;
643	}
644
645	rc = RTThreadWait(ThreadRecv1, 5000, &rc2);
646	if (RT_SUCCESS(rc))
647	ThreadRecv1 = NIL_RTTHREAD;
648	if (RT_FAILURE(rc) \|\| RT_FAILURE(rc2))
649	{
650	RTPrintf("tstIntNetR0: Failed waiting on receiver thread 1, rc=%Rrc, rc2=%Rrc\n", rc, rc2);
651	g_cErrors++;
652	}
653
654	rc = INTNETR0IfClose(pIntNet, hIf0, g_pSession);
655	if (RT_SUCCESS(rc))
656	{
657	hIf0 = INTNET_HANDLE_INVALID;
658	pBuf0 = NULL;
659	}
660	else
661	{
662	RTPrintf("tstIntNetR0: INTNETIfClose failed, rc=%Rrc! (hIf0)\n", rc);
663	g_cErrors++;
664	}
665
666	rc = INTNETR0IfClose(pIntNet, hIf1, g_pSession);
667	if (RT_SUCCESS(rc))
668	{
669	hIf1 = INTNET_HANDLE_INVALID;
670	pBuf1 = NULL;
671	}
672	else
673	{
674	RTPrintf("tstIntNetR0: INTNETIfClose failed, rc=%Rrc! (hIf1)\n", rc);
675	g_cErrors++;
676	}
677
678
679	/* check if the network still exist... */
680	if (pIntNet->pNetworks)
681	{
682	RTPrintf("tstIntNetR0: The network wasn't deleted! (g_cErrors=%d)\n", g_cErrors);
683	g_cErrors++;
684	}
685	}
686	else
687	{
688	RTPrintf("tstIntNetR0: Waiting on senders failed, rc=%Rrc, rc2=%Rrc\n", rc, rc2);
689	g_cErrors++;
690	}
691
692	/*
693	* Give them a chance to complete...
694	*/
695	RTThreadWait(ThreadRecv0, 5000, NULL);
696	RTThreadWait(ThreadRecv1, 5000, NULL);
697	RTThreadWait(ThreadSend0, 5000, NULL);
698	RTThreadWait(ThreadSend1, 5000, NULL);
699
700	}
701	else
702	{
703	RTPrintf("tstIntNetR0: Failed to create threads, rc=%Rrc\n", rc);
704	g_cErrors++;
705	}
706	}
707	}
708	else
709	{
710	RTPrintf("tstIntNetR0: INTNETIfWait returned %Rrc expected VINF_SUCCESS (hIf1)\n", rc);
711	g_cErrors++;
712	}
713	}
714	else
715	{
716	RTPrintf("tstIntNetR0: INTNETIfSend returned %Rrc! (hIf0)\n", rc);
717	g_cErrors++;
718	}
719	}
720	else
721	{
722	RTPrintf("tstIntNetR0: INTNETOpen returned invalid handle on success! (hIf1)\n");
723	g_cErrors++;
724	}
725
726	if (hIf1 != INTNET_HANDLE_INVALID)
727	rc = INTNETR0IfClose(pIntNet, hIf1, g_pSession);
728	}
729	else
730	{
731	RTPrintf("tstIntNetR0: INTNETOpen failed for the 2nd interface! rc=%Rrc\n", rc);
732	g_cErrors++;
733	}
734
735	if (hIf0 != INTNET_HANDLE_INVALID)
736	rc = INTNETR0IfClose(pIntNet, hIf0, g_pSession);
737	}
738	else
739	{
740	RTPrintf("tstIntNetR0: INTNETOpen returned invalid handle on success! (hIf0)\n");
741	g_cErrors++;
742	}
743	}
744	else
745	{
746	RTPrintf("tstIntNetR0: INTNETOpen failed for the 1st interface! rc=%Rrc\n", rc);
747	g_cErrors++;
748	}
749
750	/*
751	* Destroy the service.
752	*/
753	INTNETR0Destroy(pIntNet);
754
755	/*
756	* Summary.
757	*/
758	if (!g_cErrors)
759	RTPrintf("tstIntNetR0: SUCCESS\n");
760	else
761	RTPrintf("tstIntNetR0: FAILURE - %d errors\n", g_cErrors);
762
763	return !!g_cErrors;
764	}
765

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

source: vbox/trunk/src/VBox/Devices/Network/testcase/tstIntNetR0.cpp@ 16444

Download in other formats: