VirtualBox

source: vbox/trunk/src/VBox/Main/DVDDriveImpl.cpp@ 16684

Last change on this file since 16684 was 16560, checked in by vboxsync, 16 years ago

Main: do not include include/VBox/settings.h from other header files but only from implementations that need it (save compile time)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.3 KB
Line 
1/* $Id: DVDDriveImpl.cpp 16560 2009-02-06 18:06:04Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2006-2008 Sun Microsystems, Inc.
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
20 * Clara, CA 95054 USA or visit http://www.sun.com if you need
21 * additional information or have any questions.
22 */
23
24#include "DVDDriveImpl.h"
25
26#include "MachineImpl.h"
27#include "HostImpl.h"
28#include "HostDVDDriveImpl.h"
29#include "VirtualBoxImpl.h"
30
31#include "Global.h"
32
33#include "Logging.h"
34
35#include <iprt/string.h>
36#include <iprt/cpputils.h>
37
38#include <VBox/settings.h>
39
40// constructor / destructor
41////////////////////////////////////////////////////////////////////////////////
42
43DEFINE_EMPTY_CTOR_DTOR (DVDDrive)
44
45HRESULT DVDDrive::FinalConstruct()
46{
47 return S_OK;
48}
49
50void DVDDrive::FinalRelease()
51{
52 uninit();
53}
54
55// public initializer/uninitializer for internal purposes only
56////////////////////////////////////////////////////////////////////////////////
57
58/**
59 * Initializes the DVD drive object.
60 *
61 * @param aParent Handle of the parent object.
62 */
63HRESULT DVDDrive::init (Machine *aParent)
64{
65 LogFlowThisFunc (("aParent=%p\n", aParent));
66
67 ComAssertRet (aParent, E_INVALIDARG);
68
69 /* Enclose the state transition NotReady->InInit->Ready */
70 AutoInitSpan autoInitSpan (this);
71 AssertReturn (autoInitSpan.isOk(), E_FAIL);
72
73 unconst (mParent) = aParent;
74 /* mPeer is left null */
75
76 m.allocate();
77
78 /* Confirm a successful initialization */
79 autoInitSpan.setSucceeded();
80
81 return S_OK;
82}
83
84/**
85 * Initializes the DVD drive object given another DVD drive object
86 * (a kind of copy constructor). This object shares data with
87 * the object passed as an argument.
88 *
89 * @note This object must be destroyed before the original object
90 * it shares data with is destroyed.
91 *
92 * @note Locks @a aThat object for reading.
93 */
94HRESULT DVDDrive::init (Machine *aParent, DVDDrive *aThat)
95{
96 LogFlowThisFunc (("aParent=%p, aThat=%p\n", aParent, aThat));
97
98 ComAssertRet (aParent && aThat, E_INVALIDARG);
99
100 /* Enclose the state transition NotReady->InInit->Ready */
101 AutoInitSpan autoInitSpan (this);
102 AssertReturn (autoInitSpan.isOk(), E_FAIL);
103
104 unconst (mParent) = aParent;
105 unconst (mPeer) = aThat;
106
107 AutoCaller thatCaller (aThat);
108 AssertComRCReturnRC (thatCaller.rc());
109
110 AutoReadLock thatLock (aThat);
111 m.share (aThat->m);
112
113 /* Confirm a successful initialization */
114 autoInitSpan.setSucceeded();
115
116 return S_OK;
117}
118
119/**
120 * Initializes the DVD drive object given another DVD drive object
121 * (a kind of copy constructor). This object makes a private copy of data
122 * of the original object passed as an argument.
123 *
124 * @note Locks @a aThat object for reading.
125 */
126HRESULT DVDDrive::initCopy (Machine *aParent, DVDDrive *aThat)
127{
128 LogFlowThisFunc (("aParent=%p, aThat=%p\n", aParent, aThat));
129
130 ComAssertRet (aParent && aThat, E_INVALIDARG);
131
132 /* Enclose the state transition NotReady->InInit->Ready */
133 AutoInitSpan autoInitSpan (this);
134 AssertReturn (autoInitSpan.isOk(), E_FAIL);
135
136 unconst (mParent) = aParent;
137 /* mPeer is left null */
138
139 AutoCaller thatCaller (aThat);
140 AssertComRCReturnRC (thatCaller.rc());
141
142 AutoReadLock thatLock (aThat);
143 m.attachCopy (aThat->m);
144
145 /* at present, this must be a snapshot machine */
146 Assert (!aParent->snapshotId().isEmpty());
147
148 if (m->state == DriveState_ImageMounted)
149 {
150 /* associate the DVD image media with the snapshot */
151 HRESULT rc = m->image->attachTo (aParent->id(),
152 aParent->snapshotId());
153 AssertComRC (rc);
154 }
155
156 /* Confirm a successful initialization */
157 autoInitSpan.setSucceeded();
158
159 return S_OK;
160}
161
162/**
163 * Uninitializes the instance and sets the ready flag to FALSE.
164 * Called either from FinalRelease() or by the parent when it gets destroyed.
165 */
166void DVDDrive::uninit()
167{
168 LogFlowThisFunc (("\n"));
169
170 /* Enclose the state transition Ready->InUninit->NotReady */
171 AutoUninitSpan autoUninitSpan (this);
172 if (autoUninitSpan.uninitDone())
173 return;
174
175 if ((mParent->type() == Machine::IsMachine ||
176 mParent->type() == Machine::IsSnapshotMachine) &&
177 m->state == DriveState_ImageMounted)
178 {
179 /* Deassociate the DVD image (only when mParent is a real Machine or a
180 * SnapshotMachine instance; SessionMachine instances
181 * refer to real Machine hard disks). This is necessary for a clean
182 * re-initialization of the VM after successfully re-checking the
183 * accessibility state. */
184 HRESULT rc = m->image->detachFrom (mParent->id(),
185 mParent->snapshotId());
186 AssertComRC (rc);
187 }
188
189 m.free();
190
191 unconst (mPeer).setNull();
192 unconst (mParent).setNull();
193}
194
195// IDVDDrive properties
196////////////////////////////////////////////////////////////////////////////////
197
198STDMETHODIMP DVDDrive::COMGETTER(State) (DriveState_T *aState)
199{
200 CheckComArgOutPointerValid(aState);
201
202 AutoCaller autoCaller (this);
203 CheckComRCReturnRC (autoCaller.rc());
204
205 AutoReadLock alock (this);
206
207 *aState = m->state;
208
209 return S_OK;
210}
211
212STDMETHODIMP DVDDrive::COMGETTER(Passthrough) (BOOL *aPassthrough)
213{
214 CheckComArgOutPointerValid(aPassthrough);
215
216 AutoCaller autoCaller (this);
217 CheckComRCReturnRC (autoCaller.rc());
218
219 AutoReadLock alock (this);
220
221 *aPassthrough = m->passthrough;
222
223 return S_OK;
224}
225
226STDMETHODIMP DVDDrive::COMSETTER(Passthrough) (BOOL aPassthrough)
227{
228 AutoCaller autoCaller (this);
229 CheckComRCReturnRC (autoCaller.rc());
230
231 /* the machine needs to be mutable */
232 Machine::AutoMutableStateDependency adep (mParent);
233 CheckComRCReturnRC (adep.rc());
234
235 AutoWriteLock alock (this);
236
237 if (m->passthrough != aPassthrough)
238 {
239 m.backup();
240 m->passthrough = aPassthrough;
241 }
242
243 return S_OK;
244}
245
246// IDVDDrive methods
247////////////////////////////////////////////////////////////////////////////////
248
249STDMETHODIMP DVDDrive::MountImage (IN_GUID aImageId)
250{
251 Guid imageId = aImageId;
252 CheckComArgExpr(aImageId, !imageId.isEmpty());
253
254 AutoCaller autoCaller (this);
255 CheckComRCReturnRC (autoCaller.rc());
256
257 /* the machine needs to be mutable */
258 Machine::AutoMutableStateDependency adep (mParent);
259 CheckComRCReturnRC (adep.rc());
260
261 AutoWriteLock alock (this);
262
263 HRESULT rc = E_FAIL;
264
265 /* Our lifetime is bound to mParent's lifetime, so we don't add caller.
266 * We also don't lock mParent since its mParent field is const. */
267
268 ComObjPtr <DVDImage2> image;
269 rc = mParent->virtualBox()->findDVDImage2 (&imageId, NULL,
270 true /* aSetError */, &image);
271
272 if (SUCCEEDED (rc))
273 {
274 if (m->state != DriveState_ImageMounted ||
275 !m->image.equalsTo (image))
276 {
277 rc = image->attachTo (mParent->id(), mParent->snapshotId());
278 if (SUCCEEDED (rc))
279 {
280 /* umount() will backup data */
281 rc = unmount();
282
283 if (SUCCEEDED (rc))
284 {
285 /* lock the image for reading if the VM is online. It will
286 * be unlocked either when unmounted from this drive or by
287 * SessionMachine::setMachineState() when the VM is
288 * terminated */
289 if (Global::IsOnline (adep.machineState()))
290 rc = image->LockRead (NULL);
291 }
292
293 if (SUCCEEDED (rc))
294 {
295 m->image = image;
296 m->state = DriveState_ImageMounted;
297
298 /* leave the lock before informing callbacks */
299 alock.unlock();
300
301 mParent->onDVDDriveChange();
302 }
303 }
304 }
305 }
306
307 return rc;
308}
309
310STDMETHODIMP DVDDrive::CaptureHostDrive (IHostDVDDrive *aHostDVDDrive)
311{
312 CheckComArgNotNull(aHostDVDDrive);
313
314 AutoCaller autoCaller (this);
315 CheckComRCReturnRC (autoCaller.rc());
316
317 /* the machine needs to be mutable */
318 Machine::AutoMutableStateDependency adep (mParent);
319 CheckComRCReturnRC (adep.rc());
320
321 AutoWriteLock alock (this);
322
323 if (m->state != DriveState_HostDriveCaptured ||
324 !m->hostDrive.equalsTo (aHostDVDDrive))
325 {
326 /* umount() will backup data */
327 HRESULT rc = unmount();
328 if (SUCCEEDED (rc))
329 {
330 m->hostDrive = aHostDVDDrive;
331 m->state = DriveState_HostDriveCaptured;
332
333 /* leave the lock before informing callbacks */
334 alock.unlock();
335
336 mParent->onDVDDriveChange();
337 }
338 }
339
340 return S_OK;
341}
342
343STDMETHODIMP DVDDrive::Unmount()
344{
345 AutoCaller autoCaller (this);
346 CheckComRCReturnRC (autoCaller.rc());
347
348 /* the machine needs to be mutable */
349 Machine::AutoMutableStateDependency adep (mParent);
350 CheckComRCReturnRC (adep.rc());
351
352 AutoWriteLock alock (this);
353
354 if (m->state != DriveState_NotMounted)
355 {
356 /* umount() will backup data */
357 HRESULT rc = unmount();
358 if (SUCCEEDED (rc))
359 {
360 m->state = DriveState_NotMounted;
361
362 /* leave the lock before informing callbacks */
363 alock.unlock();
364
365 mParent->onDVDDriveChange();
366 }
367 }
368
369 return S_OK;
370}
371
372STDMETHODIMP DVDDrive::GetImage (IDVDImage2 **aDVDImage)
373{
374 CheckComArgOutPointerValid(aDVDImage);
375
376 AutoCaller autoCaller (this);
377 CheckComRCReturnRC (autoCaller.rc());
378
379 AutoReadLock alock (this);
380
381 m->image.queryInterfaceTo (aDVDImage);
382
383 return S_OK;
384}
385
386STDMETHODIMP DVDDrive::GetHostDrive(IHostDVDDrive **aHostDrive)
387{
388 CheckComArgOutPointerValid(aHostDrive);
389
390 AutoCaller autoCaller (this);
391 CheckComRCReturnRC (autoCaller.rc());
392
393 AutoReadLock alock (this);
394
395 m->hostDrive.queryInterfaceTo (aHostDrive);
396
397 return S_OK;
398}
399
400// public methods only for internal purposes
401////////////////////////////////////////////////////////////////////////////////
402
403/**
404 * Loads settings from the given machine node. May be called once right after
405 * this object creation.
406 *
407 * @param aMachineNode <Machine> node.
408 *
409 * @note Locks this object for writing.
410 */
411HRESULT DVDDrive::loadSettings (const settings::Key &aMachineNode)
412{
413 using namespace settings;
414
415 AssertReturn (!aMachineNode.isNull(), E_FAIL);
416
417 AutoCaller autoCaller (this);
418 AssertComRCReturnRC (autoCaller.rc());
419
420 AutoWriteLock alock (this);
421
422 /* Note: we assume that the default values for attributes of optional
423 * nodes are assigned in the Data::Data() constructor and don't do it
424 * here. It implies that this method may only be called after constructing
425 * a new BIOSSettings object while all its data fields are in the default
426 * values. Exceptions are fields whose creation time defaults don't match
427 * values that should be applied when these fields are not explicitly set
428 * in the settings file (for backwards compatibility reasons). This takes
429 * place when a setting of a newly created object must default to A while
430 * the same setting of an object loaded from the old settings file must
431 * default to B. */
432
433 HRESULT rc = S_OK;
434
435 /* DVD drive (required, contains either Image or HostDrive or nothing) */
436 Key dvdDriveNode = aMachineNode.key ("DVDDrive");
437
438 /* optional, defaults to false */
439 m->passthrough = dvdDriveNode.value <bool> ("passthrough");
440
441 Key typeNode;
442
443 if (!(typeNode = dvdDriveNode.findKey ("Image")).isNull())
444 {
445 Guid uuid = typeNode.value <Guid> ("uuid");
446 rc = MountImage (uuid);
447 CheckComRCReturnRC (rc);
448 }
449 else if (!(typeNode = dvdDriveNode.findKey ("HostDrive")).isNull())
450 {
451
452 Bstr src = typeNode.stringValue ("src");
453
454 /* find the correspoding object */
455 ComObjPtr <Host> host = mParent->virtualBox()->host();
456
457 ComPtr <IHostDVDDriveCollection> coll;
458 rc = host->COMGETTER(DVDDrives) (coll.asOutParam());
459 AssertComRC (rc);
460
461 ComPtr <IHostDVDDrive> drive;
462 rc = coll->FindByName (src, drive.asOutParam());
463 if (SUCCEEDED (rc))
464 {
465 rc = CaptureHostDrive (drive);
466 CheckComRCReturnRC (rc);
467 }
468 else if (rc == E_INVALIDARG)
469 {
470 /* the host DVD drive is not currently available. we
471 * assume it will be available later and create an
472 * extra object now */
473 ComObjPtr <HostDVDDrive> hostDrive;
474 hostDrive.createObject();
475 rc = hostDrive->init (src);
476 AssertComRC (rc);
477 rc = CaptureHostDrive (hostDrive);
478 CheckComRCReturnRC (rc);
479 }
480 else
481 AssertComRC (rc);
482 }
483
484 return S_OK;
485}
486
487/**
488 * Saves settings to the given machine node.
489 *
490 * @param aMachineNode <Machine> node.
491 *
492 * @note Locks this object for reading.
493 */
494HRESULT DVDDrive::saveSettings (settings::Key &aMachineNode)
495{
496 using namespace settings;
497
498 AssertReturn (!aMachineNode.isNull(), E_FAIL);
499
500 AutoCaller autoCaller (this);
501 AssertComRCReturnRC (autoCaller.rc());
502
503 AutoReadLock alock (this);
504
505 Key node = aMachineNode.createKey ("DVDDrive");
506
507 node.setValue <bool> ("passthrough", !!m->passthrough);
508
509 switch (m->state)
510 {
511 case DriveState_ImageMounted:
512 {
513 Assert (!m->image.isNull());
514
515 Guid id;
516 HRESULT rc = m->image->COMGETTER(Id) (id.asOutParam());
517 AssertComRC (rc);
518 Assert (!id.isEmpty());
519
520 Key imageNode = node.createKey ("Image");
521 imageNode.setValue <Guid> ("uuid", id);
522 break;
523 }
524 case DriveState_HostDriveCaptured:
525 {
526 Assert (!m->hostDrive.isNull());
527
528 Bstr name;
529 HRESULT rc = m->hostDrive->COMGETTER(Name) (name.asOutParam());
530 AssertComRC (rc);
531 Assert (!name.isEmpty());
532
533 Key hostDriveNode = node.createKey ("HostDrive");
534 hostDriveNode.setValue <Bstr> ("src", name);
535 break;
536 }
537 case DriveState_NotMounted:
538 /* do nothing, i.e.leave the drive node empty */
539 break;
540 default:
541 ComAssertMsgFailedRet (("Invalid drive state: %d", m->state),
542 E_FAIL);
543 }
544
545 return S_OK;
546}
547
548/**
549 * @note Locks this object for writing.
550 */
551bool DVDDrive::rollback()
552{
553 /* sanity */
554 AutoCaller autoCaller (this);
555 AssertComRCReturn (autoCaller.rc(), false);
556
557 /* we need adep for the state check */
558 Machine::AutoAnyStateDependency adep (mParent);
559 AssertComRCReturn (adep.rc(), false);
560
561 AutoWriteLock alock (this);
562
563 bool changed = false;
564
565 if (m.isBackedUp())
566 {
567 /* we need to check all data to see whether anything will be changed
568 * after rollback */
569 changed = m.hasActualChanges();
570
571 if (changed)
572 {
573 Data *oldData = m.backedUpData();
574
575 if (!m->image.isNull() &&
576 !oldData->image.equalsTo (m->image))
577 {
578 /* detach the current image that will go away after rollback */
579 m->image->detachFrom (mParent->id(), mParent->snapshotId());
580
581 /* unlock the image for reading if the VM is online */
582 if (Global::IsOnline (adep.machineState()))
583 {
584 HRESULT rc = m->image->UnlockRead (NULL);
585 AssertComRC (rc);
586 }
587 }
588 }
589
590 m.rollback();
591 }
592
593 return changed;
594}
595
596/**
597 * @note Locks this object for writing, together with the peer object (also for
598 * writing) if there is one.
599 */
600void DVDDrive::commit()
601{
602 /* sanity */
603 AutoCaller autoCaller (this);
604 AssertComRCReturnVoid (autoCaller.rc());
605
606 /* sanity too */
607 AutoCaller peerCaller (mPeer);
608 AssertComRCReturnVoid (peerCaller.rc());
609
610 /* we need adep for the state check */
611 Machine::AutoAnyStateDependency adep (mParent);
612 AssertComRCReturnVoid (adep.rc());
613
614 /* lock both for writing since we modify both (mPeer is "master" so locked
615 * first) */
616 AutoMultiWriteLock2 alock (mPeer, this);
617
618 if (m.isBackedUp())
619 {
620 Data *oldData = m.backedUpData();
621
622 if (!oldData->image.isNull() &&
623 !oldData->image.equalsTo (m->image))
624 {
625 /* detach the old image that will go away after commit */
626 oldData->image->detachFrom (mParent->id(), mParent->snapshotId());
627
628 /* unlock the image for reading if the VM is online */
629 if (Global::IsOnline (adep.machineState()))
630 {
631 HRESULT rc = oldData->image->UnlockRead (NULL);
632 AssertComRC (rc);
633 }
634 }
635
636 m.commit();
637 if (mPeer)
638 {
639 /* attach new data to the peer and reshare it */
640 mPeer->m.attach (m);
641 }
642 }
643}
644
645/**
646 * @note Locks this object for writing, together with the peer object
647 * represented by @a aThat (locked for reading).
648 */
649void DVDDrive::copyFrom (DVDDrive *aThat)
650{
651 AssertReturnVoid (aThat != NULL);
652
653 /* sanity */
654 AutoCaller autoCaller (this);
655 AssertComRCReturnVoid (autoCaller.rc());
656
657 /* sanity too */
658 AutoCaller thatCaller (aThat);
659 AssertComRCReturnVoid (thatCaller.rc());
660
661 /* peer is not modified, lock it for reading (aThat is "master" so locked
662 * first) */
663 AutoMultiLock2 alock (aThat->rlock(), this->wlock());
664
665 /* this will back up current data */
666 m.assignCopy (aThat->m);
667}
668
669/**
670 * Helper to unmount a drive.
671 *
672 * @note Must be called from under this object's write lock.
673 */
674HRESULT DVDDrive::unmount()
675{
676 AssertReturn (isWriteLockOnCurrentThread(), E_FAIL);
677
678 m.backup();
679
680 if (m->image)
681 m->image.setNull();
682 if (m->hostDrive)
683 m->hostDrive.setNull();
684
685 m->state = DriveState_NotMounted;
686
687 return S_OK;
688}
689
690// private methods
691////////////////////////////////////////////////////////////////////////////////
692
693/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette