DrvChar.cpp@ 8971

Last change on this file since 8971 was 8155, checked in by vboxsync, 17 years ago
The Big Sun Rebranding Header Change
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 13.7 KB

Line
1	/** @file
2	*
3	* VBox stream I/O devices:
4	* Generic char driver
5	*/
6
7	/*
8	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
9	*
10	* This file is part of VirtualBox Open Source Edition (OSE), as
11	* available from http://www.virtualbox.org. This file is free software;
12	* you can redistribute it and/or modify it under the terms of the GNU
13	* General Public License (GPL) as published by the Free Software
14	* Foundation, in version 2 as it comes in the "COPYING" file of the
15	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17	*
18	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
19	* Clara, CA 95054 USA or visit http://www.sun.com if you need
20	* additional information or have any questions.
21	*/
22
23
24
25	/*******************************************************************************
26	* Header Files *
27	*******************************************************************************/
28	#define LOG_GROUP LOG_GROUP_DRV_CHAR
29	#include <VBox/pdmdrv.h>
30	#include <iprt/asm.h>
31	#include <iprt/assert.h>
32	#include <iprt/stream.h>
33	#include <iprt/semaphore.h>
34
35	#include "Builtins.h"
36
37
38	/** Size of the send fifo queue (in bytes) */
39	#define CHAR_MAX_SEND_QUEUE 0x80
40	#define CHAR_MAX_SEND_QUEUE_MASK 0x7f
41
42	/*******************************************************************************
43	* Structures and Typedefs *
44	*******************************************************************************/
45
46	/**
47	* Char driver instance data.
48	*/
49	typedef struct DRVCHAR
50	{
51	/** Pointer to the driver instance structure. */
52	PPDMDRVINS pDrvIns;
53	/** Pointer to the char port interface of the driver/device above us. */
54	PPDMICHARPORT pDrvCharPort;
55	/** Pointer to the stream interface of the driver below us. */
56	PPDMISTREAM pDrvStream;
57	/** Our char interface. */
58	PDMICHAR IChar;
59	/** Flag to notify the receive thread it should terminate. */
60	volatile bool fShutdown;
61	/** Receive thread ID. */
62	RTTHREAD ReceiveThread;
63	/** Send thread ID. */
64	RTTHREAD SendThread;
65	/** Send event semephore */
66	RTSEMEVENT SendSem;
67
68	/** Internal send FIFO queue */
69	uint8_t aSendQueue[CHAR_MAX_SEND_QUEUE];
70	uint32_t iSendQueueHead;
71	uint32_t iSendQueueTail;
72
73	/** Read/write statistics */
74	STAMCOUNTER StatBytesRead;
75	STAMCOUNTER StatBytesWritten;
76	} DRVCHAR, *PDRVCHAR;
77
78
79	/** Converts a pointer to DRVCHAR::IChar to a PDRVCHAR. */
80	#define PDMICHAR_2_DRVCHAR(pInterface) ( (PDRVCHAR)((uintptr_t)pInterface - RT_OFFSETOF(DRVCHAR, IChar)) )
81
82
83	/* -=-=-=-=- IBase -=-=-=-=- */
84
85	/**
86	* Queries an interface to the driver.
87	*
88	* @returns Pointer to interface.
89	* @returns NULL if the interface was not supported by the driver.
90	* @param pInterface Pointer to this interface structure.
91	* @param enmInterface The requested interface identification.
92	*/
93	static DECLCALLBACK(void *) drvCharQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
94	{
95	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
96	PDRVCHAR pData = PDMINS2DATA(pDrvIns, PDRVCHAR);
97	switch (enmInterface)
98	{
99	case PDMINTERFACE_BASE:
100	return &pDrvIns->IBase;
101	case PDMINTERFACE_CHAR:
102	return &pData->IChar;
103	default:
104	return NULL;
105	}
106	}
107
108
109	/* -=-=-=-=- IChar -=-=-=-=- */
110
111	/** @copydoc PDMICHAR::pfnWrite */
112	static DECLCALLBACK(int) drvCharWrite(PPDMICHAR pInterface, const void *pvBuf, size_t cbWrite)
113	{
114	PDRVCHAR pData = PDMICHAR_2_DRVCHAR(pInterface);
115	const char pBuffer = (const char )pvBuf;
116
117	LogFlow(("%s: pvBuf=%#p cbWrite=%d\n", __FUNCTION__, pvBuf, cbWrite));
118
119	for (uint32_t i=0;i<cbWrite;i++)
120	{
121	uint32_t idx = pData->iSendQueueHead;
122
123	pData->aSendQueue[idx] = pBuffer[i];
124	idx = (idx + 1) & CHAR_MAX_SEND_QUEUE_MASK;
125
126	STAM_COUNTER_INC(&pData->StatBytesWritten);
127	ASMAtomicXchgU32(&pData->iSendQueueHead, idx);
128	}
129	RTSemEventSignal(pData->SendSem);
130	return VINF_SUCCESS;
131	}
132
133	/** @copydoc PDMICHAR::pfnSetParameters */
134	static DECLCALLBACK(int) drvCharSetParameters(PPDMICHAR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits)
135	{
136	/PDRVCHAR pData = PDMICHAR_2_DRVCHAR(pInterface); - unused/
137
138	LogFlow(("%s: Bps=%u chParity=%c cDataBits=%u cStopBits=%u\n", __FUNCTION__, Bps, chParity, cDataBits, cStopBits));
139	return VINF_SUCCESS;
140	}
141
142
143	/* -=-=-=-=- receive thread -=-=-=-=- */
144
145	/**
146	* Send thread loop.
147	*
148	* @returns 0 on success.
149	* @param ThreadSelf Thread handle to this thread.
150	* @param pvUser User argument.
151	*/
152	static DECLCALLBACK(int) drvCharSendLoop(RTTHREAD ThreadSelf, void *pvUser)
153	{
154	PDRVCHAR pData = (PDRVCHAR)pvUser;
155
156	for(;;)
157	{
158	int rc = RTSemEventWait(pData->SendSem, RT_INDEFINITE_WAIT);
159	if (VBOX_FAILURE(rc))
160	break;
161
162	/*
163	* Write the character to the attached stream (if present).
164	*/
165	if ( !pData->fShutdown
166	&& pData->pDrvStream)
167	{
168	while (pData->iSendQueueTail != pData->iSendQueueHead)
169	{
170	size_t cbProcessed = 1;
171
172	rc = pData->pDrvStream->pfnWrite(pData->pDrvStream, &pData->aSendQueue[pData->iSendQueueTail], &cbProcessed);
173	if (VBOX_SUCCESS(rc))
174	{
175	Assert(cbProcessed);
176	pData->iSendQueueTail++;
177	pData->iSendQueueTail &= CHAR_MAX_SEND_QUEUE_MASK;
178	}
179	else if (rc == VERR_TIMEOUT)
180	{
181	/* Normal case, just means that the stream didn't accept a new
182	* character before the timeout elapsed. Just retry. */
183	rc = VINF_SUCCESS;
184	}
185	else
186	{
187	LogFlow(("Write failed with %Vrc; skipping\n", rc));
188	break;
189	}
190	}
191	}
192	else
193	break;
194	}
195
196	pData->SendThread = NIL_RTTHREAD;
197
198	return VINF_SUCCESS;
199	}
200
201	/* -=-=-=-=- receive thread -=-=-=-=- */
202
203	/**
204	* Receive thread loop.
205	*
206	* @returns 0 on success.
207	* @param ThreadSelf Thread handle to this thread.
208	* @param pvUser User argument.
209	*/
210	static DECLCALLBACK(int) drvCharReceiveLoop(RTTHREAD ThreadSelf, void *pvUser)
211	{
212	PDRVCHAR pData = (PDRVCHAR)pvUser;
213	char aBuffer[256], *pBuffer;
214	size_t cbRemaining, cbProcessed;
215	int rc;
216
217	cbRemaining = 0;
218	pBuffer = aBuffer;
219	while (!pData->fShutdown)
220	{
221	if (!cbRemaining)
222	{
223	/* Get block of data from stream driver. */
224	if (pData->pDrvStream)
225	{
226	cbRemaining = sizeof(aBuffer);
227	rc = pData->pDrvStream->pfnRead(pData->pDrvStream, aBuffer, &cbRemaining);
228	if (VBOX_FAILURE(rc))
229	{
230	LogFlow(("Read failed with %Vrc\n", rc));
231	break;
232	}
233	}
234	else
235	{
236	cbRemaining = 0;
237	RTThreadSleep(100);
238	}
239	pBuffer = aBuffer;
240	}
241	else
242	{
243	/* Send data to guest. */
244	cbProcessed = cbRemaining;
245	rc = pData->pDrvCharPort->pfnNotifyRead(pData->pDrvCharPort, pBuffer, &cbProcessed);
246	if (VBOX_SUCCESS(rc))
247	{
248	Assert(cbProcessed);
249	pBuffer += cbProcessed;
250	cbRemaining -= cbProcessed;
251	STAM_COUNTER_ADD(&pData->StatBytesRead, cbProcessed);
252	}
253	else if (rc == VERR_TIMEOUT)
254	{
255	/* Normal case, just means that the guest didn't accept a new
256	* character before the timeout elapsed. Just retry. */
257	rc = VINF_SUCCESS;
258	}
259	else
260	{
261	LogFlow(("NotifyRead failed with %Vrc\n", rc));
262	break;
263	}
264	}
265	}
266
267	pData->ReceiveThread = NIL_RTTHREAD;
268
269	return VINF_SUCCESS;
270	}
271
272	/**
273	* Set the modem lines.
274	*
275	* @returns VBox status code
276	* @param pInterface Pointer to the interface structure.
277	* @param RequestToSend Set to true if this control line should be made active.
278	* @param DataTerminalReady Set to true if this control line should be made active.
279	*/
280	static DECLCALLBACK(int) drvCharSetModemLines(PPDMICHAR pInterface, bool RequestToSend, bool DataTerminalReady)
281	{
282	/* Nothing to do here. */
283	return VINF_SUCCESS;
284	}
285
286	/* -=-=-=-=- driver interface -=-=-=-=- */
287
288	/**
289	* Construct a char driver instance.
290	*
291	* @returns VBox status.
292	* @param pDrvIns The driver instance data.
293	* If the registration structure is needed,
294	* pDrvIns->pDrvReg points to it.
295	* @param pCfgHandle Configuration node handle for the driver. Use this to
296	* obtain the configuration of the driver instance. It's
297	* also found in pDrvIns->pCfgHandle as it's expected to
298	* be used frequently in this function.
299	*/
300	static DECLCALLBACK(int) drvCharConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
301	{
302	PDRVCHAR pData = PDMINS2DATA(pDrvIns, PDRVCHAR);
303	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
304
305	/*
306	* Init basic data members and interfaces.
307	*/
308	pData->ReceiveThread = NIL_RTTHREAD;
309	pData->fShutdown = false;
310	/* IBase. */
311	pDrvIns->IBase.pfnQueryInterface = drvCharQueryInterface;
312	/* IChar. */
313	pData->IChar.pfnWrite = drvCharWrite;
314	pData->IChar.pfnSetParameters = drvCharSetParameters;
315	pData->IChar.pfnSetModemLines = drvCharSetModemLines;
316
317	/*
318	* Get the ICharPort interface of the above driver/device.
319	*/
320	pData->pDrvCharPort = (PPDMICHARPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_CHAR_PORT);
321	if (!pData->pDrvCharPort)
322	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("Char#%d has no char port interface above"), pDrvIns->iInstance);
323
324	/*
325	* Attach driver below and query its stream interface.
326	*/
327	PPDMIBASE pBase;
328	int rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pBase);
329	if (VBOX_FAILURE(rc))
330	return rc; /* Don't call PDMDrvHlpVMSetError here as we assume that the driver already set an appropriate error */
331	pData->pDrvStream = (PPDMISTREAM)pBase->pfnQueryInterface(pBase, PDMINTERFACE_STREAM);
332	if (!pData->pDrvStream)
333	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_BELOW, RT_SRC_POS, N_("Char#%d has no stream interface below"), pDrvIns->iInstance);
334
335	rc = RTThreadCreate(&pData->ReceiveThread, drvCharReceiveLoop, (void *)pData, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharRecv");
336	if (VBOX_FAILURE(rc))
337	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Char#%d cannot create receive thread"), pDrvIns->iInstance);
338
339	rc = RTSemEventCreate(&pData->SendSem);
340	AssertRC(rc);
341
342	rc = RTThreadCreate(&pData->SendThread, drvCharSendLoop, (void *)pData, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "CharSend");
343	if (VBOX_FAILURE(rc))
344	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("Char#%d cannot create send thread"), pDrvIns->iInstance);
345
346
347	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written", "/Devices/Char%d/Written", pDrvIns->iInstance);
348	PDMDrvHlpSTAMRegisterF(pDrvIns, &pData->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read", "/Devices/Char%d/Read", pDrvIns->iInstance);
349
350	return VINF_SUCCESS;
351	}
352
353
354	/**
355	* Destruct a char driver instance.
356	*
357	* Most VM resources are freed by the VM. This callback is provided so that
358	* any non-VM resources can be freed correctly.
359	*
360	* @param pDrvIns The driver instance data.
361	*/
362	static DECLCALLBACK(void) drvCharDestruct(PPDMDRVINS pDrvIns)
363	{
364	PDRVCHAR pData = PDMINS2DATA(pDrvIns, PDRVCHAR);
365
366	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
367
368	pData->fShutdown = true;
369	if (pData->ReceiveThread)
370	{
371	RTThreadWait(pData->ReceiveThread, 1000, NULL);
372	if (pData->ReceiveThread != NIL_RTTHREAD)
373	LogRel(("Char%d: receive thread did not terminate\n", pDrvIns->iInstance));
374	}
375
376	/* Empty the send queue */
377	pData->iSendQueueTail = pData->iSendQueueHead = 0;
378
379	RTSemEventSignal(pData->SendSem);
380	RTSemEventDestroy(pData->SendSem);
381	pData->SendSem = NIL_RTSEMEVENT;
382
383	if (pData->SendThread)
384	{
385	RTThreadWait(pData->SendThread, 1000, NULL);
386	if (pData->SendThread != NIL_RTTHREAD)
387	LogRel(("Char%d: send thread did not terminate\n", pDrvIns->iInstance));
388	}
389	}
390
391	/**
392	* Char driver registration record.
393	*/
394	const PDMDRVREG g_DrvChar =
395	{
396	/* u32Version */
397	PDM_DRVREG_VERSION,
398	/* szDriverName */
399	"Char",
400	/* pszDescription */
401	"Generic char driver.",
402	/* fFlags */
403	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
404	/* fClass. */
405	PDM_DRVREG_CLASS_CHAR,
406	/* cMaxInstances */
407	~0,
408	/* cbInstance */
409	sizeof(DRVCHAR),
410	/* pfnConstruct */
411	drvCharConstruct,
412	/* pfnDestruct */
413	drvCharDestruct,
414	/* pfnIOCtl */
415	NULL,
416	/* pfnPowerOn */
417	NULL,
418	/* pfnReset */
419	NULL,
420	/* pfnSuspend */
421	NULL,
422	/* pfnResume */
423	NULL,
424	/* pfnDetach */
425	NULL,
426	/** pfnPowerOff */
427	NULL
428	};
429

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

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

Download in other formats: