DrvChar.cpp@ 68240

Last change on this file since 68240 was 62908, checked in by vboxsync, 8 years ago
Devices: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 14.9 KB

Line
1	/* $Id: DrvChar.cpp 62908 2016-08-03 11:33:27Z vboxsync $ */
2	/** @file
3	* Driver that adapts PDMISTREAM into PDMICHARCONNECTOR / PDMICHARPORT.
4	*
5	* Converts synchronous calls (PDMICHARCONNECTOR::pfnWrite, PDMISTREAM::pfnRead)
6	* into asynchronous ones.
7	*
8	* Note that we don't use a send buffer here to be able to handle
9	* dropping of bytes for xmit at device level.
10	*/
11
12	/*
13	* Copyright (C) 2006-2016 Oracle Corporation
14	*
15	* This file is part of VirtualBox Open Source Edition (OSE), as
16	* available from http://www.virtualbox.org. This file is free software;
17	* you can redistribute it and/or modify it under the terms of the GNU
18	* General Public License (GPL) as published by the Free Software
19	* Foundation, in version 2 as it comes in the "COPYING" file of the
20	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
21	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
22	*/
23
24
25	/*********************************************************************************************************************************
26	* Header Files *
27	*********************************************************************************************************************************/
28	#define LOG_GROUP LOG_GROUP_DRV_CHAR
29	#include <VBox/vmm/pdmdrv.h>
30	#include <iprt/asm.h>
31	#include <iprt/assert.h>
32	#include <iprt/stream.h>
33	#include <iprt/semaphore.h>
34	#include <iprt/uuid.h>
35
36	#include "VBoxDD.h"
37
38
39	/*********************************************************************************************************************************
40	* Defined Constants And Macros *
41	*********************************************************************************************************************************/
42	/** Converts a pointer to DRVCHAR::ICharConnector to a PDRVCHAR. */
43	#define PDMICHAR_2_DRVCHAR(pInterface) RT_FROM_MEMBER(pInterface, DRVCHAR, ICharConnector)
44
45
46	/*********************************************************************************************************************************
47	* Structures and Typedefs *
48	*********************************************************************************************************************************/
49	/**
50	* Char driver instance data.
51	*
52	* @implements PDMICHARCONNECTOR
53	*/
54	typedef struct DRVCHAR
55	{
56	/** Pointer to the driver instance structure. */
57	PPDMDRVINS pDrvIns;
58	/** Pointer to the char port interface of the driver/device above us. */
59	PPDMICHARPORT pDrvCharPort;
60	/** Pointer to the stream interface of the driver below us. */
61	PPDMISTREAM pDrvStream;
62	/** Our char interface. */
63	PDMICHARCONNECTOR ICharConnector;
64	/** Flag to notify the receive thread it should terminate. */
65	volatile bool fShutdown;
66	/** Receive thread ID. */
67	RTTHREAD ReceiveThread;
68	/** Send thread ID. */
69	RTTHREAD SendThread;
70	/** Send event semaphore */
71	RTSEMEVENT SendSem;
72
73	/** Internal send FIFO queue */
74	uint8_t volatile u8SendByte;
75	bool volatile fSending;
76	uint8_t Alignment[2];
77
78	/** Read/write statistics */
79	STAMCOUNTER StatBytesRead;
80	STAMCOUNTER StatBytesWritten;
81	} DRVCHAR, *PDRVCHAR;
82	AssertCompileMemberAlignment(DRVCHAR, StatBytesRead, 8);
83
84
85
86
87	/* -=-=-=-=- IBase -=-=-=-=- */
88
89	/**
90	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
91	*/
92	static DECLCALLBACK(void ) drvCharQueryInterface(PPDMIBASE pInterface, const char pszIID)
93	{
94	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
95	PDRVCHAR pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
96
97	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
98	PDMIBASE_RETURN_INTERFACE(pszIID, PDMICHARCONNECTOR, &pThis->ICharConnector);
99	return NULL;
100	}
101
102
103	/* -=-=-=-=- ICharConnector -=-=-=-=- */
104
105	/**
106	* @interface_method_impl{PDMICHARCONNECTOR,pfnWrite}
107	*/
108	static DECLCALLBACK(int) drvCharWrite(PPDMICHARCONNECTOR pInterface, const void *pvBuf, size_t cbWrite)
109	{
110	PDRVCHAR pThis = PDMICHAR_2_DRVCHAR(pInterface);
111	const char pbBuffer = (const char )pvBuf;
112
113	LogFlow(("%s: pvBuf=%#p cbWrite=%d\n", __FUNCTION__, pvBuf, cbWrite));
114
115	for (uint32_t i = 0; i < cbWrite; i++)
116	{
117	if (ASMAtomicXchgBool(&pThis->fSending, true))
118	return VERR_BUFFER_OVERFLOW;
119
120	pThis->u8SendByte = pbBuffer[i];
121	RTSemEventSignal(pThis->SendSem);
122	STAM_COUNTER_INC(&pThis->StatBytesWritten);
123	}
124	return VINF_SUCCESS;
125	}
126
127
128	/**
129	* @interface_method_impl{PDMICHARCONNECTOR,pfnSetParameters}
130	*/
131	static DECLCALLBACK(int) drvCharSetParameters(PPDMICHARCONNECTOR pInterface, unsigned Bps, char chParity,
132	unsigned cDataBits, unsigned cStopBits)
133	{
134	RT_NOREF(pInterface, Bps, chParity, cDataBits, cStopBits);
135	/PDRVCHAR pThis = PDMICHAR_2_DRVCHAR(pInterface); - unused/
136
137	LogFlow(("%s: Bps=%u chParity=%c cDataBits=%u cStopBits=%u\n", __FUNCTION__, Bps, chParity, cDataBits, cStopBits));
138	return VINF_SUCCESS;
139	}
140
141
142	/* -=-=-=-=- receive thread -=-=-=-=- */
143
144	/**
145	* Send thread loop - pushes data down thru the driver chain.
146	*
147	* @returns 0 on success.
148	* @param hThreadSelf Thread handle to this thread.
149	* @param pvUser User argument.
150	*/
151	static DECLCALLBACK(int) drvCharSendLoop(RTTHREAD hThreadSelf, void *pvUser)
152	{
153	RT_NOREF(hThreadSelf);
154	PDRVCHAR pThis = (PDRVCHAR)pvUser;
155
156	int rc = VINF_SUCCESS;
157	while (!pThis->fShutdown)
158	{
159	RTMSINTERVAL cMillies = (rc == VERR_TIMEOUT) ? 50 : RT_INDEFINITE_WAIT;
160	rc = RTSemEventWait(pThis->SendSem, cMillies);
161	if ( RT_FAILURE(rc)
162	&& rc != VERR_TIMEOUT)
163	break;
164
165	/*
166	* Write the character to the attached stream (if present).
167	*/
168	if ( pThis->fShutdown
169	\|\| !pThis->pDrvStream)
170	break;
171
172	size_t cbProcessed = 1;
173	uint8_t ch = pThis->u8SendByte;
174	rc = pThis->pDrvStream->pfnWrite(pThis->pDrvStream, &ch, &cbProcessed);
175	if (RT_SUCCESS(rc))
176	{
177	ASMAtomicXchgBool(&pThis->fSending, false);
178	Assert(cbProcessed == 1);
179	}
180	else if (rc == VERR_TIMEOUT)
181	{
182	/* Normal case, just means that the stream didn't accept a new
183	* character before the timeout elapsed. Just retry. */
184
185	/* do not change the rc status here, otherwise the (rc == VERR_TIMEOUT) branch
186	* in the wait above will never get executed */
187	/* rc = VINF_SUCCESS; */
188	}
189	else
190	{
191	LogRel(("Write failed with %Rrc; skipping\n", rc));
192	break;
193	}
194	}
195
196	return VINF_SUCCESS;
197	}
198
199
200	/* -=-=-=-=- receive thread -=-=-=-=- */
201
202	/**
203	* Receive thread loop.
204	*
205	* @returns 0 on success.
206	* @param hThreadSelf Thread handle to this thread.
207	* @param pvUser User argument.
208	*/
209	static DECLCALLBACK(int) drvCharReceiveLoop(RTTHREAD hThreadSelf, void *pvUser)
210	{
211	RT_NOREF(hThreadSelf);
212	PDRVCHAR pThis = (PDRVCHAR)pvUser;
213	char abBuffer[256];
214	char *pbRemaining = abBuffer;
215	size_t cbRemaining = 0;
216	int rc;
217
218	while (!pThis->fShutdown)
219	{
220	if (!cbRemaining)
221	{
222	/* Get block of data from stream driver. */
223	if (pThis->pDrvStream)
224	{
225	pbRemaining = abBuffer;
226	cbRemaining = sizeof(abBuffer);
227	rc = pThis->pDrvStream->pfnRead(pThis->pDrvStream, abBuffer, &cbRemaining);
228	if (RT_FAILURE(rc))
229	{
230	LogFlow(("Read failed with %Rrc\n", rc));
231	break;
232	}
233	}
234	else
235	RTThreadSleep(100);
236	}
237	else
238	{
239	/* Send data to guest. */
240	size_t cbProcessed = cbRemaining;
241	rc = pThis->pDrvCharPort->pfnNotifyRead(pThis->pDrvCharPort, pbRemaining, &cbProcessed);
242	if (RT_SUCCESS(rc))
243	{
244	Assert(cbProcessed);
245	pbRemaining += cbProcessed;
246	cbRemaining -= cbProcessed;
247	STAM_COUNTER_ADD(&pThis->StatBytesRead, cbProcessed);
248	}
249	else if (rc == VERR_TIMEOUT)
250	{
251	/* Normal case, just means that the guest didn't accept a new
252	* character before the timeout elapsed. Just retry. */
253	rc = VINF_SUCCESS;
254	}
255	else
256	{
257	LogFlow(("NotifyRead failed with %Rrc\n", rc));
258	break;
259	}
260	}
261	}
262
263	return VINF_SUCCESS;
264	}
265
266
267	/**
268	* @callback_method_impl{PDMICHARCONNECTOR,pfnSetModemLines}
269	*/
270	static DECLCALLBACK(int) drvCharSetModemLines(PPDMICHARCONNECTOR pInterface, bool fRequestToSend, bool fDataTerminalReady)
271	{
272	/* Nothing to do here. */
273	RT_NOREF(pInterface, fRequestToSend, fDataTerminalReady);
274	return VINF_SUCCESS;
275	}
276
277
278	/**
279	* @callback_method_impl{PDMICHARCONNECTOR,pfnSetBreak}
280	*/
281	static DECLCALLBACK(int) drvCharSetBreak(PPDMICHARCONNECTOR pInterface, bool fBreak)
282	{
283	/* Nothing to do here. */
284	RT_NOREF(pInterface, fBreak);
285	return VINF_SUCCESS;
286	}
287
288
289	/* -=-=-=-=- driver interface -=-=-=-=- */
290
291	/**
292	* Destruct a char driver instance.
293	*
294	* Most VM resources are freed by the VM. This callback is provided so that
295	* any non-VM resources can be freed correctly.
296	*
297	* @param pDrvIns The driver instance data.
298	*/
299	static DECLCALLBACK(void) drvCharDestruct(PPDMDRVINS pDrvIns)
300	{
301	PDRVCHAR pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
302	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
303	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
304
305	/*
306	* Tell the threads to shut down.
307	*/
308	pThis->fShutdown = true;
309	if (pThis->SendSem != NIL_RTSEMEVENT)
310	{
311	RTSemEventSignal(pThis->SendSem);
312	pThis->SendSem = NIL_RTSEMEVENT;
313	}
314
315	/*
316	* Wait for the threads.
317	* ASSUMES that PDM destroys the driver chain from the bottom and up.
318	*/
319	if (pThis->ReceiveThread != NIL_RTTHREAD)
320	{
321	int rc = RTThreadWait(pThis->ReceiveThread, 30000, NULL);
322	if (RT_SUCCESS(rc))
323	pThis->ReceiveThread = NIL_RTTHREAD;
324	else
325	LogRel(("Char%d: receive thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
326	}
327
328	if (pThis->SendThread != NIL_RTTHREAD)
329	{
330	int rc = RTThreadWait(pThis->SendThread, 30000, NULL);
331	if (RT_SUCCESS(rc))
332	pThis->SendThread = NIL_RTTHREAD;
333	else
334	LogRel(("Char%d: send thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
335	}
336
337	if (pThis->SendSem != NIL_RTSEMEVENT)
338	{
339	RTSemEventDestroy(pThis->SendSem);
340	pThis->SendSem = NIL_RTSEMEVENT;
341	}
342	}
343
344
345	/**
346	* Construct a char driver instance.
347	*
348	* @copydoc FNPDMDRVCONSTRUCT
349	*/
350	static DECLCALLBACK(int) drvCharConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
351	{
352	RT_NOREF(pCfg);
353	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
354	PDRVCHAR pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
355	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
356
357	/*
358	* Init basic data members and interfaces.
359	*/
360	pThis->fShutdown = false;
361	pThis->ReceiveThread = NIL_RTTHREAD;
362	pThis->SendThread = NIL_RTTHREAD;
363	pThis->SendSem = NIL_RTSEMEVENT;
364	/* IBase. */
365	pDrvIns->IBase.pfnQueryInterface = drvCharQueryInterface;
366	/* ICharConnector. */
367	pThis->ICharConnector.pfnWrite = drvCharWrite;
368	pThis->ICharConnector.pfnSetParameters = drvCharSetParameters;
369	pThis->ICharConnector.pfnSetModemLines = drvCharSetModemLines;
370	pThis->ICharConnector.pfnSetBreak = drvCharSetBreak;
371
372	/*
373	* Get the ICharPort interface of the above driver/device.
374	*/
375	pThis->pDrvCharPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMICHARPORT);
376	if (!pThis->pDrvCharPort)
377	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("Char#%d has no char port interface above"), pDrvIns->iInstance);
378
379	/*
380	* Attach driver below and query its stream interface.
381	*/
382	PPDMIBASE pBase;
383	int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pBase);
384	if (RT_FAILURE(rc))
385	return rc; /* Don't call PDMDrvHlpVMSetError here as we assume that the driver already set an appropriate error */
386	pThis->pDrvStream = PDMIBASE_QUERY_INTERFACE(pBase, PDMISTREAM);
387	if (!pThis->pDrvStream)
388	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW, RT_SRC_POS, N_("Char#%d has no stream interface below"), pDrvIns->iInstance);
389
390	/*
391	* Don't start the receive thread if the driver doesn't support reading
392	*/
393	if (pThis->pDrvStream->pfnRead)
394	{
395	rc = RTThreadCreate(&pThis->ReceiveThread, drvCharReceiveLoop, (void *)pThis, 0,
396	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharRecv");
397	if (RT_FAILURE(rc))
398	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Char#%d cannot create receive thread"), pDrvIns->iInstance);
399	}
400
401	rc = RTSemEventCreate(&pThis->SendSem);
402	AssertRCReturn(rc, rc);
403
404	rc = RTThreadCreate(&pThis->SendThread, drvCharSendLoop, (void *)pThis, 0,
405	RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharSend");
406	if (RT_FAILURE(rc))
407	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Char#%d cannot create send thread"), pDrvIns->iInstance);
408
409
410	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written", "/Devices/Char%d/Written", pDrvIns->iInstance);
411	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read", "/Devices/Char%d/Read", pDrvIns->iInstance);
412
413	return VINF_SUCCESS;
414	}
415
416
417	/**
418	* Char driver registration record.
419	*/
420	const PDMDRVREG g_DrvChar =
421	{
422	/* u32Version */
423	PDM_DRVREG_VERSION,
424	/* szName */
425	"Char",
426	/* szRCMod */
427	"",
428	/* szR0Mod */
429	"",
430	/* pszDescription */
431	"Generic char driver.",
432	/* fFlags */
433	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
434	/* fClass. */
435	PDM_DRVREG_CLASS_CHAR,
436	/* cMaxInstances */
437	~0U,
438	/* cbInstance */
439	sizeof(DRVCHAR),
440	/* pfnConstruct */
441	drvCharConstruct,
442	/* pfnDestruct */
443	drvCharDestruct,
444	/* pfnRelocate */
445	NULL,
446	/* pfnIOCtl */
447	NULL,
448	/* pfnPowerOn */
449	NULL,
450	/* pfnReset */
451	NULL,
452	/* pfnSuspend */
453	NULL,
454	/* pfnResume */
455	NULL,
456	/* pfnAttach */
457	NULL,
458	/* pfnDetach */
459	NULL,
460	/* pfnPowerOff */
461	NULL,
462	/* pfnSoftReset */
463	NULL,
464	/* u32EndVersion */
465	PDM_DRVREG_VERSION
466	};

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

source: vbox/trunk/src/VBox/Devices/Serial/DrvChar.cpp@ 68240

Download in other formats: