← Back to branch summary

~ubuntu-branches/ubuntu/raring/virtualbox-ose/raring

« back to all changes in this revision

Viewing changes to src/VBox/Main/BIOSSettingsImpl.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2011-01-30 23:27:25 UTC
  • mfrom: (0.3.12 upstream)
  • Revision ID: james.westby@ubuntu.com-20110130232725-2ouajjd2ggdet0zd
Tags: 4.0.2-dfsg-1ubuntu1
* Merge from Debian unstable, remaining changes:
  - Add Apport hook.
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Drop *-source packages.
* Drop ubuntu-01-fix-build-gcc45.patch, fixed upstream.
* Drop ubuntu-02-as-needed.patch, added to the Debian package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Main/BIOSSettingsImpl.cpp
1
 
/** @file
2
 
 *
3
 
 * VirtualBox COM class implementation
4
 
 */
5
 
 
6
 
/*
7
 
 * Copyright (C) 2006-2007 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
 
#include "BIOSSettingsImpl.h"
19
 
#include "MachineImpl.h"
20
 
#include "GuestOSTypeImpl.h"
21
 
 
22
 
#include <iprt/cpp/utils.h>
23
 
#include <VBox/settings.h>
24
 
 
25
 
#include "AutoStateDep.h"
26
 
#include "AutoCaller.h"
27
 
#include "Logging.h"
28
 
 
29
 
////////////////////////////////////////////////////////////////////////////////
30
 
//
31
 
// BIOSSettings private data definition
32
 
//
33
 
////////////////////////////////////////////////////////////////////////////////
34
 
 
35
 
struct BIOSSettings::Data
36
 
{
37
 
    Data()
38
 
        : pMachine(NULL)
39
 
    { }
40
 
 
41
 
    Machine * const             pMachine;
42
 
    ComObjPtr<BIOSSettings>     pPeer;
43
 
 
44
 
    // use the XML settings structure in the members for simplicity
45
 
    Backupable<settings::BIOSSettings> bd;
46
 
};
47
 
 
48
 
// constructor / destructor
49
 
/////////////////////////////////////////////////////////////////////////////
50
 
 
51
 
HRESULT BIOSSettings::FinalConstruct()
52
 
{
53
 
    return S_OK;
54
 
}
55
 
 
56
 
void BIOSSettings::FinalRelease()
57
 
{
58
 
    uninit ();
59
 
}
60
 
 
61
 
// public initializer/uninitializer for internal purposes only
62
 
/////////////////////////////////////////////////////////////////////////////
63
 
 
64
 
/**
65
 
 * Initializes the audio adapter object.
66
 
 *
67
 
 * @returns COM result indicator
68
 
 */
69
 
HRESULT BIOSSettings::init(Machine *aParent)
70
 
{
71
 
    LogFlowThisFuncEnter();
72
 
    LogFlowThisFunc(("aParent: %p\n", aParent));
73
 
 
74
 
    ComAssertRet(aParent, E_INVALIDARG);
75
 
 
76
 
    /* Enclose the state transition NotReady->InInit->Ready */
77
 
    AutoInitSpan autoInitSpan(this);
78
 
    AssertReturn(autoInitSpan.isOk(), E_FAIL);
79
 
 
80
 
    m = new Data();
81
 
 
82
 
    /* share the parent weakly */
83
 
    unconst(m->pMachine) = aParent;
84
 
 
85
 
    m->bd.allocate();
86
 
 
87
 
    autoInitSpan.setSucceeded();
88
 
 
89
 
    LogFlowThisFuncLeave();
90
 
    return S_OK;
91
 
}
92
 
 
93
 
/**
94
 
 *  Initializes the audio adapter object given another audio adapter object
95
 
 *  (a kind of copy constructor). This object shares data with
96
 
 *  the object passed as an argument.
97
 
 *
98
 
 *  @note This object must be destroyed before the original object
99
 
 *  it shares data with is destroyed.
100
 
 */
101
 
HRESULT BIOSSettings::init(Machine *aParent, BIOSSettings *that)
102
 
{
103
 
    LogFlowThisFuncEnter();
104
 
    LogFlowThisFunc(("aParent: %p, that: %p\n", aParent, that));
105
 
 
106
 
    ComAssertRet(aParent && that, E_INVALIDARG);
107
 
 
108
 
    /* Enclose the state transition NotReady->InInit->Ready */
109
 
    AutoInitSpan autoInitSpan(this);
110
 
    AssertReturn(autoInitSpan.isOk(), E_FAIL);
111
 
 
112
 
    m = new Data();
113
 
 
114
 
    unconst(m->pMachine) = aParent;
115
 
    m->pPeer = that;
116
 
 
117
 
    AutoWriteLock thatlock(that COMMA_LOCKVAL_SRC_POS);
118
 
    m->bd.share(that->m->bd);
119
 
 
120
 
    autoInitSpan.setSucceeded();
121
 
 
122
 
    LogFlowThisFuncLeave();
123
 
    return S_OK;
124
 
}
125
 
 
126
 
/**
127
 
 *  Initializes the guest object given another guest object
128
 
 *  (a kind of copy constructor). This object makes a private copy of data
129
 
 *  of the original object passed as an argument.
130
 
 */
131
 
HRESULT BIOSSettings::initCopy(Machine *aParent, BIOSSettings *that)
132
 
{
133
 
    LogFlowThisFuncEnter();
134
 
    LogFlowThisFunc(("aParent: %p, that: %p\n", aParent, that));
135
 
 
136
 
    ComAssertRet(aParent && that, E_INVALIDARG);
137
 
 
138
 
    /* Enclose the state transition NotReady->InInit->Ready */
139
 
    AutoInitSpan autoInitSpan(this);
140
 
    AssertReturn(autoInitSpan.isOk(), E_FAIL);
141
 
 
142
 
    m = new Data();
143
 
 
144
 
    unconst(m->pMachine) = aParent;
145
 
    // mPeer is left null
146
 
 
147
 
    AutoWriteLock thatlock(that COMMA_LOCKVAL_SRC_POS);
148
 
    m->bd.attachCopy(that->m->bd);
149
 
 
150
 
    autoInitSpan.setSucceeded();
151
 
 
152
 
    LogFlowThisFuncLeave();
153
 
    return S_OK;
154
 
}
155
 
 
156
 
/**
157
 
 *  Uninitializes the instance and sets the ready flag to FALSE.
158
 
 *  Called either from FinalRelease() or by the parent when it gets destroyed.
159
 
 */
160
 
void BIOSSettings::uninit()
161
 
{
162
 
    LogFlowThisFuncEnter();
163
 
 
164
 
    /* Enclose the state transition Ready->InUninit->NotReady */
165
 
    AutoUninitSpan autoUninitSpan(this);
166
 
    if (autoUninitSpan.uninitDone())
167
 
        return;
168
 
 
169
 
    m->bd.free();
170
 
 
171
 
    unconst(m->pPeer) = NULL;
172
 
    unconst(m->pMachine) = NULL;
173
 
 
174
 
    delete m;
175
 
    m = NULL;
176
 
 
177
 
    LogFlowThisFuncLeave();
178
 
}
179
 
 
180
 
// IBIOSSettings properties
181
 
/////////////////////////////////////////////////////////////////////////////
182
 
 
183
 
STDMETHODIMP BIOSSettings::COMGETTER(LogoFadeIn)(BOOL *enabled)
184
 
{
185
 
    if (!enabled)
186
 
        return E_POINTER;
187
 
 
188
 
    AutoCaller autoCaller(this);
189
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
190
 
 
191
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
192
 
 
193
 
    *enabled = m->bd->fLogoFadeIn;
194
 
 
195
 
    return S_OK;
196
 
}
197
 
 
198
 
STDMETHODIMP BIOSSettings::COMSETTER(LogoFadeIn)(BOOL enable)
199
 
{
200
 
    AutoCaller autoCaller(this);
201
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
202
 
 
203
 
    /* the machine needs to be mutable */
204
 
    AutoMutableStateDependency adep(m->pMachine);
205
 
    if (FAILED(adep.rc())) return adep.rc();
206
 
 
207
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
208
 
 
209
 
    m->bd.backup();
210
 
    m->bd->fLogoFadeIn = !!enable;
211
 
 
212
 
    alock.release();
213
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
214
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
215
 
 
216
 
    return S_OK;
217
 
}
218
 
 
219
 
STDMETHODIMP BIOSSettings::COMGETTER(LogoFadeOut)(BOOL *enabled)
220
 
{
221
 
    if (!enabled)
222
 
        return E_POINTER;
223
 
 
224
 
    AutoCaller autoCaller(this);
225
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
226
 
 
227
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
228
 
 
229
 
    *enabled = m->bd->fLogoFadeOut;
230
 
 
231
 
    return S_OK;
232
 
}
233
 
 
234
 
STDMETHODIMP BIOSSettings::COMSETTER(LogoFadeOut)(BOOL enable)
235
 
{
236
 
    AutoCaller autoCaller(this);
237
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
238
 
 
239
 
    /* the machine needs to be mutable */
240
 
    AutoMutableStateDependency adep(m->pMachine);
241
 
    if (FAILED(adep.rc())) return adep.rc();
242
 
 
243
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
244
 
 
245
 
    m->bd.backup();
246
 
    m->bd->fLogoFadeOut = !!enable;
247
 
 
248
 
    alock.release();
249
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
250
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
251
 
 
252
 
    return S_OK;
253
 
}
254
 
 
255
 
STDMETHODIMP BIOSSettings::COMGETTER(LogoDisplayTime)(ULONG *displayTime)
256
 
{
257
 
    if (!displayTime)
258
 
        return E_POINTER;
259
 
 
260
 
    AutoCaller autoCaller(this);
261
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
262
 
 
263
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
264
 
 
265
 
    *displayTime = m->bd->ulLogoDisplayTime;
266
 
 
267
 
    return S_OK;
268
 
}
269
 
 
270
 
STDMETHODIMP BIOSSettings::COMSETTER(LogoDisplayTime)(ULONG displayTime)
271
 
{
272
 
    AutoCaller autoCaller(this);
273
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
274
 
 
275
 
    /* the machine needs to be mutable */
276
 
    AutoMutableStateDependency adep(m->pMachine);
277
 
    if (FAILED(adep.rc())) return adep.rc();
278
 
 
279
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
280
 
 
281
 
    m->bd.backup();
282
 
    m->bd->ulLogoDisplayTime = displayTime;
283
 
 
284
 
    alock.release();
285
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
286
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
287
 
 
288
 
    return S_OK;
289
 
}
290
 
 
291
 
STDMETHODIMP BIOSSettings::COMGETTER(LogoImagePath)(BSTR *imagePath)
292
 
{
293
 
    if (!imagePath)
294
 
        return E_POINTER;
295
 
 
296
 
    AutoCaller autoCaller(this);
297
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
298
 
 
299
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
300
 
 
301
 
    m->bd->strLogoImagePath.cloneTo(imagePath);
302
 
    return S_OK;
303
 
}
304
 
 
305
 
STDMETHODIMP BIOSSettings::COMSETTER(LogoImagePath)(IN_BSTR imagePath)
306
 
{
307
 
    /* NULL strings are not allowed */
308
 
    if (!imagePath)
309
 
        return E_INVALIDARG;
310
 
 
311
 
    AutoCaller autoCaller(this);
312
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
313
 
 
314
 
    /* the machine needs to be mutable */
315
 
    AutoMutableStateDependency adep(m->pMachine);
316
 
    if (FAILED(adep.rc())) return adep.rc();
317
 
 
318
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
319
 
 
320
 
    m->bd.backup();
321
 
    m->bd->strLogoImagePath = imagePath;
322
 
 
323
 
    alock.release();
324
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
325
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
326
 
 
327
 
    return S_OK;
328
 
}
329
 
 
330
 
STDMETHODIMP BIOSSettings::COMGETTER(BootMenuMode)(BIOSBootMenuMode_T *bootMenuMode)
331
 
{
332
 
    if (!bootMenuMode)
333
 
        return E_POINTER;
334
 
 
335
 
    AutoCaller autoCaller(this);
336
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
337
 
 
338
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
339
 
 
340
 
    *bootMenuMode = m->bd->biosBootMenuMode;
341
 
    return S_OK;
342
 
}
343
 
 
344
 
STDMETHODIMP BIOSSettings::COMSETTER(BootMenuMode)(BIOSBootMenuMode_T bootMenuMode)
345
 
{
346
 
    AutoCaller autoCaller(this);
347
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
348
 
 
349
 
    /* the machine needs to be mutable */
350
 
    AutoMutableStateDependency adep(m->pMachine);
351
 
    if (FAILED(adep.rc())) return adep.rc();
352
 
 
353
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
354
 
 
355
 
    m->bd.backup();
356
 
    m->bd->biosBootMenuMode = bootMenuMode;
357
 
 
358
 
    alock.release();
359
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
360
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
361
 
 
362
 
    return S_OK;
363
 
}
364
 
 
365
 
STDMETHODIMP BIOSSettings::COMGETTER(ACPIEnabled)(BOOL *enabled)
366
 
{
367
 
    if (!enabled)
368
 
        return E_POINTER;
369
 
 
370
 
    AutoCaller autoCaller(this);
371
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
372
 
 
373
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
374
 
 
375
 
    *enabled = m->bd->fACPIEnabled;
376
 
 
377
 
    return S_OK;
378
 
}
379
 
 
380
 
STDMETHODIMP BIOSSettings::COMSETTER(ACPIEnabled)(BOOL enable)
381
 
{
382
 
    AutoCaller autoCaller(this);
383
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
384
 
 
385
 
    /* the machine needs to be mutable */
386
 
    AutoMutableStateDependency adep(m->pMachine);
387
 
    if (FAILED(adep.rc())) return adep.rc();
388
 
 
389
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
390
 
 
391
 
    m->bd.backup();
392
 
    m->bd->fACPIEnabled = !!enable;
393
 
 
394
 
    alock.release();
395
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
396
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
397
 
 
398
 
    return S_OK;
399
 
}
400
 
 
401
 
STDMETHODIMP BIOSSettings::COMGETTER(IOAPICEnabled)(BOOL *enabled)
402
 
{
403
 
    if (!enabled)
404
 
        return E_POINTER;
405
 
 
406
 
    AutoCaller autoCaller(this);
407
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
408
 
 
409
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
410
 
 
411
 
    *enabled = m->bd->fIOAPICEnabled;
412
 
 
413
 
    return S_OK;
414
 
}
415
 
 
416
 
STDMETHODIMP BIOSSettings::COMSETTER(IOAPICEnabled)(BOOL enable)
417
 
{
418
 
    AutoCaller autoCaller(this);
419
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
420
 
 
421
 
    /* the machine needs to be mutable */
422
 
    AutoMutableStateDependency adep(m->pMachine);
423
 
    if (FAILED(adep.rc())) return adep.rc();
424
 
 
425
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
426
 
 
427
 
    m->bd.backup();
428
 
    m->bd->fIOAPICEnabled = !!enable;
429
 
 
430
 
    alock.release();
431
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
432
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
433
 
 
434
 
    return S_OK;
435
 
}
436
 
 
437
 
STDMETHODIMP BIOSSettings::COMGETTER(PXEDebugEnabled)(BOOL *enabled)
438
 
{
439
 
    if (!enabled)
440
 
        return E_POINTER;
441
 
 
442
 
    AutoCaller autoCaller(this);
443
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
444
 
 
445
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
446
 
 
447
 
    *enabled = m->bd->fPXEDebugEnabled;
448
 
 
449
 
    return S_OK;
450
 
}
451
 
 
452
 
STDMETHODIMP BIOSSettings::COMSETTER(PXEDebugEnabled)(BOOL enable)
453
 
{
454
 
    AutoCaller autoCaller(this);
455
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
456
 
 
457
 
    /* the machine needs to be mutable */
458
 
    AutoMutableStateDependency adep(m->pMachine);
459
 
    if (FAILED(adep.rc())) return adep.rc();
460
 
 
461
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
462
 
 
463
 
    m->bd.backup();
464
 
    m->bd->fPXEDebugEnabled = !!enable;
465
 
 
466
 
    alock.release();
467
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
468
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
469
 
 
470
 
    return S_OK;
471
 
}
472
 
 
473
 
STDMETHODIMP BIOSSettings::COMGETTER(TimeOffset)(LONG64 *offset)
474
 
{
475
 
    if (!offset)
476
 
        return E_POINTER;
477
 
 
478
 
    AutoCaller autoCaller(this);
479
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
480
 
 
481
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
482
 
 
483
 
    *offset = m->bd->llTimeOffset;
484
 
 
485
 
    return S_OK;
486
 
}
487
 
 
488
 
STDMETHODIMP BIOSSettings::COMSETTER(TimeOffset)(LONG64 offset)
489
 
{
490
 
    AutoCaller autoCaller(this);
491
 
    if (FAILED(autoCaller.rc())) return autoCaller.rc();
492
 
 
493
 
    /* the machine needs to be mutable */
494
 
    AutoMutableStateDependency adep(m->pMachine);
495
 
    if (FAILED(adep.rc())) return adep.rc();
496
 
 
497
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
498
 
 
499
 
    m->bd.backup();
500
 
    m->bd->llTimeOffset = offset;
501
 
 
502
 
    alock.release();
503
 
    AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
504
 
    m->pMachine->setModified(Machine::IsModified_BIOS);
505
 
 
506
 
    return S_OK;
507
 
}
508
 
 
509
 
 
510
 
// IBIOSSettings methods
511
 
/////////////////////////////////////////////////////////////////////////////
512
 
 
513
 
// public methods only for internal purposes
514
 
/////////////////////////////////////////////////////////////////////////////
515
 
 
516
 
/**
517
 
 *  Loads settings from the given machine node.
518
 
 *  May be called once right after this object creation.
519
 
 *
520
 
 *  @param aMachineNode <Machine> node.
521
 
 *
522
 
 *  @note Locks this object for writing.
523
 
 */
524
 
HRESULT BIOSSettings::loadSettings(const settings::BIOSSettings &data)
525
 
{
526
 
    AutoCaller autoCaller(this);
527
 
    AssertComRCReturnRC(autoCaller.rc());
528
 
 
529
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
530
 
 
531
 
    // simply copy
532
 
    *m->bd.data() = data;
533
 
 
534
 
    return S_OK;
535
 
}
536
 
 
537
 
/**
538
 
 *  Saves settings to the given machine node.
539
 
 *
540
 
 *  @param aMachineNode <Machine> node.
541
 
 *
542
 
 *  @note Locks this object for reading.
543
 
 */
544
 
HRESULT BIOSSettings::saveSettings(settings::BIOSSettings &data)
545
 
{
546
 
    AutoCaller autoCaller(this);
547
 
    AssertComRCReturnRC(autoCaller.rc());
548
 
 
549
 
    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
550
 
 
551
 
    data = *m->bd.data();
552
 
 
553
 
    return S_OK;
554
 
}
555
 
 
556
 
void BIOSSettings::rollback()
557
 
{
558
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
559
 
    m->bd.rollback();
560
 
}
561
 
 
562
 
void BIOSSettings::commit()
563
 
{
564
 
    /* sanity */
565
 
    AutoCaller autoCaller(this);
566
 
    AssertComRCReturnVoid(autoCaller.rc());
567
 
 
568
 
    /* sanity too */
569
 
    AutoCaller peerCaller(m->pPeer);
570
 
    AssertComRCReturnVoid(peerCaller.rc());
571
 
 
572
 
    /* lock both for writing since we modify both (mPeer is "master" so locked
573
 
     * first) */
574
 
    AutoMultiWriteLock2 alock(m->pPeer, this COMMA_LOCKVAL_SRC_POS);
575
 
 
576
 
    if (m->bd.isBackedUp())
577
 
    {
578
 
        m->bd.commit();
579
 
        if (m->pPeer)
580
 
        {
581
 
            /* attach new data to the peer and reshare it */
582
 
            AutoWriteLock peerlock(m->pPeer COMMA_LOCKVAL_SRC_POS);
583
 
            m->pPeer->m->bd.attach(m->bd);
584
 
        }
585
 
    }
586
 
}
587
 
 
588
 
void BIOSSettings::copyFrom (BIOSSettings *aThat)
589
 
{
590
 
    AssertReturnVoid (aThat != NULL);
591
 
 
592
 
    /* sanity */
593
 
    AutoCaller autoCaller(this);
594
 
    AssertComRCReturnVoid (autoCaller.rc());
595
 
 
596
 
    /* sanity too */
597
 
    AutoCaller thatCaller (aThat);
598
 
    AssertComRCReturnVoid (thatCaller.rc());
599
 
 
600
 
    /* peer is not modified, lock it for reading (aThat is "master" so locked
601
 
     * first) */
602
 
    AutoReadLock rl(aThat COMMA_LOCKVAL_SRC_POS);
603
 
    AutoWriteLock wl(this COMMA_LOCKVAL_SRC_POS);
604
 
 
605
 
    /* this will back up current data */
606
 
    m->bd.assignCopy(aThat->m->bd);
607
 
}
608
 
 
609
 
void BIOSSettings::applyDefaults (GuestOSType *aOsType)
610
 
{
611
 
    AssertReturnVoid (aOsType != NULL);
612
 
 
613
 
    /* sanity */
614
 
    AutoCaller autoCaller(this);
615
 
    AssertComRCReturnVoid (autoCaller.rc());
616
 
 
617
 
    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
618
 
 
619
 
    /* Initialize default BIOS settings here */
620
 
    m->bd->fIOAPICEnabled = aOsType->recommendedIOAPIC();
621
 
}
622
 
 
623
 
/* vi: set tabstop=4 shiftwidth=4 expandtab: */