SerialPortImpl.cpp@ 69731

Last change on this file since 69731 was 69500, checked in by vboxsync, 7 years ago
*: scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 18.8 KB

Line
1	/* $Id: SerialPortImpl.cpp 69500 2017-10-28 15:14:05Z vboxsync $ */
2	/** @file
3	*
4	* VirtualBox COM class implementation
5	*/
6
7	/*
8	* Copyright (C) 2006-2017 Oracle Corporation
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
19	#include "SerialPortImpl.h"
20	#include "MachineImpl.h"
21	#include "VirtualBoxImpl.h"
22	#include "GuestOSTypeImpl.h"
23
24	#include <iprt/assert.h>
25	#include <iprt/string.h>
26	#include <iprt/cpp/utils.h>
27
28	#include <VBox/settings.h>
29
30	#include "AutoStateDep.h"
31	#include "AutoCaller.h"
32	#include "Logging.h"
33
34	//////////////////////////////////////////////////////////////////////////////////
35	//
36	// SerialPort private data definition
37	//
38	//////////////////////////////////////////////////////////////////////////////////
39
40	struct SerialPort::Data
41	{
42	Data()
43	: fModified(false),
44	pMachine(NULL)
45	{ }
46
47	bool fModified;
48	Machine * const pMachine;
49	const ComObjPtr<SerialPort> pPeer;
50	Backupable<settings::SerialPort> bd;
51	};
52
53	// constructor / destructor
54	/////////////////////////////////////////////////////////////////////////////
55
56	DEFINE_EMPTY_CTOR_DTOR(SerialPort)
57
58	HRESULT SerialPort::FinalConstruct()
59	{
60	return BaseFinalConstruct();
61	}
62
63	void SerialPort::FinalRelease()
64	{
65	uninit();
66	BaseFinalRelease();
67	}
68
69	// public initializer/uninitializer for internal purposes only
70	/////////////////////////////////////////////////////////////////////////////
71
72	/**
73	* Initializes the Serial Port object.
74	*
75	* @param aParent Handle of the parent object.
76	* @param aSlot Slot number the serial port is plugged into.
77	*/
78	HRESULT SerialPort::init(Machine *aParent, ULONG aSlot)
79	{
80	LogFlowThisFunc(("aParent=%p, aSlot=%d\n", aParent, aSlot));
81
82	ComAssertRet(aParent, E_INVALIDARG);
83
84	/* Enclose the state transition NotReady->InInit->Ready */
85	AutoInitSpan autoInitSpan(this);
86	AssertReturn(autoInitSpan.isOk(), E_FAIL);
87
88	m = new Data();
89
90	unconst(m->pMachine) = aParent;
91	/* m->pPeer is left null */
92
93	m->bd.allocate();
94
95	/* initialize data */
96	m->bd->ulSlot = aSlot;
97
98	/* Confirm a successful initialization */
99	autoInitSpan.setSucceeded();
100
101	return S_OK;
102	}
103
104	/**
105	* Initializes the Serial Port object given another serial port object
106	* (a kind of copy constructor). This object shares data with
107	* the object passed as an argument.
108	*
109	* @note This object must be destroyed before the original object
110	* it shares data with is destroyed.
111	*
112	* @note Locks @a aThat object for reading.
113	*/
114	HRESULT SerialPort::init(Machine aParent, SerialPort aThat)
115	{
116	LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
117
118	ComAssertRet(aParent && aThat, E_INVALIDARG);
119
120	/* Enclose the state transition NotReady->InInit->Ready */
121	AutoInitSpan autoInitSpan(this);
122	AssertReturn(autoInitSpan.isOk(), E_FAIL);
123
124	m = new Data();
125
126	unconst(m->pMachine) = aParent;
127	unconst(m->pPeer) = aThat;
128
129	AutoCaller thatCaller(aThat);
130	AssertComRCReturnRC(thatCaller.rc());
131
132	AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
133	m->bd.share(aThat->m->bd);
134
135	/* Confirm a successful initialization */
136	autoInitSpan.setSucceeded();
137
138	return S_OK;
139	}
140
141	/**
142	* Initializes the guest object given another guest object
143	* (a kind of copy constructor). This object makes a private copy of data
144	* of the original object passed as an argument.
145	*
146	* @note Locks @a aThat object for reading.
147	*/
148	HRESULT SerialPort::initCopy(Machine aParent, SerialPort aThat)
149	{
150	LogFlowThisFunc(("aParent=%p, aThat=%p\n", aParent, aThat));
151
152	ComAssertRet(aParent && aThat, E_INVALIDARG);
153
154	/* Enclose the state transition NotReady->InInit->Ready */
155	AutoInitSpan autoInitSpan(this);
156	AssertReturn(autoInitSpan.isOk(), E_FAIL);
157
158	m = new Data();
159
160	unconst(m->pMachine) = aParent;
161	/* pPeer is left null */
162
163	AutoCaller thatCaller(aThat);
164	AssertComRCReturnRC(thatCaller.rc());
165
166	AutoReadLock thatLock(aThat COMMA_LOCKVAL_SRC_POS);
167	m->bd.attachCopy(aThat->m->bd);
168
169	/* Confirm a successful initialization */
170	autoInitSpan.setSucceeded();
171
172	return S_OK;
173	}
174
175	/**
176	* Uninitializes the instance and sets the ready flag to FALSE.
177	* Called either from FinalRelease() or by the parent when it gets destroyed.
178	*/
179	void SerialPort::uninit()
180	{
181	LogFlowThisFunc(("\n"));
182
183	/* Enclose the state transition Ready->InUninit->NotReady */
184	AutoUninitSpan autoUninitSpan(this);
185	if (autoUninitSpan.uninitDone())
186	return;
187
188	m->bd.free();
189
190	unconst(m->pPeer) = NULL;
191	unconst(m->pMachine) = NULL;
192
193	delete m;
194	m = NULL;
195	}
196
197	// ISerialPort properties
198	/////////////////////////////////////////////////////////////////////////////
199
200	HRESULT SerialPort::getEnabled(BOOL *aEnabled)
201	{
202	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
203
204	*aEnabled = m->bd->fEnabled;
205
206	return S_OK;
207	}
208
209
210	HRESULT SerialPort::setEnabled(BOOL aEnabled)
211	{
212	LogFlowThisFunc(("aEnabled=%RTbool\n", aEnabled));
213
214	/* the machine needs to be mutable */
215	AutoMutableStateDependency adep(m->pMachine);
216	if (FAILED(adep.rc())) return adep.rc();
217
218	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
219
220	if (m->bd->fEnabled != RT_BOOL(aEnabled))
221	{
222	m->bd.backup();
223	m->bd->fEnabled = RT_BOOL(aEnabled);
224
225	m->fModified = true;
226	// leave the lock before informing callbacks
227	alock.release();
228
229	AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
230	m->pMachine->i_setModified(Machine::IsModified_SerialPorts);
231	mlock.release();
232
233	m->pMachine->i_onSerialPortChange(this);
234	}
235
236	return S_OK;
237	}
238
239
240	HRESULT SerialPort::getHostMode(PortMode_T *aHostMode)
241	{
242	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
243
244	*aHostMode = m->bd->portMode;
245
246	return S_OK;
247	}
248
249	HRESULT SerialPort::setHostMode(PortMode_T aHostMode)
250	{
251	/* the machine needs to be mutable */
252	AutoMutableOrSavedStateDependency adep(m->pMachine);
253	if (FAILED(adep.rc())) return adep.rc();
254
255	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
256
257	if (m->bd->portMode != aHostMode)
258	{
259	switch (aHostMode)
260	{
261	case PortMode_RawFile:
262	if (m->bd->strPath.isEmpty())
263	return setError(E_INVALIDARG,
264	tr("Cannot set the raw file mode of the serial port %d "
265	"because the file path is empty or null"),
266	m->bd->ulSlot);
267	break;
268	case PortMode_HostPipe:
269	if (m->bd->strPath.isEmpty())
270	return setError(E_INVALIDARG,
271	tr("Cannot set the host pipe mode of the serial port %d "
272	"because the pipe path is empty or null"),
273	m->bd->ulSlot);
274	break;
275	case PortMode_HostDevice:
276	if (m->bd->strPath.isEmpty())
277	return setError(E_INVALIDARG,
278	tr("Cannot set the host device mode of the serial port %d "
279	"because the device path is empty or null"),
280	m->bd->ulSlot);
281	break;
282	case PortMode_TCP:
283	if (m->bd->strPath.isEmpty())
284	return setError(E_INVALIDARG,
285	tr("Cannot set the host device mode of the serial port %d "
286	"because the server address or TCP port is invalid"),
287	m->bd->ulSlot);
288	break;
289	case PortMode_Disconnected:
290	break;
291	}
292
293	m->bd.backup();
294	m->bd->portMode = aHostMode;
295
296	m->fModified = true;
297	// leave the lock before informing callbacks
298	alock.release();
299
300	AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
301	m->pMachine->i_setModified(Machine::IsModified_SerialPorts);
302	mlock.release();
303
304	m->pMachine->i_onSerialPortChange(this);
305	}
306
307	return S_OK;
308	}
309
310	HRESULT SerialPort::getSlot(ULONG *aSlot)
311	{
312	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
313
314	*aSlot = m->bd->ulSlot;
315
316	return S_OK;
317	}
318
319
320	HRESULT SerialPort::getIRQ(ULONG *aIRQ)
321	{
322	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
323
324	*aIRQ = m->bd->ulIRQ;
325
326	return S_OK;
327	}
328
329
330	HRESULT SerialPort::setIRQ(ULONG aIRQ)
331	{
332	/* check IRQ limits
333	* (when changing this, make sure it corresponds to XML schema */
334	if (aIRQ > 255)
335	return setError(E_INVALIDARG,
336	tr("Invalid IRQ number of the serial port %d: %lu (must be in range [0, %lu])"),
337	m->bd->ulSlot, aIRQ, 255);
338
339	/* the machine needs to be mutable */
340	AutoMutableStateDependency adep(m->pMachine);
341	if (FAILED(adep.rc())) return adep.rc();
342
343	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
344
345	if (m->bd->ulIRQ != aIRQ)
346	{
347	m->bd.backup();
348	m->bd->ulIRQ = aIRQ;
349
350	m->fModified = true;
351	// leave the lock before informing callbacks
352	alock.release();
353
354	AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
355	m->pMachine->i_setModified(Machine::IsModified_SerialPorts);
356	mlock.release();
357
358	m->pMachine->i_onSerialPortChange(this);
359	}
360
361	return S_OK;
362	}
363
364
365	HRESULT SerialPort::getIOBase(ULONG *aIOBase)
366	{
367	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
368
369	*aIOBase = m->bd->ulIOBase;
370
371	return S_OK;
372	}
373
374	HRESULT SerialPort::setIOBase(ULONG aIOBase)
375	{
376	/* check IOBase limits
377	* (when changing this, make sure it corresponds to XML schema */
378	if (aIOBase > 0xFFFF)
379	return setError(E_INVALIDARG,
380	tr("Invalid I/O port base address of the serial port %d: %lu (must be in range [0, 0x%X])"),
381	m->bd->ulSlot, aIOBase, 0, 0xFFFF);
382
383	AutoCaller autoCaller(this);
384	if (FAILED(autoCaller.rc())) return autoCaller.rc();
385
386	/* the machine needs to be mutable */
387	AutoMutableStateDependency adep(m->pMachine);
388	if (FAILED(adep.rc())) return adep.rc();
389
390	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
391
392	HRESULT rc = S_OK;
393
394	if (m->bd->ulIOBase != aIOBase)
395	{
396	m->bd.backup();
397	m->bd->ulIOBase = aIOBase;
398
399	m->fModified = true;
400	// leave the lock before informing callbacks
401	alock.release();
402
403	AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
404	m->pMachine->i_setModified(Machine::IsModified_SerialPorts);
405	mlock.release();
406
407	m->pMachine->i_onSerialPortChange(this);
408	}
409
410	return rc;
411	}
412
413	HRESULT SerialPort::getPath(com::Utf8Str &aPath)
414	{
415	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
416
417	aPath = m->bd->strPath;
418
419	return S_OK;
420	}
421
422
423	HRESULT SerialPort::setPath(const com::Utf8Str &aPath)
424	{
425	/* the machine needs to be mutable */
426	AutoMutableOrSavedStateDependency adep(m->pMachine);
427	if (FAILED(adep.rc())) return adep.rc();
428
429	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
430
431	if (aPath != m->bd->strPath)
432	{
433	HRESULT rc = i_checkSetPath(aPath);
434	if (FAILED(rc)) return rc;
435
436	m->bd.backup();
437	m->bd->strPath = aPath;
438
439	m->fModified = true;
440	// leave the lock before informing callbacks
441	alock.release();
442
443	AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
444	m->pMachine->i_setModified(Machine::IsModified_SerialPorts);
445	mlock.release();
446
447	m->pMachine->i_onSerialPortChange(this);
448	}
449
450	return S_OK;
451	}
452
453	HRESULT SerialPort::getServer(BOOL *aServer)
454	{
455	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
456
457	*aServer = m->bd->fServer;
458
459	return S_OK;
460	}
461
462	HRESULT SerialPort::setServer(BOOL aServer)
463	{
464	/* the machine needs to be mutable */
465	AutoMutableOrSavedStateDependency adep(m->pMachine);
466	if (FAILED(adep.rc())) return adep.rc();
467
468	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
469
470	if (m->bd->fServer != RT_BOOL(aServer))
471	{
472	m->bd.backup();
473	m->bd->fServer = RT_BOOL(aServer);
474
475	m->fModified = true;
476	// leave the lock before informing callbacks
477	alock.release();
478
479	AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);
480	m->pMachine->i_setModified(Machine::IsModified_SerialPorts);
481	mlock.release();
482
483	m->pMachine->i_onSerialPortChange(this);
484	}
485
486	return S_OK;
487	}
488
489	// public methods only for internal purposes
490	////////////////////////////////////////////////////////////////////////////////
491
492	/**
493	* Loads settings from the given port node.
494	* May be called once right after this object creation.
495	*
496	* @param data Configuration settings.
497	*
498	* @note Locks this object for writing.
499	*/
500	HRESULT SerialPort::i_loadSettings(const settings::SerialPort &data)
501	{
502
503	AutoCaller autoCaller(this);
504	AssertComRCReturnRC(autoCaller.rc());
505
506	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
507
508	// simply copy
509	*m->bd.data() = data;
510
511	return S_OK;
512	}
513
514	/**
515	* Saves the port settings to the given port node.
516	*
517	* Note that the given Port node is completely empty on input.
518	*
519	* @param data Configuration settings.
520	*
521	* @note Locks this object for reading.
522	*/
523	HRESULT SerialPort::i_saveSettings(settings::SerialPort &data)
524	{
525	AutoCaller autoCaller(this);
526	AssertComRCReturnRC(autoCaller.rc());
527
528	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
529
530	// simply copy
531	data = *m->bd.data();
532
533	return S_OK;
534	}
535
536	/**
537	* Returns true if any setter method has modified settings of this instance.
538	* @return
539	*/
540	bool SerialPort::i_isModified()
541	{
542	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
543	return m->fModified;
544	}
545
546	/**
547	* @note Locks this object for writing.
548	*/
549	void SerialPort::i_rollback()
550	{
551	/* sanity */
552	AutoCaller autoCaller(this);
553	AssertComRCReturnVoid(autoCaller.rc());
554
555	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
556
557	m->bd.rollback();
558	}
559
560	/**
561	* @note Locks this object for writing, together with the peer object (also
562	* for writing) if there is one.
563	*/
564	void SerialPort::i_commit()
565	{
566	/* sanity */
567	AutoCaller autoCaller(this);
568	AssertComRCReturnVoid(autoCaller.rc());
569
570	/* sanity too */
571	AutoCaller peerCaller(m->pPeer);
572	AssertComRCReturnVoid(peerCaller.rc());
573
574	/* lock both for writing since we modify both (pPeer is "master" so locked
575	* first) */
576	AutoMultiWriteLock2 alock(m->pPeer, this COMMA_LOCKVAL_SRC_POS);
577
578	if (m->bd.isBackedUp())
579	{
580	m->bd.commit();
581	if (m->pPeer)
582	{
583	/* attach new data to the peer and reshare it */
584	m->pPeer->m->bd.attach(m->bd);
585	}
586	}
587	}
588
589	/**
590	* @note Locks this object for writing, together with the peer object
591	* represented by @a aThat (locked for reading).
592	*/
593	void SerialPort::i_copyFrom(SerialPort *aThat)
594	{
595	AssertReturnVoid(aThat != NULL);
596
597	/* sanity */
598	AutoCaller autoCaller(this);
599	AssertComRCReturnVoid(autoCaller.rc());
600
601	/* sanity too */
602	AutoCaller thatCaller(aThat);
603	AssertComRCReturnVoid(thatCaller.rc());
604
605	/* peer is not modified, lock it for reading (aThat is "master" so locked
606	* first) */
607	AutoReadLock rl(aThat COMMA_LOCKVAL_SRC_POS);
608	AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
609
610	/* this will back up current data */
611	m->bd.assignCopy(aThat->m->bd);
612	}
613
614	/**
615	* Applies the defaults for this serial port.
616	*
617	* @note This method currently assumes that the object is in the state after
618	* calling init(), it does not set defaults from an arbitrary state.
619	*/
620	void SerialPort::i_applyDefaults(GuestOSType *aOsType)
621	{
622	/* sanity */
623	AutoCaller autoCaller(this);
624	AssertComRCReturnVoid(autoCaller.rc());
625
626	AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
627
628	/* Set some more defaults. */
629	switch (m->bd->ulSlot)
630	{
631	case 0:
632	{
633	m->bd->ulIOBase = 0x3f8;
634	m->bd->ulIRQ = 4;
635	break;
636	}
637	case 1:
638	{
639	m->bd->ulIOBase = 0x2f8;
640	m->bd->ulIRQ = 3;
641	break;
642	}
643	case 2:
644	{
645	m->bd->ulIOBase = 0x3e8;
646	m->bd->ulIRQ = 4;
647	break;
648	}
649	case 3:
650	{
651	m->bd->ulIOBase = 0x2e8;
652	m->bd->ulIRQ = 3;
653	break;
654	}
655	default:
656	AssertMsgFailed(("Serial port slot %u exceeds limit\n", m->bd->ulSlot));
657	break;
658	}
659
660	uint32_t numSerialEnabled = 0;
661	if (aOsType)
662	numSerialEnabled = aOsType->i_numSerialEnabled();
663
664	/* Enable port if requested */
665	if (m->bd->ulSlot < numSerialEnabled)
666	{
667	m->bd->fEnabled = true;
668	}
669	}
670
671	bool SerialPort::i_hasDefaults()
672	{
673	/* sanity */
674	AutoCaller autoCaller(this);
675	AssertComRCReturn(autoCaller.rc(), true);
676
677	AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
678
679	if ( !m->bd->fEnabled
680	&& m->bd->portMode == PortMode_Disconnected
681	&& !m->bd->fServer)
682	{
683	/* Could be default, check the IO base and IRQ. */
684	switch (m->bd->ulSlot)
685	{
686	case 0:
687	if (m->bd->ulIOBase == 0x3f8 && m->bd->ulIRQ == 4)
688	return true;
689	break;
690	case 1:
691	if (m->bd->ulIOBase == 0x2f8 && m->bd->ulIRQ == 3)
692	return true;
693	break;
694	case 2:
695	if (m->bd->ulIOBase == 0x3e8 && m->bd->ulIRQ == 4)
696	return true;
697	break;
698	case 3:
699	if (m->bd->ulIOBase == 0x2e8 && m->bd->ulIRQ == 3)
700	return true;
701	break;
702	default:
703	AssertMsgFailed(("Serial port slot %u exceeds limit\n", m->bd->ulSlot));
704	break;
705	}
706
707	/* Detect old-style defaults (0x3f8, irq 4) in any slot, they are still
708	* in place for many VMs created by old VirtualBox versions. */
709	if (m->bd->ulIOBase == 0x3f8 && m->bd->ulIRQ == 4)
710	return true;
711	}
712
713	return false;
714	}
715
716	/**
717	* Validates COMSETTER(Path) arguments.
718	*/
719	HRESULT SerialPort::i_checkSetPath(const Utf8Str &str)
720	{
721	AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
722
723	if ( ( m->bd->portMode == PortMode_HostDevice
724	\|\| m->bd->portMode == PortMode_HostPipe
725	\|\| m->bd->portMode == PortMode_TCP
726	\|\| m->bd->portMode == PortMode_RawFile
727	) && str.isEmpty()
728	)
729	return setError(E_INVALIDARG,
730	tr("Path of the serial port %d may not be empty or null in "
731	"host pipe, host device or TCP mode"),
732	m->bd->ulSlot);
733
734	return S_OK;
735	}
736
737	/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

source: vbox/trunk/src/VBox/Main/src-server/SerialPortImpl.cpp@ 69731

Download in other formats: