DrvHostSerial.cpp@ 33223

Last change on this file since 33223 was 32678, checked in by vboxsync, 14 years ago
Devices/Serial, Devices/Parallel: minor fix (free alloc'd string)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 51.2 KB

Line
1	/* $Id: DrvHostSerial.cpp 32678 2010-09-21 17:14:02Z vboxsync $ */
2	/** @file
3	* VBox stream I/O devices: Host serial driver
4	*/
5
6	/*
7	* Copyright (C) 2006-2010 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/pdm.h>
25	#include <VBox/err.h>
26
27	#include <VBox/log.h>
28	#include <iprt/asm.h>
29	#include <iprt/assert.h>
30	#include <iprt/file.h>
31	#include <iprt/mem.h>
32	#include <iprt/semaphore.h>
33	#include <iprt/uuid.h>
34
35	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
36	# include <errno.h>
37	# ifdef RT_OS_SOLARIS
38	# include <sys/termios.h>
39	# else
40	# include <termios.h>
41	# endif
42	# include <sys/types.h>
43	# include <fcntl.h>
44	# include <string.h>
45	# include <unistd.h>
46	# ifdef RT_OS_DARWIN
47	# include <sys/select.h>
48	# else
49	# include <sys/poll.h>
50	# endif
51	# include <sys/ioctl.h>
52	# include <pthread.h>
53
54	# ifdef RT_OS_LINUX
55	/*
56	* TIOCM_LOOP is not defined in the above header files for some reason but in asm/termios.h.
57	* But inclusion of this file however leads to compilation errors because of redefinition of some
58	* structs. Thatswhy it is defined here until a better solution is found.
59	*/
60	# ifndef TIOCM_LOOP
61	# define TIOCM_LOOP 0x8000
62	# endif
63	/* For linux custom baudrate code we also need serial_struct */
64	# include <linux/serial.h>
65	# endif /* linux */
66
67	#elif defined(RT_OS_WINDOWS)
68	# include <Windows.h>
69	#endif
70
71	#include "../Builtins.h"
72
73
74	/** Size of the send fifo queue (in bytes) */
75	#ifdef RT_OS_DARWIN
76	/** @todo This is really desperate, but it seriously looks like
77	* the data is arriving way too fast for us to push over. 9600
78	* baud and zoc reports sending at 12000+ chars/sec... */
79	# define CHAR_MAX_SEND_QUEUE 0x400
80	# define CHAR_MAX_SEND_QUEUE_MASK 0x3ff
81	#else
82	# define CHAR_MAX_SEND_QUEUE 0x80
83	# define CHAR_MAX_SEND_QUEUE_MASK 0x7f
84	#endif
85
86	/*******************************************************************************
87	* Structures and Typedefs *
88	*******************************************************************************/
89
90	/**
91	* Char driver instance data.
92	*
93	* @implements PDMICHARCONNECTOR
94	*/
95	typedef struct DRVHOSTSERIAL
96	{
97	/** Pointer to the driver instance structure. */
98	PPDMDRVINS pDrvIns;
99	/** Pointer to the char port interface of the driver/device above us. */
100	PPDMICHARPORT pDrvCharPort;
101	/** Our char interface. */
102	PDMICHARCONNECTOR ICharConnector;
103	/** Receive thread. */
104	PPDMTHREAD pRecvThread;
105	/** Send thread. */
106	PPDMTHREAD pSendThread;
107	/** Status lines monitor thread. */
108	PPDMTHREAD pMonitorThread;
109	/** Send event semephore */
110	RTSEMEVENT SendSem;
111
112	/** the device path */
113	char *pszDevicePath;
114
115	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
116	/** the device handle */
117	RTFILE DeviceFile;
118	# ifdef RT_OS_DARWIN
119	/** The device handle used for reading.
120	* Used to prevent the read selecto from blocking the writes. */
121	RTFILE DeviceFileR;
122	# endif
123	/** The read end of the control pipe */
124	RTFILE WakeupPipeR;
125	/** The write end of the control pipe */
126	RTFILE WakeupPipeW;
127	# ifndef RT_OS_LINUX
128	/** The current line status.
129	* Used by the polling version of drvHostSerialMonitorThread. */
130	int fStatusLines;
131	# endif
132	#elif defined(RT_OS_WINDOWS)
133	/** the device handle */
134	HANDLE hDeviceFile;
135	/** The event semaphore for waking up the receive thread */
136	HANDLE hHaltEventSem;
137	/** The event semaphore for overlapped receiving */
138	HANDLE hEventRecv;
139	/** For overlapped receiving */
140	OVERLAPPED overlappedRecv;
141	/** The event semaphore for overlapped sending */
142	HANDLE hEventSend;
143	/** For overlapped sending */
144	OVERLAPPED overlappedSend;
145	#endif
146
147	/** Internal send FIFO queue */
148	uint8_t volatile aSendQueue[CHAR_MAX_SEND_QUEUE];
149	uint32_t volatile iSendQueueHead;
150	uint32_t volatile iSendQueueTail;
151
152	/** Read/write statistics */
153	STAMCOUNTER StatBytesRead;
154	STAMCOUNTER StatBytesWritten;
155	#ifdef RT_OS_DARWIN
156	/** The number of bytes we've dropped because the send queue
157	* was full. */
158	STAMCOUNTER StatSendOverflows;
159	#endif
160	} DRVHOSTSERIAL, *PDRVHOSTSERIAL;
161
162
163	/** Converts a pointer to DRVCHAR::ICharConnector to a PDRVHOSTSERIAL. */
164	#define PDMICHAR_2_DRVHOSTSERIAL(pInterface) RT_FROM_MEMBER(pInterface, DRVHOSTSERIAL, ICharConnector)
165
166
167	/* -=-=-=-=- IBase -=-=-=-=- */
168
169	/**
170	* @interface_method_impl{PDMIBASE,pfnQueryInterface}
171	*/
172	static DECLCALLBACK(void ) drvHostSerialQueryInterface(PPDMIBASE pInterface, const char pszIID)
173	{
174	PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
175	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
176
177	PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
178	PDMIBASE_RETURN_INTERFACE(pszIID, PDMICHARCONNECTOR, &pThis->ICharConnector);
179	return NULL;
180	}
181
182
183	/* -=-=-=-=- ICharConnector -=-=-=-=- */
184
185	/** @copydoc PDMICHARCONNECTOR::pfnWrite */
186	static DECLCALLBACK(int) drvHostSerialWrite(PPDMICHARCONNECTOR pInterface, const void *pvBuf, size_t cbWrite)
187	{
188	PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
189	const uint8_t pbBuffer = (const uint8_t )pvBuf;
190
191	LogFlow(("%s: pvBuf=%#p cbWrite=%d\n", __FUNCTION__, pvBuf, cbWrite));
192
193	for (uint32_t i = 0; i < cbWrite; i++)
194	{
195	#ifdef RT_OS_DARWIN /* don't wanna break the others here. */
196	uint32_t iHead = ASMAtomicUoReadU32(&pThis->iSendQueueHead);
197	uint32_t iTail = ASMAtomicUoReadU32(&pThis->iSendQueueTail);
198	int32_t cbAvail = iTail > iHead
199	? iTail - iHead - 1
200	: CHAR_MAX_SEND_QUEUE - (iHead - iTail) - 1;
201	if (cbAvail <= 0)
202	{
203	# ifdef DEBUG
204	uint64_t volatile u64Now = RTTimeNanoTS(); NOREF(u64Now);
205	# endif
206	Log(("%s: dropping %d chars (cbAvail=%d iHead=%d iTail=%d)\n", __FUNCTION__, cbWrite - i , cbAvail, iHead, iTail));
207	STAM_COUNTER_INC(&pThis->StatSendOverflows);
208	break;
209	}
210
211	pThis->aSendQueue[iHead] = pbBuffer[i];
212	STAM_COUNTER_INC(&pThis->StatBytesWritten);
213	ASMAtomicWriteU32(&pThis->iSendQueueHead, (iHead + 1) & CHAR_MAX_SEND_QUEUE_MASK);
214	if (cbAvail < CHAR_MAX_SEND_QUEUE / 4)
215	{
216	RTSemEventSignal(pThis->SendSem);
217	RTThreadYield();
218	}
219	#else /* old code */
220	uint32_t idx = ASMAtomicUoReadU32(&pThis->iSendQueueHead);
221
222	pThis->aSendQueue[idx] = pbBuffer[i];
223	idx = (idx + 1) & CHAR_MAX_SEND_QUEUE_MASK;
224
225	STAM_COUNTER_INC(&pThis->StatBytesWritten);
226	ASMAtomicWriteU32(&pThis->iSendQueueHead, idx);
227	#endif /* old code */
228	}
229	RTSemEventSignal(pThis->SendSem);
230	return VINF_SUCCESS;
231	}
232
233	static DECLCALLBACK(int) drvHostSerialSetParameters(PPDMICHARCONNECTOR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits)
234	{
235	PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
236	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
237	struct termios *termiosSetup;
238	int baud_rate;
239	#elif defined(RT_OS_WINDOWS)
240	LPDCB comSetup;
241	#endif
242
243	LogFlow(("%s: Bps=%u chParity=%c cDataBits=%u cStopBits=%u\n", __FUNCTION__, Bps, chParity, cDataBits, cStopBits));
244
245	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS)
246	termiosSetup = (struct termios *)RTMemTmpAllocZ(sizeof(struct termios));
247
248	/* Enable receiver */
249	termiosSetup->c_cflag \|= (CLOCAL \| CREAD);
250
251	switch (Bps) {
252	case 50:
253	baud_rate = B50;
254	break;
255	case 75:
256	baud_rate = B75;
257	break;
258	case 110:
259	baud_rate = B110;
260	break;
261	case 134:
262	baud_rate = B134;
263	break;
264	case 150:
265	baud_rate = B150;
266	break;
267	case 200:
268	baud_rate = B200;
269	break;
270	case 300:
271	baud_rate = B300;
272	break;
273	case 600:
274	baud_rate = B600;
275	break;
276	case 1200:
277	baud_rate = B1200;
278	break;
279	case 1800:
280	baud_rate = B1800;
281	break;
282	case 2400:
283	baud_rate = B2400;
284	break;
285	case 4800:
286	baud_rate = B4800;
287	break;
288	case 9600:
289	baud_rate = B9600;
290	break;
291	case 19200:
292	baud_rate = B19200;
293	break;
294	case 38400:
295	baud_rate = B38400;
296	break;
297	case 57600:
298	baud_rate = B57600;
299	break;
300	case 115200:
301	baud_rate = B115200;
302	break;
303	default:
304	#ifdef RT_OS_LINUX
305	struct serial_struct serialStruct;
306	if (ioctl(pThis->DeviceFile, TIOCGSERIAL, &serialStruct) != -1)
307	{
308	serialStruct.custom_divisor = serialStruct.baud_base / Bps;
309	if (!serialStruct.custom_divisor)
310	serialStruct.custom_divisor = 1;
311	serialStruct.flags &= ~ASYNC_SPD_MASK;
312	serialStruct.flags \|= ASYNC_SPD_CUST;
313	ioctl(pThis->DeviceFile, TIOCSSERIAL, &serialStruct);
314	baud_rate = B38400;
315	}
316	else
317	baud_rate = B9600;
318	#else /* !RT_OS_LINUX */
319	baud_rate = B9600;
320	#endif /* !RT_OS_LINUX */
321	}
322
323	cfsetispeed(termiosSetup, baud_rate);
324	cfsetospeed(termiosSetup, baud_rate);
325
326	switch (chParity) {
327	case 'E':
328	termiosSetup->c_cflag \|= PARENB;
329	break;
330	case 'O':
331	termiosSetup->c_cflag \|= (PARENB \| PARODD);
332	break;
333	case 'N':
334	break;
335	default:
336	break;
337	}
338
339	switch (cDataBits) {
340	case 5:
341	termiosSetup->c_cflag \|= CS5;
342	break;
343	case 6:
344	termiosSetup->c_cflag \|= CS6;
345	break;
346	case 7:
347	termiosSetup->c_cflag \|= CS7;
348	break;
349	case 8:
350	termiosSetup->c_cflag \|= CS8;
351	break;
352	default:
353	break;
354	}
355
356	switch (cStopBits) {
357	case 2:
358	termiosSetup->c_cflag \|= CSTOPB;
359	default:
360	break;
361	}
362
363	/* set serial port to raw input */
364	termiosSetup->c_lflag &= ~(ICANON \| ECHO \| ECHOE \| ECHONL \| ECHOK \| ISIG \| IEXTEN);
365
366	tcsetattr(pThis->DeviceFile, TCSANOW, termiosSetup);
367	RTMemTmpFree(termiosSetup);
368	#elif defined(RT_OS_WINDOWS)
369	comSetup = (LPDCB)RTMemTmpAllocZ(sizeof(DCB));
370
371	comSetup->DCBlength = sizeof(DCB);
372
373	switch (Bps) {
374	case 110:
375	comSetup->BaudRate = CBR_110;
376	break;
377	case 300:
378	comSetup->BaudRate = CBR_300;
379	break;
380	case 600:
381	comSetup->BaudRate = CBR_600;
382	break;
383	case 1200:
384	comSetup->BaudRate = CBR_1200;
385	break;
386	case 2400:
387	comSetup->BaudRate = CBR_2400;
388	break;
389	case 4800:
390	comSetup->BaudRate = CBR_4800;
391	break;
392	case 9600:
393	comSetup->BaudRate = CBR_9600;
394	break;
395	case 14400:
396	comSetup->BaudRate = CBR_14400;
397	break;
398	case 19200:
399	comSetup->BaudRate = CBR_19200;
400	break;
401	case 38400:
402	comSetup->BaudRate = CBR_38400;
403	break;
404	case 57600:
405	comSetup->BaudRate = CBR_57600;
406	break;
407	case 115200:
408	comSetup->BaudRate = CBR_115200;
409	break;
410	default:
411	comSetup->BaudRate = CBR_9600;
412	}
413
414	comSetup->fBinary = TRUE;
415	comSetup->fOutxCtsFlow = FALSE;
416	comSetup->fOutxDsrFlow = FALSE;
417	comSetup->fDtrControl = DTR_CONTROL_DISABLE;
418	comSetup->fDsrSensitivity = FALSE;
419	comSetup->fTXContinueOnXoff = TRUE;
420	comSetup->fOutX = FALSE;
421	comSetup->fInX = FALSE;
422	comSetup->fErrorChar = FALSE;
423	comSetup->fNull = FALSE;
424	comSetup->fRtsControl = RTS_CONTROL_DISABLE;
425	comSetup->fAbortOnError = FALSE;
426	comSetup->wReserved = 0;
427	comSetup->XonLim = 5;
428	comSetup->XoffLim = 5;
429	comSetup->ByteSize = cDataBits;
430
431	switch (chParity) {
432	case 'E':
433	comSetup->Parity = EVENPARITY;
434	break;
435	case 'O':
436	comSetup->Parity = ODDPARITY;
437	break;
438	case 'N':
439	comSetup->Parity = NOPARITY;
440	break;
441	default:
442	break;
443	}
444
445	switch (cStopBits) {
446	case 1:
447	comSetup->StopBits = ONESTOPBIT;
448	break;
449	case 2:
450	comSetup->StopBits = TWOSTOPBITS;
451	break;
452	default:
453	break;
454	}
455
456	comSetup->XonChar = 0;
457	comSetup->XoffChar = 0;
458	comSetup->ErrorChar = 0;
459	comSetup->EofChar = 0;
460	comSetup->EvtChar = 0;
461
462	SetCommState(pThis->hDeviceFile, comSetup);
463	RTMemTmpFree(comSetup);
464	#endif /* RT_OS_WINDOWS */
465
466	return VINF_SUCCESS;
467	}
468
469	/* -=-=-=-=- receive thread -=-=-=-=- */
470
471	/**
472	* Send thread loop.
473	*
474	* @returns VINF_SUCCESS.
475	* @param ThreadSelf Thread handle to this thread.
476	* @param pvUser User argument.
477	*/
478	static DECLCALLBACK(int) drvHostSerialSendThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
479	{
480	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
481
482	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
483	return VINF_SUCCESS;
484
485	#ifdef RT_OS_WINDOWS
486	/* Make sure that the halt event semaphore is reset. */
487	DWORD dwRet = WaitForSingleObject(pThis->hHaltEventSem, 0);
488
489	HANDLE haWait[2];
490	haWait[0] = pThis->hEventSend;
491	haWait[1] = pThis->hHaltEventSem;
492	#endif
493
494	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
495	{
496	int rc = RTSemEventWait(pThis->SendSem, RT_INDEFINITE_WAIT);
497	if (RT_FAILURE(rc))
498	break;
499
500	/*
501	* Write the character to the host device.
502	*/
503	#ifdef RT_OS_DARWIN
504	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
505	{
506	/* copy the send queue so we get a linear buffer with the maximal size. */
507	uint8_t abBuf[sizeof(pThis->aSendQueue)];
508	uint32_t cb = 0;
509	uint32_t iTail = ASMAtomicUoReadU32(&pThis->iSendQueueTail);
510	uint32_t iHead = ASMAtomicUoReadU32(&pThis->iSendQueueHead);
511	if (iTail == iHead)
512	break;
513	do
514	{
515	abBuf[cb++] = pThis->aSendQueue[iTail];
516	iTail = (iTail + 1) & CHAR_MAX_SEND_QUEUE_MASK;
517	} while (iTail != iHead);
518
519	ASMAtomicWriteU32(&pThis->iSendQueueTail, iTail);
520
521	/* write it. */
522	# ifdef DEBUG
523	uint64_t volatile u64Now = RTTimeNanoTS(); NOREF(u64Now);
524	# endif
525	# if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
526
527	size_t cbWritten;
528	rc = RTFileWrite(pThis->DeviceFile, abBuf, cb, &cbWritten);
529	if (rc == VERR_TRY_AGAIN)
530	cbWritten = 0;
531	if (cbWritten < cb && (RT_SUCCESS(rc) \|\| rc == VERR_TRY_AGAIN))
532	{
533	/* ok, block till the device is ready for more (O_NONBLOCK) effect. */
534	rc = VINF_SUCCESS;
535	uint8_t const *pbSrc = &abBuf[0];
536	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
537	{
538	/* advance */
539	cb -= cbWritten;
540	pbSrc += cbWritten;
541
542	/* wait */
543	fd_set WrSet;
544	FD_ZERO(&WrSet);
545	FD_SET(pThis->DeviceFile, &WrSet);
546	fd_set XcptSet;
547	FD_ZERO(&XcptSet);
548	FD_SET(pThis->DeviceFile, &XcptSet);
549	rc = select(pThis->DeviceFile + 1, NULL, &WrSet, &XcptSet, NULL);
550	/** @todo check rc? */
551
552	/* try write more */
553	rc = RTFileWrite(pThis->DeviceFile, pbSrc, cb, &cbWritten);
554	if (rc == VERR_TRY_AGAIN)
555	cbWritten = 0;
556	else if (RT_FAILURE(rc))
557	break;
558	else if (cbWritten >= cb)
559	break;
560	rc = VINF_SUCCESS;
561	} /* wait/write loop */
562	}
563
564	# elif defined(RT_OS_WINDOWS)
565	/* perform an overlapped write operation. */
566	DWORD cbWritten;
567	memset(&pThis->overlappedSend, 0, sizeof(pThis->overlappedSend));
568	pThis->overlappedSend.hEvent = pThis->hEventSend;
569	if (!WriteFile(pThis->hDeviceFile, abBuf, cb, &cbWritten, &pThis->overlappedSend))
570	{
571	dwRet = GetLastError();
572	if (dwRet == ERROR_IO_PENDING)
573	{
574	/*
575	* write blocked, wait for completion or wakeup...
576	*/
577	dwRet = WaitForMultipleObjects(2, haWait, FALSE, INFINITE);
578	if (dwRet != WAIT_OBJECT_0)
579	{
580	AssertMsg(pThread->enmState != PDMTHREADSTATE_RUNNING, ("The halt event sempahore is set but the thread is still in running state\n"));
581	break;
582	}
583	}
584	else
585	rc = RTErrConvertFromWin32(dwRet);
586	}
587
588	# endif /* RT_OS_WINDOWS */
589	if (RT_FAILURE(rc))
590	{
591	LogRel(("HostSerial#%d: Serial Write failed with %Rrc; terminating send thread\n", pDrvIns->iInstance, rc));
592	return rc;
593	}
594	} /* write loop */
595
596	#else /* old code */
597	uint32_t iTail;
598	while ( pThread->enmState == PDMTHREADSTATE_RUNNING
599	&& (iTail = ASMAtomicUoReadU32(&pThis->iSendQueueTail)) != ASMAtomicUoReadU32(&pThis->iSendQueueHead))
600	{
601	/** @todo process more than one byte? */
602	unsigned cbProcessed = 1;
603	uint8_t abBuf[1];
604	abBuf[0] = pThis->aSendQueue[iTail];
605
606	# if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
607
608	rc = RTFileWrite(pThis->DeviceFile, abBuf, cbProcessed, NULL);
609
610	# elif defined(RT_OS_WINDOWS)
611
612	DWORD cbBytesWritten;
613	memset(&pThis->overlappedSend, 0, sizeof(pThis->overlappedSend));
614	pThis->overlappedSend.hEvent = pThis->hEventSend;
615
616	if (!WriteFile(pThis->hDeviceFile, abBuf, cbProcessed, &cbBytesWritten, &pThis->overlappedSend))
617	{
618	dwRet = GetLastError();
619	if (dwRet == ERROR_IO_PENDING)
620	{
621	/*
622	* write blocked, wait ...
623	*/
624	dwRet = WaitForMultipleObjects(2, haWait, FALSE, INFINITE);
625	if (dwRet != WAIT_OBJECT_0)
626	{
627	AssertMsg(pThread->enmState != PDMTHREADSTATE_RUNNING, ("The halt event sempahore is set but the thread is still in running state\n"));
628	break;
629	}
630	}
631	else
632	rc = RTErrConvertFromWin32(dwRet);
633	}
634
635	# endif
636
637	if (RT_SUCCESS(rc))
638	{
639	Assert(cbProcessed == 1);
640	ASMAtomicWriteU32(&pThis->iSendQueueTail, (iTail + 1) & CHAR_MAX_SEND_QUEUE_MASK);
641	}
642	else if (RT_FAILURE(rc))
643	{
644	LogRel(("HostSerial#%d: Serial Write failed with %Rrc; terminating send thread\n", pDrvIns->iInstance, rc));
645	return rc;
646	}
647	}
648	#endif /* old code */
649	}
650
651	return VINF_SUCCESS;
652	}
653
654	/**
655	* Unblock the send thread so it can respond to a state change.
656	*
657	* @returns a VBox status code.
658	* @param pDrvIns The driver instance.
659	* @param pThread The send thread.
660	*/
661	static DECLCALLBACK(int) drvHostSerialWakeupSendThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
662	{
663	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
664	int rc;
665
666	rc = RTSemEventSignal(pThis->SendSem);
667	if (RT_FAILURE(rc))
668	return rc;
669
670	#ifdef RT_OS_WINDOWS
671	if (!SetEvent(pThis->hHaltEventSem))
672	return RTErrConvertFromWin32(GetLastError());
673	#endif
674
675	return VINF_SUCCESS;
676	}
677
678	/* -=-=-=-=- receive thread -=-=-=-=- */
679
680	/**
681	* Receive thread loop.
682	*
683	* This thread pushes data from the host serial device up the driver
684	* chain toward the serial device.
685	*
686	* @returns VINF_SUCCESS.
687	* @param ThreadSelf Thread handle to this thread.
688	* @param pvUser User argument.
689	*/
690	static DECLCALLBACK(int) drvHostSerialRecvThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
691	{
692	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
693	uint8_t abBuffer[256];
694	uint8_t *pbBuffer = NULL;
695	size_t cbRemaining = 0; /* start by reading host data */
696	int rc = VINF_SUCCESS;
697	int rcThread = VINF_SUCCESS;
698
699	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
700	return VINF_SUCCESS;
701
702	#ifdef RT_OS_WINDOWS
703	/* Make sure that the halt event semaphore is reset. */
704	DWORD dwRet = WaitForSingleObject(pThis->hHaltEventSem, 0);
705
706	HANDLE ahWait[2];
707	ahWait[0] = pThis->hEventRecv;
708	ahWait[1] = pThis->hHaltEventSem;
709	#endif
710
711	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
712	{
713	if (!cbRemaining)
714	{
715	/* Get a block of data from the host serial device. */
716
717	#if defined(RT_OS_DARWIN) /* poll is broken on x86 darwin, returns POLLNVAL. */
718	fd_set RdSet;
719	FD_ZERO(&RdSet);
720	FD_SET(pThis->DeviceFileR, &RdSet);
721	FD_SET(pThis->WakeupPipeR, &RdSet);
722	fd_set XcptSet;
723	FD_ZERO(&XcptSet);
724	FD_SET(pThis->DeviceFileR, &XcptSet);
725	FD_SET(pThis->WakeupPipeR, &XcptSet);
726	# if 1 /* it seems like this select is blocking the write... */
727	rc = select(RT_MAX(pThis->WakeupPipeR, pThis->DeviceFileR) + 1, &RdSet, NULL, &XcptSet, NULL);
728	# else
729	struct timeval tv = { 0, 1000 };
730	rc = select(RT_MAX(pThis->WakeupPipeR, pThis->DeviceFileR) + 1, &RdSet, NULL, &XcptSet, &tv);
731	# endif
732	if (rc == -1)
733	{
734	int err = errno;
735	rcThread = RTErrConvertFromErrno(err);
736	LogRel(("HostSerial#%d: select failed with errno=%d / %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, err, rcThread));
737	break;
738	}
739
740	/* this might have changed in the meantime */
741	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
742	break;
743	if (rc == 0)
744	continue;
745
746	/* drain the wakeup pipe */
747	size_t cbRead;
748	if ( FD_ISSET(pThis->WakeupPipeR, &RdSet)
749	\|\| FD_ISSET(pThis->WakeupPipeR, &XcptSet))
750	{
751	rc = RTFileRead(pThis->WakeupPipeR, abBuffer, 1, &cbRead);
752	if (RT_FAILURE(rc))
753	{
754	LogRel(("HostSerial#%d: draining the wakekup pipe failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));
755	rcThread = rc;
756	break;
757	}
758	continue;
759	}
760
761	/* read data from the serial port. */
762	rc = RTFileRead(pThis->DeviceFileR, abBuffer, sizeof(abBuffer), &cbRead);
763	if (RT_FAILURE(rc))
764	{
765	LogRel(("HostSerial#%d: (1) Read failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));
766	rcThread = rc;
767	break;
768	}
769	cbRemaining = cbRead;
770
771	#elif defined(RT_OS_LINUX) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
772
773	size_t cbRead;
774	struct pollfd aFDs[2];
775	aFDs[0].fd = pThis->DeviceFile;
776	aFDs[0].events = POLLIN;
777	aFDs[0].revents = 0;
778	aFDs[1].fd = pThis->WakeupPipeR;
779	aFDs[1].events = POLLIN \| POLLERR \| POLLHUP;
780	aFDs[1].revents = 0;
781	rc = poll(aFDs, RT_ELEMENTS(aFDs), -1);
782	if (rc < 0)
783	{
784	int err = errno;
785	rcThread = RTErrConvertFromErrno(err);
786	LogRel(("HostSerial#%d: poll failed with errno=%d / %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, err, rcThread));
787	break;
788	}
789	/* this might have changed in the meantime */
790	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
791	break;
792	if (rc > 0 && aFDs[1].revents)
793	{
794	if (aFDs[1].revents & (POLLHUP \| POLLERR \| POLLNVAL))
795	break;
796	/* notification to terminate -- drain the pipe */
797	RTFileRead(pThis->WakeupPipeR, &abBuffer, 1, &cbRead);
798	continue;
799	}
800	rc = RTFileRead(pThis->DeviceFile, abBuffer, sizeof(abBuffer), &cbRead);
801	if (RT_FAILURE(rc))
802	{
803	/* don't terminate worker thread when data unavailable */
804	if (rc == VERR_TRY_AGAIN)
805	continue;
806
807	LogRel(("HostSerial#%d: (2) Read failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));
808	rcThread = rc;
809	break;
810	}
811	cbRemaining = cbRead;
812
813	#elif defined(RT_OS_WINDOWS)
814
815	DWORD dwEventMask = 0;
816	DWORD dwNumberOfBytesTransferred;
817
818	memset(&pThis->overlappedRecv, 0, sizeof(pThis->overlappedRecv));
819	pThis->overlappedRecv.hEvent = pThis->hEventRecv;
820
821	if (!WaitCommEvent(pThis->hDeviceFile, &dwEventMask, &pThis->overlappedRecv))
822	{
823	dwRet = GetLastError();
824	if (dwRet == ERROR_IO_PENDING)
825	{
826	dwRet = WaitForMultipleObjects(2, ahWait, FALSE, INFINITE);
827	if (dwRet != WAIT_OBJECT_0)
828	{
829	/* notification to terminate */
830	AssertMsg(pThread->enmState != PDMTHREADSTATE_RUNNING, ("The halt event sempahore is set but the thread is still in running state\n"));
831	break;
832	}
833	}
834	else
835	{
836	rcThread = RTErrConvertFromWin32(dwRet);
837	LogRel(("HostSerial#%d: Wait failed with error %Rrc; terminating the worker thread.\n", pDrvIns->iInstance, rcThread));
838	break;
839	}
840	}
841	/* this might have changed in the meantime */
842	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
843	break;
844
845	/* Check the event */
846	if (dwEventMask & EV_RXCHAR)
847	{
848	if (!ReadFile(pThis->hDeviceFile, abBuffer, sizeof(abBuffer), &dwNumberOfBytesTransferred, &pThis->overlappedRecv))
849	{
850	rcThread = RTErrConvertFromWin32(GetLastError());
851	LogRel(("HostSerial#%d: Read failed with error %Rrc; terminating the worker thread.\n", pDrvIns->iInstance, rcThread));
852	break;
853	}
854	cbRemaining = dwNumberOfBytesTransferred;
855	}
856	else if (dwEventMask & EV_BREAK)
857	{
858	Log(("HostSerial#%d: Detected break\n"));
859	rc = pThis->pDrvCharPort->pfnNotifyBreak(pThis->pDrvCharPort);
860	}
861	else
862	{
863	/* The status lines have changed. Notify the device. */
864	DWORD dwNewStatusLinesState = 0;
865	uint32_t uNewStatusLinesState = 0;
866
867	/* Get the new state */
868	if (GetCommModemStatus(pThis->hDeviceFile, &dwNewStatusLinesState))
869	{
870	if (dwNewStatusLinesState & MS_RLSD_ON)
871	uNewStatusLinesState \|= PDMICHARPORT_STATUS_LINES_DCD;
872	if (dwNewStatusLinesState & MS_RING_ON)
873	uNewStatusLinesState \|= PDMICHARPORT_STATUS_LINES_RI;
874	if (dwNewStatusLinesState & MS_DSR_ON)
875	uNewStatusLinesState \|= PDMICHARPORT_STATUS_LINES_DSR;
876	if (dwNewStatusLinesState & MS_CTS_ON)
877	uNewStatusLinesState \|= PDMICHARPORT_STATUS_LINES_CTS;
878	rc = pThis->pDrvCharPort->pfnNotifyStatusLinesChanged(pThis->pDrvCharPort, uNewStatusLinesState);
879	if (RT_FAILURE(rc))
880	{
881	/* Notifying device failed, continue but log it */
882	LogRel(("HostSerial#%d: Notifying device failed with error %Rrc; continuing.\n", pDrvIns->iInstance, rc));
883	}
884	}
885	else
886	{
887	/* Getting new state failed, continue but log it */
888	LogRel(("HostSerial#%d: Getting status lines state failed with error %Rrc; continuing.\n", pDrvIns->iInstance, RTErrConvertFromWin32(GetLastError())));
889	}
890	}
891	#endif
892
893	Log(("Read %d bytes.\n", cbRemaining));
894	pbBuffer = abBuffer;
895	}
896	else
897	{
898	/* Send data to the guest. */
899	size_t cbProcessed = cbRemaining;
900	rc = pThis->pDrvCharPort->pfnNotifyRead(pThis->pDrvCharPort, pbBuffer, &cbProcessed);
901	if (RT_SUCCESS(rc))
902	{
903	Assert(cbProcessed); Assert(cbProcessed <= cbRemaining);
904	pbBuffer += cbProcessed;
905	cbRemaining -= cbProcessed;
906	STAM_COUNTER_ADD(&pThis->StatBytesRead, cbProcessed);
907	}
908	else if (rc == VERR_TIMEOUT)
909	{
910	/* Normal case, just means that the guest didn't accept a new
911	* character before the timeout elapsed. Just retry. */
912	rc = VINF_SUCCESS;
913	}
914	else
915	{
916	LogRel(("HostSerial#%d: NotifyRead failed with %Rrc, terminating the worker thread.\n", pDrvIns->iInstance, rc));
917	rcThread = rc;
918	break;
919	}
920	}
921	}
922
923	return rcThread;
924	}
925
926	/**
927	* Unblock the send thread so it can respond to a state change.
928	*
929	* @returns a VBox status code.
930	* @param pDrvIns The driver instance.
931	* @param pThread The send thread.
932	*/
933	static DECLCALLBACK(int) drvHostSerialWakeupRecvThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
934	{
935	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
936	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
937	return RTFileWrite(pThis->WakeupPipeW, "", 1, NULL);
938	#elif defined(RT_OS_WINDOWS)
939	if (!SetEvent(pThis->hHaltEventSem))
940	return RTErrConvertFromWin32(GetLastError());
941	return VINF_SUCCESS;
942	#else
943	# error adapt me!
944	#endif
945	}
946
947	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
948	/* -=-=-=-=- Monitor thread -=-=-=-=- */
949
950	/**
951	* Monitor thread loop.
952	*
953	* This thread monitors the status lines and notifies the device
954	* if they change.
955	*
956	* @returns VINF_SUCCESS.
957	* @param ThreadSelf Thread handle to this thread.
958	* @param pvUser User argument.
959	*/
960	static DECLCALLBACK(int) drvHostSerialMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
961	{
962	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
963	int rc = VINF_SUCCESS;
964	unsigned uStatusLinesToCheck = 0;
965
966	uStatusLinesToCheck = TIOCM_CAR \| TIOCM_RNG \| TIOCM_LE \| TIOCM_CTS;
967
968	if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
969	return VINF_SUCCESS;
970
971	while (pThread->enmState == PDMTHREADSTATE_RUNNING)
972	{
973	uint32_t newStatusLine = 0;
974	unsigned int statusLines;
975
976	# ifdef RT_OS_LINUX
977	/*
978	* Wait for status line change.
979	*/
980	rc = ioctl(pThis->DeviceFile, TIOCMIWAIT, uStatusLinesToCheck);
981	if (pThread->enmState != PDMTHREADSTATE_RUNNING)
982	break;
983	if (rc < 0)
984	{
985	ioctl_error:
986	PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /fFlags/, "DrvHostSerialFail",
987	N_("Ioctl failed for serial host device '%s' (%Rrc). The device will not work properly"),
988	pThis->pszDevicePath, RTErrConvertFromErrno(errno));
989	break;
990	}
991
992	rc = ioctl(pThis->DeviceFile, TIOCMGET, &statusLines);
993	if (rc < 0)
994	goto ioctl_error;
995	# else /* !RT_OS_LINUX */
996	/*
997	* Poll for the status line change.
998	*/
999	rc = ioctl(pThis->DeviceFile, TIOCMGET, &statusLines);
1000	if (rc < 0)
1001	{
1002	PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /fFlags/, "DrvHostSerialFail",
1003	N_("Ioctl failed for serial host device '%s' (%Rrc). The device will not work properly"),
1004	pThis->pszDevicePath, RTErrConvertFromErrno(errno));
1005	break;
1006	}
1007	if (!((statusLines ^ pThis->fStatusLines) & uStatusLinesToCheck))
1008	{
1009	PDMR3ThreadSleep(pThread, 500); /* 0.5 sec */
1010	continue;
1011	}
1012	pThis->fStatusLines = statusLines;
1013	# endif /* !RT_OS_LINUX */
1014
1015	if (statusLines & TIOCM_CAR)
1016	newStatusLine \|= PDMICHARPORT_STATUS_LINES_DCD;
1017	if (statusLines & TIOCM_RNG)
1018	newStatusLine \|= PDMICHARPORT_STATUS_LINES_RI;
1019	if (statusLines & TIOCM_LE)
1020	newStatusLine \|= PDMICHARPORT_STATUS_LINES_DSR;
1021	if (statusLines & TIOCM_CTS)
1022	newStatusLine \|= PDMICHARPORT_STATUS_LINES_CTS;
1023	rc = pThis->pDrvCharPort->pfnNotifyStatusLinesChanged(pThis->pDrvCharPort, newStatusLine);
1024	}
1025
1026	return VINF_SUCCESS;
1027	}
1028
1029	/**
1030	* Unblock the monitor thread so it can respond to a state change.
1031	* We need to execute this code exactly once during initialization.
1032	* But we don't want to block --- therefore this dedicated thread.
1033	*
1034	* @returns a VBox status code.
1035	* @param pDrvIns The driver instance.
1036	* @param pThread The send thread.
1037	*/
1038	static DECLCALLBACK(int) drvHostSerialWakeupMonitorThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
1039	{
1040	# ifdef RT_OS_LINUX
1041	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
1042	int rc = VINF_SUCCESS;
1043	# if 0
1044	unsigned int uSerialLineFlags;
1045	unsigned int uSerialLineStatus;
1046	unsigned int uIoctl;
1047	# endif
1048
1049	/*
1050	* Linux is a bit difficult as the thread is sleeping in an ioctl call.
1051	* So there is no way to have a wakeup pipe.
1052	*
1053	* 1. Thatswhy we set the serial device into loopback mode and change one of the
1054	* modem control bits.
1055	* This should make the ioctl call return.
1056	*
1057	* 2. We still got reports about long shutdown times. It may bepossible
1058	* that the loopback mode is not implemented on all devices.
1059	* The next possible solution is to close the device file to make the ioctl
1060	* return with EBADF and be able to suspend the thread.
1061	*
1062	* 3. The second approach doesn't work too, the ioctl doesn't return.
1063	* But it seems that the ioctl is interruptible (return code in errno is EINTR).
1064	*/
1065
1066	# if 0 /* Disabled because it does not work for all. */
1067	/* Get current status of control lines. */
1068	rc = ioctl(pThis->DeviceFile, TIOCMGET, &uSerialLineStatus);
1069	if (rc < 0)
1070	goto ioctl_error;
1071
1072	uSerialLineFlags = TIOCM_LOOP;
1073	rc = ioctl(pThis->DeviceFile, TIOCMBIS, &uSerialLineFlags);
1074	if (rc < 0)
1075	goto ioctl_error;
1076
1077	/*
1078	* Change current level on the RTS pin to make the ioctl call return in the
1079	* monitor thread.
1080	*/
1081	uIoctl = (uSerialLineStatus & TIOCM_CTS) ? TIOCMBIC : TIOCMBIS;
1082	uSerialLineFlags = TIOCM_RTS;
1083
1084	rc = ioctl(pThis->DeviceFile, uIoctl, &uSerialLineFlags);
1085	if (rc < 0)
1086	goto ioctl_error;
1087
1088	/* Change RTS back to the previous level. */
1089	uIoctl = (uIoctl == TIOCMBIC) ? TIOCMBIS : TIOCMBIC;
1090
1091	rc = ioctl(pThis->DeviceFile, uIoctl, &uSerialLineFlags);
1092	if (rc < 0)
1093	goto ioctl_error;
1094
1095	/*
1096	* Set serial device into normal state.
1097	*/
1098	uSerialLineFlags = TIOCM_LOOP;
1099	rc = ioctl(pThis->DeviceFile, TIOCMBIC, &uSerialLineFlags);
1100	if (rc >= 0)
1101	return VINF_SUCCESS;
1102
1103	ioctl_error:
1104	PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /fFlags/, "DrvHostSerialFail",
1105	N_("Ioctl failed for serial host device '%s' (%Rrc). The device will not work properly"),
1106	pThis->pszDevicePath, RTErrConvertFromErrno(errno));
1107	# endif
1108
1109	# if 0
1110	/* Close file to make ioctl return. */
1111	RTFileClose(pData->DeviceFile);
1112	/* Open again to make use after suspend possible again. */
1113	rc = RTFileOpen(&pData->DeviceFile, pData->pszDevicePath, RTFILE_O_OPEN \| RTFILE_O_READWRITE);
1114	AssertMsgRC(rc, ("Opening device file again failed rc=%Rrc\n", rc));
1115
1116	if (RT_FAILURE(rc))
1117	PDMDrvHlpVMSetRuntimeError(pDrvIns, false, "DrvHostSerialFail",
1118	N_("Opening failed for serial host device '%s' (%Rrc). The device will not work"),
1119	pData->pszDevicePath, rc);
1120	# endif
1121
1122	rc = RTThreadPoke(pThread->Thread);
1123	if (RT_FAILURE(rc))
1124	PDMDrvHlpVMSetRuntimeError(pDrvIns, 0 /fFlags/, "DrvHostSerialFail",
1125	N_("Suspending serial monitor thread failed for serial device '%s' (%Rrc). The shutdown may take longer than expected"),
1126	pThis->pszDevicePath, RTErrConvertFromErrno(rc));
1127
1128	# else /* !RT_OS_LINUX*/
1129
1130	/* In polling mode there is nobody to wake up (PDMThread will cancel the sleep). */
1131	NOREF(pDrvIns);
1132	NOREF(pThread);
1133
1134	# endif /* RT_OS_LINUX */
1135
1136	return VINF_SUCCESS;
1137	}
1138	#endif /* RT_OS_LINUX \|\| RT_OS_DARWIN \|\| RT_OS_SOLARIS */
1139
1140	/**
1141	* Set the modem lines.
1142	*
1143	* @returns VBox status code
1144	* @param pInterface Pointer to the interface structure.
1145	* @param RequestToSend Set to true if this control line should be made active.
1146	* @param DataTerminalReady Set to true if this control line should be made active.
1147	*/
1148	static DECLCALLBACK(int) drvHostSerialSetModemLines(PPDMICHARCONNECTOR pInterface, bool RequestToSend, bool DataTerminalReady)
1149	{
1150	PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
1151
1152	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1153	int modemStateSet = 0;
1154	int modemStateClear = 0;
1155
1156	if (RequestToSend)
1157	modemStateSet \|= TIOCM_RTS;
1158	else
1159	modemStateClear \|= TIOCM_RTS;
1160
1161	if (DataTerminalReady)
1162	modemStateSet \|= TIOCM_DTR;
1163	else
1164	modemStateClear \|= TIOCM_DTR;
1165
1166	if (modemStateSet)
1167	ioctl(pThis->DeviceFile, TIOCMBIS, &modemStateSet);
1168
1169	if (modemStateClear)
1170	ioctl(pThis->DeviceFile, TIOCMBIC, &modemStateClear);
1171	#elif defined(RT_OS_WINDOWS)
1172	if (RequestToSend)
1173	EscapeCommFunction(pThis->hDeviceFile, SETRTS);
1174	else
1175	EscapeCommFunction(pThis->hDeviceFile, CLRRTS);
1176
1177	if (DataTerminalReady)
1178	EscapeCommFunction(pThis->hDeviceFile, SETDTR);
1179	else
1180	EscapeCommFunction(pThis->hDeviceFile, CLRDTR);
1181	#endif
1182
1183	return VINF_SUCCESS;
1184	}
1185
1186	/**
1187	* Sets the TD line into break condition.
1188	*
1189	* @returns VBox status code.
1190	* @param pInterface Pointer to the interface structure containing the called function pointer.
1191	* @param fBreak Set to true to let the device send a break false to put into normal operation.
1192	* @thread Any thread.
1193	*/
1194	static DECLCALLBACK(int) drvHostSerialSetBreak(PPDMICHARCONNECTOR pInterface, bool fBreak)
1195	{
1196	PDRVHOSTSERIAL pThis = PDMICHAR_2_DRVHOSTSERIAL(pInterface);
1197
1198	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1199	if (fBreak)
1200	ioctl(pThis->DeviceFile, TIOCSBRK);
1201	else
1202	ioctl(pThis->DeviceFile, TIOCCBRK);
1203
1204	#elif defined(RT_OS_WINDOWS)
1205	if (fBreak)
1206	SetCommBreak(pThis->hDeviceFile);
1207	else
1208	ClearCommBreak(pThis->hDeviceFile);
1209	#endif
1210
1211	return VINF_SUCCESS;
1212	}
1213
1214	/* -=-=-=-=- driver interface -=-=-=-=- */
1215
1216	/**
1217	* Destruct a char driver instance.
1218	*
1219	* Most VM resources are freed by the VM. This callback is provided so that
1220	* any non-VM resources can be freed correctly.
1221	*
1222	* @param pDrvIns The driver instance data.
1223	*/
1224	static DECLCALLBACK(void) drvHostSerialDestruct(PPDMDRVINS pDrvIns)
1225	{
1226	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
1227	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
1228	PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1229
1230	/* Empty the send queue */
1231	pThis->iSendQueueTail = pThis->iSendQueueHead = 0;
1232
1233	RTSemEventDestroy(pThis->SendSem);
1234	pThis->SendSem = NIL_RTSEMEVENT;
1235
1236	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1237
1238	if (pThis->WakeupPipeW != NIL_RTFILE)
1239	{
1240	int rc = RTFileClose(pThis->WakeupPipeW);
1241	AssertRC(rc);
1242	pThis->WakeupPipeW = NIL_RTFILE;
1243	}
1244	if (pThis->WakeupPipeR != NIL_RTFILE)
1245	{
1246	int rc = RTFileClose(pThis->WakeupPipeR);
1247	AssertRC(rc);
1248	pThis->WakeupPipeR = NIL_RTFILE;
1249	}
1250	# if defined(RT_OS_DARWIN)
1251	if (pThis->DeviceFileR != NIL_RTFILE)
1252	{
1253	if (pThis->DeviceFileR != pThis->DeviceFile)
1254	{
1255	int rc = RTFileClose(pThis->DeviceFileR);
1256	AssertRC(rc);
1257	}
1258	pThis->DeviceFileR = NIL_RTFILE;
1259	}
1260	# endif
1261	if (pThis->DeviceFile != NIL_RTFILE)
1262	{
1263	int rc = RTFileClose(pThis->DeviceFile);
1264	AssertRC(rc);
1265	pThis->DeviceFile = NIL_RTFILE;
1266	}
1267
1268	#elif defined(RT_OS_WINDOWS)
1269
1270	CloseHandle(pThis->hEventRecv);
1271	CloseHandle(pThis->hEventSend);
1272	CancelIo(pThis->hDeviceFile);
1273	CloseHandle(pThis->hDeviceFile);
1274
1275	#endif
1276
1277	if (pThis->pszDevicePath)
1278	{
1279	MMR3HeapFree(pThis->pszDevicePath);
1280	pThis->pszDevicePath = NULL;
1281	}
1282	}
1283
1284	/**
1285	* Construct a char driver instance.
1286	*
1287	* @copydoc FNPDMDRVCONSTRUCT
1288	*/
1289	static DECLCALLBACK(int) drvHostSerialConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1290	{
1291	PDRVHOSTSERIAL pThis = PDMINS_2_DATA(pDrvIns, PDRVHOSTSERIAL);
1292	LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
1293	PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1294
1295	/*
1296	* Init basic data members and interfaces.
1297	*/
1298	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1299	pThis->DeviceFile = NIL_RTFILE;
1300	# ifdef RT_OS_DARWIN
1301	pThis->DeviceFileR = NIL_RTFILE;
1302	# endif
1303	pThis->WakeupPipeR = NIL_RTFILE;
1304	pThis->WakeupPipeW = NIL_RTFILE;
1305	#endif
1306	/* IBase. */
1307	pDrvIns->IBase.pfnQueryInterface = drvHostSerialQueryInterface;
1308	/* ICharConnector. */
1309	pThis->ICharConnector.pfnWrite = drvHostSerialWrite;
1310	pThis->ICharConnector.pfnSetParameters = drvHostSerialSetParameters;
1311	pThis->ICharConnector.pfnSetModemLines = drvHostSerialSetModemLines;
1312	pThis->ICharConnector.pfnSetBreak = drvHostSerialSetBreak;
1313
1314	/** @todo Initialize all members with NIL values!! The destructor is ALWAYS called. */
1315
1316	/*
1317	* Query configuration.
1318	*/
1319	/* Device */
1320	int rc = CFGMR3QueryStringAlloc(pCfg, "DevicePath", &pThis->pszDevicePath);
1321	if (RT_FAILURE(rc))
1322	{
1323	AssertMsgFailed(("Configuration error: query for \"DevicePath\" string returned %Rra.\n", rc));
1324	return rc;
1325	}
1326
1327	/*
1328	* Open the device
1329	*/
1330	#ifdef RT_OS_WINDOWS
1331
1332	pThis->hHaltEventSem = CreateEvent(NULL, FALSE, FALSE, NULL);
1333	AssertReturn(pThis->hHaltEventSem != NULL, VERR_NO_MEMORY);
1334
1335	pThis->hEventRecv = CreateEvent(NULL, FALSE, FALSE, NULL);
1336	AssertReturn(pThis->hEventRecv != NULL, VERR_NO_MEMORY);
1337
1338	pThis->hEventSend = CreateEvent(NULL, FALSE, FALSE, NULL);
1339	AssertReturn(pThis->hEventSend != NULL, VERR_NO_MEMORY);
1340
1341	HANDLE hFile = CreateFile(pThis->pszDevicePath,
1342	GENERIC_READ \| GENERIC_WRITE,
1343	0, // must be opened with exclusive access
1344	NULL, // no SECURITY_ATTRIBUTES structure
1345	OPEN_EXISTING, // must use OPEN_EXISTING
1346	FILE_FLAG_OVERLAPPED, // overlapped I/O
1347	NULL); // no template file
1348	if (hFile == INVALID_HANDLE_VALUE)
1349	rc = RTErrConvertFromWin32(GetLastError());
1350	else
1351	{
1352	pThis->hDeviceFile = hFile;
1353	/* for overlapped read */
1354	if (!SetCommMask(hFile, EV_RXCHAR \| EV_CTS \| EV_DSR \| EV_RING \| EV_RLSD))
1355	{
1356	LogRel(("HostSerial#%d: SetCommMask failed with error %d.\n", pDrvIns->iInstance, GetLastError()));
1357	return VERR_FILE_IO_ERROR;
1358	}
1359	rc = VINF_SUCCESS;
1360	}
1361
1362	#else
1363
1364	rc = RTFileOpen(&pThis->DeviceFile, pThis->pszDevicePath, RTFILE_O_READWRITE \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
1365	# ifdef RT_OS_DARWIN
1366	if (RT_SUCCESS(rc))
1367	rc = RTFileOpen(&pThis->DeviceFileR, pThis->pszDevicePath, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE);
1368	# endif
1369
1370
1371	#endif
1372
1373	if (RT_FAILURE(rc))
1374	{
1375	AssertMsgFailed(("Could not open host device %s, rc=%Rrc\n", pThis->pszDevicePath, rc));
1376	switch (rc)
1377	{
1378	case VERR_ACCESS_DENIED:
1379	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1380	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1381	N_("Cannot open host device '%s' for read/write access. Check the permissions "
1382	"of that device ('/bin/ls -l %s'): Most probably you need to be member "
1383	"of the device group. Make sure that you logout/login after changing "
1384	"the group settings of the current user"),
1385	#else
1386	N_("Cannot open host device '%s' for read/write access. Check the permissions "
1387	"of that device"),
1388	#endif
1389	pThis->pszDevicePath, pThis->pszDevicePath);
1390	default:
1391	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,
1392	N_("Failed to open host device '%s'"),
1393	pThis->pszDevicePath);
1394	}
1395	}
1396
1397	/* Set to non blocking I/O */
1398	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1399
1400	fcntl(pThis->DeviceFile, F_SETFL, O_NONBLOCK);
1401	# ifdef RT_OS_DARWIN
1402	fcntl(pThis->DeviceFileR, F_SETFL, O_NONBLOCK);
1403	# endif
1404	int aFDs[2];
1405	if (pipe(aFDs) != 0)
1406	{
1407	rc = RTErrConvertFromErrno(errno);
1408	AssertRC(rc);
1409	return rc;
1410	}
1411	pThis->WakeupPipeR = aFDs[0];
1412	pThis->WakeupPipeW = aFDs[1];
1413
1414	#elif defined(RT_OS_WINDOWS)
1415
1416	/* Set the COMMTIMEOUTS to get non blocking I/O */
1417	COMMTIMEOUTS comTimeout;
1418
1419	comTimeout.ReadIntervalTimeout = MAXDWORD;
1420	comTimeout.ReadTotalTimeoutMultiplier = 0;
1421	comTimeout.ReadTotalTimeoutConstant = 0;
1422	comTimeout.WriteTotalTimeoutMultiplier = 0;
1423	comTimeout.WriteTotalTimeoutConstant = 0;
1424
1425	SetCommTimeouts(pThis->hDeviceFile, &comTimeout);
1426
1427	#endif
1428
1429	/*
1430	* Get the ICharPort interface of the above driver/device.
1431	*/
1432	pThis->pDrvCharPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMICHARPORT);
1433	if (!pThis->pDrvCharPort)
1434	return PDMDrvHlpVMSetError(pDrvIns, VERR_PDM_MISSING_INTERFACE_ABOVE, RT_SRC_POS, N_("HostSerial#%d has no char port interface above"), pDrvIns->iInstance);
1435
1436	/*
1437	* Create the receive, send and monitor threads pluss the related send semaphore.
1438	*/
1439	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pRecvThread, pThis, drvHostSerialRecvThread, drvHostSerialWakeupRecvThread, 0, RTTHREADTYPE_IO, "SerRecv");
1440	if (RT_FAILURE(rc))
1441	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create receive thread"), pDrvIns->iInstance);
1442
1443	rc = RTSemEventCreate(&pThis->SendSem);
1444	AssertRC(rc);
1445
1446	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pSendThread, pThis, drvHostSerialSendThread, drvHostSerialWakeupSendThread, 0, RTTHREADTYPE_IO, "SerSend");
1447	if (RT_FAILURE(rc))
1448	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create send thread"), pDrvIns->iInstance);
1449
1450	#if defined(RT_OS_LINUX) \|\| defined(RT_OS_DARWIN) \|\| defined(RT_OS_SOLARIS) \|\| defined(RT_OS_FREEBSD)
1451	/* Linux & darwin needs a separate thread which monitors the status lines. */
1452	# ifndef RT_OS_LINUX
1453	ioctl(pThis->DeviceFile, TIOCMGET, &pThis->fStatusLines);
1454	# endif
1455	rc = PDMDrvHlpThreadCreate(pDrvIns, &pThis->pMonitorThread, pThis, drvHostSerialMonitorThread, drvHostSerialWakeupMonitorThread, 0, RTTHREADTYPE_IO, "SerMon");
1456	if (RT_FAILURE(rc))
1457	return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS, N_("HostSerial#%d cannot create monitor thread"), pDrvIns->iInstance);
1458	#endif
1459
1460	/*
1461	* Register release statistics.
1462	*/
1463	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes written", "/Devices/HostSerial%d/Written", pDrvIns->iInstance);
1464	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes read", "/Devices/HostSerial%d/Read", pDrvIns->iInstance);
1465	#ifdef RT_OS_DARWIN /* new Write code, not darwin specific. */
1466	PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatSendOverflows, STAMTYPE_COUNTER, STAMVISIBILITY_USED, STAMUNIT_BYTES, "Nr of bytes overflowed", "/Devices/HostSerial%d/SendOverflow", pDrvIns->iInstance);
1467	#endif
1468
1469	return VINF_SUCCESS;
1470	}
1471
1472	/**
1473	* Char driver registration record.
1474	*/
1475	const PDMDRVREG g_DrvHostSerial =
1476	{
1477	/* u32Version */
1478	PDM_DRVREG_VERSION,
1479	/* szName */
1480	"Host Serial",
1481	/* szRCMod */
1482	"",
1483	/* szR0Mod */
1484	"",
1485	/* pszDescription */
1486	"Host serial driver.",
1487	/* fFlags */
1488	PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1489	/* fClass. */
1490	PDM_DRVREG_CLASS_CHAR,
1491	/* cMaxInstances */
1492	~0,
1493	/* cbInstance */
1494	sizeof(DRVHOSTSERIAL),
1495	/* pfnConstruct */
1496	drvHostSerialConstruct,
1497	/* pfnDestruct */
1498	drvHostSerialDestruct,
1499	/* pfnRelocate */
1500	NULL,
1501	/* pfnIOCtl */
1502	NULL,
1503	/* pfnPowerOn */
1504	NULL,
1505	/* pfnReset */
1506	NULL,
1507	/* pfnSuspend */
1508	NULL,
1509	/* pfnResume */
1510	NULL,
1511	/* pfnAttach */
1512	NULL,
1513	/* pfnDetach */
1514	NULL,
1515	/* pfnPowerOff */
1516	NULL,
1517	/* pfnSoftReset */
1518	NULL,
1519	/* u32EndVersion */
1520	PDM_DRVREG_VERSION
1521	};
1522

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

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

Download in other formats: