DrvHostSerial.cpp@ 84909

Last change on this file since 84909 was 83522, checked in by vboxsync, 5 years ago
Devices/Serial/DrvHostSerial: Show a warning when the serial port encounters a fatal error and stop any I/O activity. Upon a suspend/resume cycle the serial port is reopened if a fatal error was encountered previously to try restarting I/O. [doxygen fix]
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.5 KB

Line
1	/* $Id: DrvHostSerial.cpp 83522 2020-04-03 08:58:00Z vboxsync $ */
2	/** @file
3	* VBox serial devices: Host serial driver
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19
20	/*********************************************************************************************************************************
21	* Header Files *
22	*********************************************************************************************************************************/
23	#define LOG_GROUP LOG_GROUP_DRV_HOST_SERIAL
24	#include <VBox/vmm/pdm.h>
25	#include <VBox/vmm/pdmserialifs.h>
26	#include <VBox/err.h>
27
28	#include <VBox/log.h>
29	#include <iprt/asm.h>
30	#include <iprt/assert.h>
31	#include <iprt/file.h>
32	#include <iprt/mem.h>
33	#include <iprt/pipe.h>
34	#include <iprt/semaphore.h>
35	#include <iprt/uuid.h>
36	#include <iprt/serialport.h>
37
38	#include "VBoxDD.h"
39
40
41	/*********************************************************************************************************************************
42	* Structures and Typedefs *
43	*********************************************************************************************************************************/
44
45	/**
46	* Char driver instance data.
47	*
48	* @implements PDMISERIALCONNECTOR
49	*/
50	typedef struct DRVHOSTSERIAL
51	{
52	/** Pointer to the driver instance structure. */
53	PPDMDRVINS pDrvIns;
54	/** Pointer to the serial port interface of the driver/device above us. */
55	PPDMISERIALPORT pDrvSerialPort;
56	/** Our serial interface. */
57	PDMISERIALCONNECTOR ISerialConnector;
58	/** I/O thread. */
59	PPDMTHREAD pIoThrd;
60	/** The serial port handle. */
61	RTSERIALPORT hSerialPort;
62	/** the device path */
63	char *pszDevicePath;
64	/** The active config of the serial port. */
65	RTSERIALPORTCFG Cfg;
66
67	/** Flag whether data is available from the device/driver above as notified by the driver. */
68	volatile bool fAvailWrExt;
69	/** Internal copy of the flag which gets reset when there is no data anymore. */
70	bool fAvailWrInt;
71	/** Small send buffer. */
72	uint8_t abTxBuf[16];
73	/** Amount of data in the buffer. */
74	size_t cbTxUsed;
75
76	/** The read queue. */
77	uint8_t abReadBuf[256];
78	/** Current offset to write to next. */
79	volatile uint32_t offWrite;
80	/** Current offset into the read buffer. */
81	volatile uint32_t offRead;
82	/** Current amount of data in the buffer. */
83	volatile size_t cbReadBuf;
84
85	/* Flag whether the host device ran into a fatal error condition and I/O is suspended
86	* until the nuext VM suspend/resume cycle where we will try again. */
87	volatile bool fIoFatalErr;
88	/** Event semaphore the I/O thread is waiting on */
89	RTSEMEVENT hSemEvtIoFatalErr;
90
91	/** Read/write statistics */
92	STAMCOUNTER StatBytesRead;
93	STAMCOUNTER StatBytesWritten;
94	} DRVHOSTSERIAL, *PDRVHOSTSERIAL;
95
96
97	/*********************************************************************************************************************************
98	* Global Variables *
99	*********************************************************************************************************************************/
100
101
102	/*********************************************************************************************************************************
103	* Internal Functions *
104	*********************************************************************************************************************************/
105
106
107	/**
108	* Resets the read buffer.
109	*
110	* @returns Number of bytes which were queued in the read buffer before reset.
111	* @param pThis The host serial driver instance.
112	*/
113	DECLINLINE(size_t) drvHostSerialReadBufReset(PDRVHOSTSERIAL pThis)
114	{
115	size_t cbOld = ASMAtomicXchgZ(&pThis->cbReadBuf, 0);
116	ASMAtomicWriteU32(&pThis->offWrite, 0);
117	ASMAtomicWriteU32(&pThis->offRead, 0);
118
119	return cbOld;
120	}
121
122
123	/**
124	* Returns number of bytes free in the read buffer and pointer to the start of the free space
125	* in the read buffer.
126	*
127	* @returns Number of bytes free in the buffer.
128	* @param pThis The host serial driver instance.
129	* @param ppv Where to return the pointer if there is still free space.
130	*/
131	DECLINLINE(size_t) drvHostSerialReadBufGetWrite(PDRVHOSTSERIAL pThis, void **ppv)
132	{
133	if (ppv)
134	*ppv = &pThis->abReadBuf[pThis->offWrite];
135
136	size_t cbFree = sizeof(pThis->abReadBuf) - ASMAtomicReadZ(&pThis->cbReadBuf);
137	if (cbFree)
138	cbFree = RT_MIN(cbFree, sizeof(pThis->abReadBuf) - pThis->offWrite);
139
140	return cbFree;
141	}
142
143
144	/**
145	* Returns number of bytes used in the read buffer and pointer to the next byte to read.
146	*
147	* @returns Number of bytes free in the buffer.
148	* @param pThis The host serial driver instance.
149	* @param ppv Where to return the pointer to the next data to read.
150	*/
151	DECLINLINE(size_t) drvHostSerialReadBufGetRead(PDRVHOSTSERIAL pThis, void **ppv)
152	{
153	if (ppv)
154	*ppv = &pThis->abReadBuf[pThis->offRead];
155
156	size_t cbUsed = ASMAtomicReadZ(&pThis->cbReadBuf);
157	if (cbUsed)
158	cbUsed = RT_MIN(cbUsed, sizeof(pThis->abReadBuf) - pThis->offRead);
159
160	return cbUsed;
161	}
162
163
164	/**
165	* Advances the write position of the read buffer by the given amount of bytes.
166	*
167	* @returns nothing.
168	* @param pThis The host serial driver instance.
169	* @param cbAdv Number of bytes to advance.
170	*/
171	DECLINLINE(void) drvHostSerialReadBufWriteAdv(PDRVHOSTSERIAL pThis, size_t cbAdv)
172	{
173	uint32_t offWrite = ASMAtomicReadU32(&pThis->offWrite);
174	offWrite = (offWrite + cbAdv) % sizeof(pThis->abReadBuf);
175	ASMAtomicWriteU32(&pThis->offWrite, offWrite);
176	ASMAtomicAddZ(&pThis->cbReadBuf, cbAdv);
177	}
178
179
180	/**
181	* Advances the read position of the read buffer by the given amount of bytes.
182	*
183	* @returns nothing.
184	* @param pThis The host serial driver instance.
185	* @param cbAdv Number of bytes to advance.
186	*/
187	DECLINLINE(void) drvHostSerialReadBufReadAdv(PDRVHOSTSERIAL pThis, size_t cbAdv)
188	{
189	uint32_t offRead = ASMAtomicReadU32(&pThis->offRead);
190	offRead = (offRead + cbAdv) % sizeof(pThis->abReadBuf);
191	ASMAtomicWriteU32(&pThis->offRead, offRead);
192	ASMAtomicSubZ(&pThis->cbReadBuf, cbAdv);
193	}
194
195
196	/**
197	* Wakes up the serial port I/O thread.
198	*
199	* @returns VBox status code.
200	* @param pThis The host serial driver instance.
201	*/
202	static int drvHostSerialWakeupIoThread(PDRVHOSTSERIAL pThis)
203	{
204
205	if (RT_UNLIKELY(pThis->fIoFatalErr))
206	return RTSemEventSignal(pThis->hSemEvtIoFatalErr);
207
208	return RTSerialPortEvtPollInterrupt(pThis->hSerialPort);
209	}
210
211
212	/* -=-=-=-=- IBase -=-=-=-=- */
213
214	/**
215	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
216	*/
217	static DECLCALLBACK(void ) drvHostSerialQueryInterface(PPDMIBASE pInterface, const char pszIID)
218	{
219	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
220	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
221
222	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
223	PDMIBASE_RETURN_INTERFACE(pszIID, PDMISERIALCONNECTOR, &pThis->ISerialConnector);
224	return NULL;
225	}
226
227
228	/* -=-=-=-=- ISerialConnector -=-=-=-=- */
229
230	/** @interface_method_impl{PDMISERIALCONNECTOR,pfnDataAvailWrNotify} */
231	static DECLCALLBACK(int) drvHostSerialDataAvailWrNotify(PPDMISERIALCONNECTOR pInterface)
232	{
233	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
234
235	int rc = VINF_SUCCESS;
236	bool fAvailOld = ASMAtomicXchgBool(&pThis->fAvailWrExt, true);
237	if (!fAvailOld)
238	rc = drvHostSerialWakeupIoThread(pThis);
239
240	return rc;
241	}
242
243
244	/**
245	* @interface_method_impl{PDMISERIALCONNECTOR,pfnReadRdr}
246	*/
247	static DECLCALLBACK(int) drvHostSerialReadRdr(PPDMISERIALCONNECTOR pInterface, void *pvBuf,
248	size_t cbRead, size_t *pcbRead)
249	{
250	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
251	int rc = VINF_SUCCESS;
252	uint8_t pbDst = (uint8_t )pvBuf;
253	size_t cbReadAll = 0;
254
255	do
256	{
257	void *pvSrc = NULL;
258	size_t cbThisRead = RT_MIN(drvHostSerialReadBufGetRead(pThis, &pvSrc), cbRead);
259	if (cbThisRead)
260	{
261	memcpy(pbDst, pvSrc, cbThisRead);
262	cbRead -= cbThisRead;
263	pbDst += cbThisRead;
264	cbReadAll += cbThisRead;
265	drvHostSerialReadBufReadAdv(pThis, cbThisRead);
266	}
267	else
268	break;
269	} while (cbRead > 0);
270
271	*pcbRead = cbReadAll;
272	/* Kick the I/O thread if there is nothing to read to recalculate the poll flags. */
273	if (!drvHostSerialReadBufGetRead(pThis, NULL))
274	rc = drvHostSerialWakeupIoThread(pThis);
275
276	STAM_COUNTER_ADD(&pThis->StatBytesRead, cbReadAll);
277	return rc;
278	}
279
280
281	/**
282	* @interface_method_impl{PDMISERIALCONNECTOR,pfnChgParams}
283	*/
284	static DECLCALLBACK(int) drvHostSerialChgParams(PPDMISERIALCONNECTOR pInterface, uint32_t uBps,
285	PDMSERIALPARITY enmParity, unsigned cDataBits,
286	PDMSERIALSTOPBITS enmStopBits)
287	{
288	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
289
290	pThis->Cfg.uBaudRate = uBps;
291
292	switch (enmParity)
293	{
294	case PDMSERIALPARITY_EVEN:
295	pThis->Cfg.enmParity = RTSERIALPORTPARITY_EVEN;
296	break;
297	case PDMSERIALPARITY_ODD:
298	pThis->Cfg.enmParity = RTSERIALPORTPARITY_ODD;
299	break;
300	case PDMSERIALPARITY_NONE:
301	pThis->Cfg.enmParity = RTSERIALPORTPARITY_NONE;
302	break;
303	case PDMSERIALPARITY_MARK:
304	pThis->Cfg.enmParity = RTSERIALPORTPARITY_MARK;
305	break;
306	case PDMSERIALPARITY_SPACE:
307	pThis->Cfg.enmParity = RTSERIALPORTPARITY_SPACE;
308	break;
309	default:
310	AssertMsgFailed(("Unsupported parity setting %d\n", enmParity)); /* Should not happen. */
311	pThis->Cfg.enmParity = RTSERIALPORTPARITY_NONE;
312	}
313
314	switch (cDataBits)
315	{
316	case 5:
317	pThis->Cfg.enmDataBitCount = RTSERIALPORTDATABITS_5BITS;
318	break;
319	case 6:
320	pThis->Cfg.enmDataBitCount = RTSERIALPORTDATABITS_6BITS;
321	break;
322	case 7:
323	pThis->Cfg.enmDataBitCount = RTSERIALPORTDATABITS_7BITS;
324	break;
325	case 8:
326	pThis->Cfg.enmDataBitCount = RTSERIALPORTDATABITS_8BITS;
327	break;
328	default:
329	AssertMsgFailed(("Unsupported data bit count %u\n", cDataBits)); /* Should not happen. */
330	pThis->Cfg.enmDataBitCount = RTSERIALPORTDATABITS_8BITS;
331	}
332
333	switch (enmStopBits)
334	{
335	case PDMSERIALSTOPBITS_ONE:
336	pThis->Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_ONE;
337	break;
338	case PDMSERIALSTOPBITS_ONEPOINTFIVE:
339	pThis->Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_ONEPOINTFIVE;
340	break;
341	case PDMSERIALSTOPBITS_TWO:
342	pThis->Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_TWO;
343	break;
344	default:
345	AssertMsgFailed(("Unsupported stop bit count %d\n", enmStopBits)); /* Should not happen. */
346	pThis->Cfg.enmStopBitCount = RTSERIALPORTSTOPBITS_ONE;
347	}
348
349	return RTSerialPortCfgSet(pThis->hSerialPort, &pThis->Cfg, NULL);
350	}
351
352
353	/**
354	* @interface_method_impl{PDMISERIALCONNECTOR,pfnChgModemLines}
355	*/
356	static DECLCALLBACK(int) drvHostSerialChgModemLines(PPDMISERIALCONNECTOR pInterface, bool fRts, bool fDtr)
357	{
358	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
359
360	uint32_t fClear = 0;
361	uint32_t fSet = 0;
362
363	if (fRts)
364	fSet \|= RTSERIALPORT_CHG_STS_LINES_F_RTS;
365	else
366	fClear \|= RTSERIALPORT_CHG_STS_LINES_F_RTS;
367
368	if (fDtr)
369	fSet \|= RTSERIALPORT_CHG_STS_LINES_F_DTR;
370	else
371	fClear \|= RTSERIALPORT_CHG_STS_LINES_F_DTR;
372
373	return RTSerialPortChgStatusLines(pThis->hSerialPort, fClear, fSet);
374	}
375
376
377	/**
378	* @interface_method_impl{PDMISERIALCONNECTOR,pfnChgBrk}
379	*/
380	static DECLCALLBACK(int) drvHostSerialChgBrk(PPDMISERIALCONNECTOR pInterface, bool fBrk)
381	{
382	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
383
384	return RTSerialPortChgBreakCondition(pThis->hSerialPort, fBrk);
385	}
386
387
388	/**
389	* @interface_method_impl{PDMISERIALCONNECTOR,pfnQueryStsLines}
390	*/
391	static DECLCALLBACK(int) drvHostSerialQueryStsLines(PPDMISERIALCONNECTOR pInterface, uint32_t *pfStsLines)
392	{
393	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
394
395	return RTSerialPortQueryStatusLines(pThis->hSerialPort, pfStsLines);
396	}
397
398
399	/**
400	* @callback_method_impl{PDMISERIALCONNECTOR,pfnQueuesFlush}
401	*/
402	static DECLCALLBACK(int) drvHostSerialQueuesFlush(PPDMISERIALCONNECTOR pInterface, bool fQueueRecv, bool fQueueXmit)
403	{
404	RT_NOREF(fQueueXmit);
405	LogFlowFunc(("pInterface=%#p fQueueRecv=%RTbool fQueueXmit=%RTbool\n", pInterface, fQueueRecv, fQueueXmit));
406	int rc = VINF_SUCCESS;
407	PDRVHOSTSERIAL pThis = RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ISerialConnector);
408
409	if (fQueueRecv)
410	{
411	size_t cbOld = drvHostSerialReadBufReset(pThis);
412	if (cbOld) /* Kick the I/O thread to fetch new data. */
413	rc = drvHostSerialWakeupIoThread(pThis);
414	}
415
416	LogFlowFunc(("-> %Rrc\n", rc));
417	return VINF_SUCCESS;
418	}
419
420
421	/* -=-=-=-=- I/O thread -=-=-=-=- */
422
423	/**
424	* The normal I/O loop.
425	*
426	* @returns VBox status code.
427	* @param pDrvIns Pointer to the driver instance data.
428	* @param pThis Host serial driver instance data.
429	* @param pThread Thread instance data.
430	*/
431	static int drvHostSerialIoLoopNormal(PPDMDRVINS pDrvIns, PDRVHOSTSERIAL pThis, PPDMTHREAD pThread)
432	{
433	int rc = VINF_SUCCESS;
434	while ( pThread->enmState == PDMTHREADSTATE_RUNNING
435	&& RT_SUCCESS(rc))
436	{
437	uint32_t fEvtFlags = RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED \| RTSERIALPORT_EVT_F_BREAK_DETECTED;
438
439	if (!pThis->fAvailWrInt)
440	pThis->fAvailWrInt = ASMAtomicXchgBool(&pThis->fAvailWrExt, false);
441
442	/* Wait until there is room again if there is anyting to send. */
443	if ( pThis->fAvailWrInt
444	\|\| pThis->cbTxUsed)
445	fEvtFlags \|= RTSERIALPORT_EVT_F_DATA_TX;
446
447	/* Try to receive more if there is still room. */
448	if (drvHostSerialReadBufGetWrite(pThis, NULL) > 0)
449	fEvtFlags \|= RTSERIALPORT_EVT_F_DATA_RX;
450
451	uint32_t fEvtsRecv = 0;
452	rc = RTSerialPortEvtPoll(pThis->hSerialPort, fEvtFlags, &fEvtsRecv, RT_INDEFINITE_WAIT);
453	if (RT_SUCCESS(rc))
454	{
455	if (fEvtsRecv & RTSERIALPORT_EVT_F_DATA_TX)
456	{
457	if ( pThis->fAvailWrInt
458	&& pThis->cbTxUsed < RT_ELEMENTS(pThis->abTxBuf))
459	{
460	/* Stuff as much data into the TX buffer as we can. */
461	size_t cbToFetch = RT_ELEMENTS(pThis->abTxBuf) - pThis->cbTxUsed;
462	size_t cbFetched = 0;
463	rc = pThis->pDrvSerialPort->pfnReadWr(pThis->pDrvSerialPort, &pThis->abTxBuf[pThis->cbTxUsed], cbToFetch,
464	&cbFetched);
465	AssertRC(rc);
466
467	if (cbFetched > 0)
468	pThis->cbTxUsed += cbFetched;
469	else
470	{
471	/* There is no data available anymore. */
472	pThis->fAvailWrInt = false;
473	}
474	}
475
476	if (pThis->cbTxUsed)
477	{
478	size_t cbProcessed = 0;
479	rc = RTSerialPortWriteNB(pThis->hSerialPort, &pThis->abTxBuf[0], pThis->cbTxUsed, &cbProcessed);
480	if (RT_SUCCESS(rc))
481	{
482	pThis->cbTxUsed -= cbProcessed;
483	if ( pThis->cbTxUsed
484	&& cbProcessed)
485	{
486	/* Move the data in the TX buffer to the front to fill the end again. */
487	memmove(&pThis->abTxBuf[0], &pThis->abTxBuf[cbProcessed], pThis->cbTxUsed);
488	}
489	else
490	pThis->pDrvSerialPort->pfnDataSentNotify(pThis->pDrvSerialPort);
491	STAM_COUNTER_ADD(&pThis->StatBytesWritten, cbProcessed);
492	}
493	else
494	{
495	LogRelMax(10, ("HostSerial#%d: Sending data failed even though the serial port is marked as writeable (rc=%Rrc)\n",
496	pThis->pDrvIns->iInstance, rc));
497	break;
498	}
499	}
500	}
501
502	if (fEvtsRecv & RTSERIALPORT_EVT_F_DATA_RX)
503	{
504	void *pvDst = NULL;
505	size_t cbToRead = drvHostSerialReadBufGetWrite(pThis, &pvDst);
506	size_t cbRead = 0;
507	rc = RTSerialPortReadNB(pThis->hSerialPort, pvDst, cbToRead, &cbRead);
508	/*
509	* No data being available while the port is marked as readable can happen
510	* if another thread changed the settings of the port inbetween the poll and
511	* the read call because it can flush all the buffered data (seen on Windows).
512	*/
513	if (rc != VINF_TRY_AGAIN)
514	{
515	if (RT_SUCCESS(rc))
516	{
517	drvHostSerialReadBufWriteAdv(pThis, cbRead);
518	/* Notify the device/driver above. */
519	rc = pThis->pDrvSerialPort->pfnDataAvailRdrNotify(pThis->pDrvSerialPort, cbRead);
520	AssertRC(rc);
521	}
522	else
523	LogRelMax(10, ("HostSerial#%d: Reading data failed even though the serial port is marked as readable (rc=%Rrc)\n",
524	pThis->pDrvIns->iInstance, rc));
525	}
526	}
527
528	if (fEvtsRecv & RTSERIALPORT_EVT_F_BREAK_DETECTED)
529	pThis->pDrvSerialPort->pfnNotifyBrk(pThis->pDrvSerialPort);
530
531	if (fEvtsRecv & RTSERIALPORT_EVT_F_STATUS_LINE_CHANGED)
532	{
533	/* The status lines have changed. Notify the device. */
534	uint32_t fStsLines = 0;
535	rc = RTSerialPortQueryStatusLines(pThis->hSerialPort, &fStsLines);
536	if (RT_SUCCESS(rc))
537	{
538	uint32_t fPdmStsLines = 0;
539
540	if (fStsLines & RTSERIALPORT_STS_LINE_DCD)
541	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_DCD;
542	if (fStsLines & RTSERIALPORT_STS_LINE_RI)
543	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_RI;
544	if (fStsLines & RTSERIALPORT_STS_LINE_DSR)
545	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_DSR;
546	if (fStsLines & RTSERIALPORT_STS_LINE_CTS)
547	fPdmStsLines \|= PDMISERIALPORT_STS_LINE_CTS;
548
549	rc = pThis->pDrvSerialPort->pfnNotifyStsLinesChanged(pThis->pDrvSerialPort, fPdmStsLines);
550	if (RT_FAILURE(rc))
551	{
552	/* Notifying device failed, continue but log it */
553	LogRelMax(10, ("HostSerial#%d: Notifying device about changed status lines failed with error %Rrc; continuing.\n",
554	pDrvIns->iInstance, rc));
555	rc = VINF_SUCCESS;
556	}
557	}
558	else
559	{
560	LogRelMax(10, ("HostSerial#%d: Getting status lines state failed with error %Rrc; continuing.\n", pDrvIns->iInstance, rc));
561	rc = VINF_SUCCESS;
562	}
563	}
564
565	if (fEvtsRecv & RTSERIALPORT_EVT_F_STATUS_LINE_MONITOR_FAILED)
566	LogRel(("HostSerial#%d: Status line monitoring failed at a lower level and is disabled\n", pDrvIns->iInstance));
567	}
568	else if (rc == VERR_TIMEOUT \|\| rc == VERR_INTERRUPTED)
569	{
570	/* Getting interrupted or running into a timeout are no error conditions. */
571	rc = VINF_SUCCESS;
572	}
573	}
574
575	LogRel(("HostSerial#%d: The underlying host device run into a fatal error condition %Rrc, any data transfer is disabled\n",
576	pDrvIns->iInstance, rc));
577
578	return rc;
579	}
580
581
582	/**
583	* The error I/O loop.
584	*
585	* @returns VBox status code.
586	* @param pThis Host serial driver instance data.
587	* @param pThread Thread instance data.
588	*/
589	static void drvHostSerialIoLoopError(PDRVHOSTSERIAL pThis, PPDMTHREAD pThread)
590	{
591	ASMAtomicXchgBool(&pThis->fIoFatalErr, true);
592
593	PDMDrvHlpVMSetRuntimeError(pThis->pDrvIns, 0 /fFlags/, "SerialPortIoError",
594	N_("The host serial port \"%s\" encountered a fatal error and stopped functioning. "
595	"This can be caused by bad cabling or USB to serial converters being unplugged by accident. "
596	"To restart I/O transfers suspend and resume the VM after fixing the underlying issue."),
597	pThis->pszDevicePath);
598
599	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
600	{
601	/*
602	* We have to discard any data which is going to be send (the error
603	* mode resembles the "someone just pulled the plug on the serial port" situation)
604	*/
605	RTSemEventWait(pThis->hSemEvtIoFatalErr, RT_INDEFINITE_WAIT);
606
607	if (ASMAtomicXchgBool(&pThis->fAvailWrExt, false))
608	{
609	size_t cbFetched = 0;
610
611	do
612	{
613	/* Stuff as much data into the TX buffer as we can. */
614	uint8_t abDiscard[64];
615	int rc = pThis->pDrvSerialPort->pfnReadWr(pThis->pDrvSerialPort, &abDiscard, sizeof(abDiscard),
616	&cbFetched);
617	AssertRC(rc);
618	} while (cbFetched > 0);
619
620	/* Acknowledge the sent data. */
621	pThis->pDrvSerialPort->pfnDataSentNotify(pThis->pDrvSerialPort);
622
623	/*
624	* Sleep a bit to avoid excessive I/O loop CPU usage, timing is not important in
625	* this mode.
626	*/
627	PDMR3ThreadSleep(pThread, 100);
628	}
629	}
630	}
631
632
633	/**
634	* I/O thread loop.
635	*
636	* @returns VINF_SUCCESS.
637	* @param pDrvIns PDM driver instance data.
638	* @param pThread The PDM thread data.
639	*/
640	static DECLCALLBACK(int) drvHostSerialIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
641	{
642	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
643
644	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
645	return VINF_SUCCESS;
646
647	int rc = VINF_SUCCESS;
648	if (!pThis->fIoFatalErr)
649	rc = drvHostSerialIoLoopNormal(pDrvIns, pThis, pThread);
650
651	if ( RT_FAILURE(rc)
652	\|\| pThis->fIoFatalErr)
653	drvHostSerialIoLoopError(pThis, pThread);
654
655	return VINF_SUCCESS;
656	}
657
658
659	/**
660	* Unblock the send thread so it can respond to a state change.
661	*
662	* @returns a VBox status code.
663	* @param pDrvIns The driver instance.
664	* @param pThread The send thread.
665	*/
666	static DECLCALLBACK(int) drvHostSerialWakeupIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
667	{
668	RT_NOREF(pThread);
669	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
670
671	return drvHostSerialWakeupIoThread(pThis);
672	}
673
674
675	/* -=-=-=-=- driver interface -=-=-=-=- */
676
677	/**
678	* @callback_method_impl{FNPDMDRVRESUME}
679	*/
680	static DECLCALLBACK(void) drvHostSerialResume(PPDMDRVINS pDrvIns)
681	{
682	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
683
684	if (RT_UNLIKELY(pThis->fIoFatalErr))
685	{
686	/* Try to reopen the device and set the old config. */
687	uint32_t fOpenFlags = RTSERIALPORT_OPEN_F_READ
688	\| RTSERIALPORT_OPEN_F_WRITE
689	\| RTSERIALPORT_OPEN_F_SUPPORT_STATUS_LINE_MONITORING
690	\| RTSERIALPORT_OPEN_F_DETECT_BREAK_CONDITION;
691	int rc = RTSerialPortOpen(&pThis->hSerialPort, pThis->pszDevicePath, fOpenFlags);
692	if (rc == VERR_NOT_SUPPORTED)
693	{
694	/*
695	* For certain devices (or pseudo terminals) status line monitoring does not work
696	* so try again without it.
697	*/
698	fOpenFlags &= ~RTSERIALPORT_OPEN_F_SUPPORT_STATUS_LINE_MONITORING;
699	rc = RTSerialPortOpen(&pThis->hSerialPort, pThis->pszDevicePath, fOpenFlags);
700	}
701
702	if (RT_SUCCESS(rc))
703	{
704	/* Set the config which is currently active. */
705	rc = RTSerialPortCfgSet(pThis->hSerialPort, &pThis->Cfg, NULL);
706	if (RT_FAILURE(rc))
707	LogRelMax(10, ("HostSerial#%d: Setting the active serial port config failed with error %Rrc during VM resume; continuing.\n", pDrvIns->iInstance, rc));
708	/* Reset the I/O error flag on success to resume the normal I/O thread loop. */
709	ASMAtomicXchgBool(&pThis->fIoFatalErr, false);
710	}
711	}
712	}
713
714
715	/**
716	* @callback_method_impl{FNPDMDRVSUSPEND}
717	*/
718	static DECLCALLBACK(void) drvHostSerialSuspend(PPDMDRVINS pDrvIns)
719	{
720	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
721
722	if (RT_UNLIKELY(pThis->fIoFatalErr))
723	{
724	/* Close the device and try reopening it on resume. */
725	if (pThis->hSerialPort != NIL_RTSERIALPORT)
726	{
727	RTSerialPortClose(pThis->hSerialPort);
728	pThis->hSerialPort = NIL_RTSERIALPORT;
729	}
730	}
731	}
732
733
734	/**
735	* Destruct a char driver instance.
736	*
737	* Most VM resources are freed by the VM. This callback is provided so that
738	* any non-VM resources can be freed correctly.
739	*
740	* @param pDrvIns The driver instance data.
741	*/
742	static DECLCALLBACK(void) drvHostSerialDestruct(PPDMDRVINS pDrvIns)
743	{
744	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
745	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
746	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
747
748	if (pThis->hSerialPort != NIL_RTSERIALPORT)
749	{
750	RTSerialPortClose(pThis->hSerialPort);
751	pThis->hSerialPort = NIL_RTSERIALPORT;
752	}
753
754	if (pThis->hSemEvtIoFatalErr != NIL_RTSEMEVENT)
755	{
756	RTSemEventDestroy(pThis->hSemEvtIoFatalErr);
757	pThis->hSemEvtIoFatalErr = NIL_RTSEMEVENT;
758	}
759
760	if (pThis->pszDevicePath)
761	{
762	MMR3HeapFree(pThis->pszDevicePath);
763	pThis->pszDevicePath = NULL;
764	}
765	}
766
767
768	/**
769	* Construct a char driver instance.
770	*
771	* @copydoc FNPDMDRVCONSTRUCT
772	*/
773	static DECLCALLBACK(int) drvHostSerialConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
774	{
775	RT_NOREF1(fFlags);
776	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
777	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
778	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
779
780	/*
781	* Init basic data members and interfaces.
782	*/
783	pThis->pDrvIns = pDrvIns;
784	pThis->hSerialPort = NIL_RTSERIALPORT;
785	pThis->fAvailWrExt = false;
786	pThis->fAvailWrInt = false;
787	pThis->cbTxUsed = 0;
788	pThis->offWrite = 0;
789	pThis->offRead = 0;
790	pThis->cbReadBuf = 0;
791	pThis->fIoFatalErr = false;
792	pThis->hSemEvtIoFatalErr = NIL_RTSEMEVENT;
793	/* IBase. */
794	pDrvIns->IBase.pfnQueryInterface = drvHostSerialQueryInterface;
795	/* ISerialConnector. */
796	pThis->ISerialConnector.pfnDataAvailWrNotify = drvHostSerialDataAvailWrNotify;
797	pThis->ISerialConnector.pfnReadRdr = drvHostSerialReadRdr;
798	pThis->ISerialConnector.pfnChgParams = drvHostSerialChgParams;
799	pThis->ISerialConnector.pfnChgModemLines = drvHostSerialChgModemLines;
800	pThis->ISerialConnector.pfnChgBrk = drvHostSerialChgBrk;
801	pThis->ISerialConnector.pfnQueryStsLines = drvHostSerialQueryStsLines;
802	pThis->ISerialConnector.pfnQueuesFlush = drvHostSerialQueuesFlush;
803
804	/*
805	* Query configuration.
806	*/
807	/* Device */
808	int rc = CFGMR3QueryStringAlloc(pCfg, "DevicePath", &pThis->pszDevicePath);
809	if (RT_FAILURE(rc))
810	{
811	AssertMsgFailed(("Configuration error: query for \"DevicePath\" string returned %Rra.\n", rc));
812	return rc;
813	}
814
815	/*
816	* Open the device
817	*/
818	uint32_t fOpenFlags = RTSERIALPORT_OPEN_F_READ
819	\| RTSERIALPORT_OPEN_F_WRITE
820	\| RTSERIALPORT_OPEN_F_SUPPORT_STATUS_LINE_MONITORING
821	\| RTSERIALPORT_OPEN_F_DETECT_BREAK_CONDITION;
822	rc = RTSerialPortOpen(&pThis->hSerialPort, pThis->pszDevicePath, fOpenFlags);
823	if (rc == VERR_NOT_SUPPORTED)
824	{
825	/*
826	* For certain devices (or pseudo terminals) status line monitoring does not work
827	* so try again without it.
828	*/
829	fOpenFlags &= ~RTSERIALPORT_OPEN_F_SUPPORT_STATUS_LINE_MONITORING;
830	rc = RTSerialPortOpen(&pThis->hSerialPort, pThis->pszDevicePath, fOpenFlags);
831	}
832
833	if (RT_FAILURE(rc))
834	{
835	AssertMsgFailed(("Could not open host device %s, rc=%Rrc\n", pThis->pszDevicePath, rc));
836	switch (rc)
837	{
838	case VERR_ACCESS_DENIED:
839	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
840	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
841	N_("Cannot open host device '%s' for read/write access. Check the permissions "
842	"of that device ('/bin/ls -l %s'): Most probably you need to be member "
843	"of the device group. Make sure that you logout/login after changing "
844	"the group settings of the current user"),
845	#else
846	N_("Cannot open host device '%s' for read/write access. Check the permissions "
847	"of that device"),
848	#endif
849	pThis->pszDevicePath, pThis->pszDevicePath);
850	default:
851	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
852	N_("Failed to open host device '%s'"),
853	pThis->pszDevicePath);
854	}
855	}
856
857	rc = RTSemEventCreate(&pThis->hSemEvtIoFatalErr);
858	if (RT_FAILURE(rc))
859	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d failed to create event semaphore"), pDrvIns->iInstance);
860
861	/*
862	* Get the ISerialPort interface of the above driver/device.
863	*/
864	pThis->pDrvSerialPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMISERIALPORT);
865	if (!pThis->pDrvSerialPort)
866	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("HostSerial#%d has no serial port interface above"), pDrvIns->iInstance);
867
868	/*
869	* Create the I/O thread.
870	*/
871	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pIoThrd, pThis, drvHostSerialIoThread, drvHostSerialWakeupIoThread, 0, RTTHREADTYPE_IO, "SerIo");
872	if (RT_FAILURE(rc))
873	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create I/O thread"), pDrvIns->iInstance);
874
875	/*
876	* Register release statistics.
877	*/
878	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES,
879	"Nr of bytes written", "/Devices/HostSerial%d/Written", pDrvIns->iInstance);
880	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES,
881	"Nr of bytes read", "/Devices/HostSerial%d/Read", pDrvIns->iInstance);
882
883	return VINF_SUCCESS;
884	}
885
886	/**
887	* Char driver registration record.
888	*/
889	const PDMDRVREG g_DrvHostSerial =
890	{
891	/* u32Version */
892	PDM_DRVREG_VERSION,
893	/* szName */
894	"Host Serial",
895	/* szRCMod */
896	"",
897	/* szR0Mod */
898	"",
899	/* pszDescription */
900	"Host serial driver.",
901	/* fFlags */
902	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
903	/* fClass. */
904	PDM_DRVREG_CLASS_CHAR,
905	/* cMaxInstances */
906	~0U,
907	/* cbInstance */
908	sizeof(DRVHOSTSERIAL),
909	/* pfnConstruct */
910	drvHostSerialConstruct,
911	/* pfnDestruct */
912	drvHostSerialDestruct,
913	/* pfnRelocate */
914	NULL,
915	/* pfnIOCtl */
916	NULL,
917	/* pfnPowerOn */
918	NULL,
919	/* pfnReset */
920	NULL,
921	/* pfnSuspend */
922	drvHostSerialSuspend,
923	/* pfnResume */
924	drvHostSerialResume,
925	/* pfnAttach */
926	NULL,
927	/* pfnDetach */
928	NULL,
929	/* pfnPowerOff */
930	NULL,
931	/* pfnSoftReset */
932	NULL,
933	/* u32EndVersion */
934	PDM_DRVREG_VERSION
935	};
936

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

source: vbox/trunk/src/VBox/Devices/Serial/DrvHostSerial.cpp@ 84909

Download in other formats: