← Back to branch summary

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

« back to all changes in this revision

Viewing changes to include/VBox/pdmdrv.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-12-18 16:44:29 UTC
  • mfrom: (0.3.3 upstream) (0.4.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091218164429-jd34ccexpv5na11a
Tags: 3.1.2-dfsg-1ubuntu1
https://launchpad.net/bugs/498219
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/474625
https://launchpad.net/bugs/495935
https://launchpad.net/bugs/473334
* Merge from Debian unstable (LP: #498219), remaining changes:
  - Disable update action
    - debian/patches/u01-disable-update-action.dpatch
  - VirtualBox should go in Accessories, not in System tools (LP: #288590)
    - debian/virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add Apport hook
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Add Launchpad integration
    - debian/control
    - debian/lpi-bug.xpm
    - debian/patches/u02-lp-integration.dpatch
* Fixes the following bugs:
  - Kernel module fails to build with Linux >= 2.6.32 (LP: #474625)
  - X.Org drivers need to be rebuilt against X-Server 1.7 (LP: #495935)
  - The *-source packages try to build the kernel modules even though the
    kernel headers aren't available (LP: #473334)
* Replace *-source packages with transitional packages for *-dkms.
* Adapt u01-disable-update-action.dpatch and u02-lp-integration.dpatch for
  new upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/VBox/pdmdrv.h
1
1
/** @file
2
 
 * PDM - Pluggable Device Manager, Drivers.
 
2
 * PDM - Pluggable Device Manager, Drivers. (VMM)
3
3
 */
4
4
 
5
5
/*
35
35
#include <VBox/pdmthread.h>
36
36
#include <VBox/pdmifs.h>
37
37
#include <VBox/pdmins.h>
 
38
#include <VBox/pdmcommon.h>
38
39
#include <VBox/tm.h>
39
40
#include <VBox/ssm.h>
40
41
#include <VBox/cfgm.h>
63
64
 * @param   pCfgHandle  Configuration node handle for the driver. Use this to obtain the configuration
64
65
 *                      of the driver instance. It's also found in pDrvIns->pCfgHandle as it's expected
65
66
 *                      to be used frequently in this function.
 
67
 * @param   fFlags      Flags, combination of the PDM_TACH_FLAGS_* \#defines.
66
68
 */
67
 
typedef DECLCALLBACK(int)   FNPDMDRVCONSTRUCT(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle);
 
69
typedef DECLCALLBACK(int)   FNPDMDRVCONSTRUCT(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle, uint32_t fFlags);
68
70
/** Pointer to a FNPDMDRVCONSTRUCT() function. */
69
71
typedef FNPDMDRVCONSTRUCT *PFNPDMDRVCONSTRUCT;
70
72
 
151
153
typedef FNPDMDRVPOWEROFF *PFNPDMDRVPOWEROFF;
152
154
 
153
155
/**
 
156
 * Attach command.
 
157
 *
 
158
 * This is called to let the drive attach to a driver at runtime.  This is not
 
159
 * called during VM construction, the driver constructor have to do this by
 
160
 * calling PDMDrvHlpAttach.
 
161
 *
 
162
 * This is like plugging in the keyboard or mouse after turning on the PC.
 
163
 *
 
164
 * @returns VBox status code.
 
165
 * @param   pDrvIns     The driver instance.
 
166
 * @param   fFlags      Flags, combination of the PDM_TACH_FLAGS_* \#defines.
 
167
 */
 
168
typedef DECLCALLBACK(int)  FNPDMDRVATTACH(PPDMDRVINS pDrvIns, uint32_t fFlags);
 
169
/** Pointer to a FNPDMDRVATTACH() function. */
 
170
typedef FNPDMDRVATTACH *PFNPDMDRVATTACH;
 
171
 
 
172
/**
154
173
 * Detach notification.
155
174
 *
156
175
 * This is called when a driver below it in the chain is detaching itself
159
178
 * This is like ejecting a cdrom or floppy.
160
179
 *
161
180
 * @param   pDrvIns     The driver instance.
 
181
 * @param   fFlags      PDM_TACH_FLAGS_NOT_HOT_PLUG or 0.
162
182
 */
163
 
typedef DECLCALLBACK(void)  FNPDMDRVDETACH(PPDMDRVINS pDrvIns);
 
183
typedef DECLCALLBACK(void)  FNPDMDRVDETACH(PPDMDRVINS pDrvIns, uint32_t fFlags);
164
184
/** Pointer to a FNPDMDRVDETACH() function. */
165
185
typedef FNPDMDRVDETACH *PFNPDMDRVDETACH;
166
186
 
204
224
    PFNPDMDRVSUSPEND    pfnSuspend;
205
225
    /** Resume notification - optional. */
206
226
    PFNPDMDRVRESUME     pfnResume;
 
227
    /** Attach command - optional. */
 
228
    PFNPDMDRVATTACH     pfnAttach;
207
229
    /** Detach notification - optional. */
208
230
    PFNPDMDRVDETACH     pfnDetach;
209
231
    /** Power off notification - optional. */
210
232
    PFNPDMDRVPOWEROFF   pfnPowerOff;
211
 
 
 
233
    /** @todo */
 
234
    PFNRT               pfnSoftReset;
 
235
    /** Initialization safty marker. */
 
236
    uint32_t            u32VersionEnd;
212
237
} PDMDRVREG;
213
238
/** Pointer to a PDM Driver Structure. */
214
239
typedef PDMDRVREG *PPDMDRVREG;
216
241
typedef PDMDRVREG const *PCPDMDRVREG;
217
242
 
218
243
/** Current DRVREG version number. */
219
 
#define PDM_DRVREG_VERSION  0x80010000
 
244
#define PDM_DRVREG_VERSION  0x80020000
220
245
 
221
 
/** PDM Device Flags.
 
246
/** PDM Driver Flags.
222
247
 * @{ */
223
248
/** @def PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT
224
249
 * The bit count for the current host. */
363
388
     *
364
389
     * @returns VBox status code.
365
390
     * @param   pDrvIns             Driver instance.
 
391
     * @param   fFlags              PDM_TACH_FLAGS_NOT_HOT_PLUG or 0.
366
392
     * @param   ppBaseInterface     Where to store the pointer to the base interface.
367
393
     */
368
 
    DECLR3CALLBACKMEMBER(int, pfnAttach,(PPDMDRVINS pDrvIns, PPDMIBASE *ppBaseInterface));
 
394
    DECLR3CALLBACKMEMBER(int, pfnAttach,(PPDMDRVINS pDrvIns, uint32_t fFlags, PPDMIBASE *ppBaseInterface));
369
395
 
370
396
    /**
371
397
     * Detach the driver the drivers below us.
372
398
     *
373
399
     * @returns VBox status code.
374
400
     * @param   pDrvIns             Driver instance.
 
401
     * @param   fFlags              PDM_TACH_FLAGS_NOT_HOT_PLUG or 0.
375
402
     */
376
 
    DECLR3CALLBACKMEMBER(int, pfnDetach,(PPDMDRVINS pDrvIns));
 
403
    DECLR3CALLBACKMEMBER(int, pfnDetach,(PPDMDRVINS pDrvIns, uint32_t fFlags));
377
404
 
378
405
    /**
379
406
     * Detach the driver from the driver above it and destroy this
381
408
     *
382
409
     * @returns VBox status code.
383
410
     * @param   pDrvIns             Driver instance.
 
411
     * @param   fFlags              PDM_TACH_FLAGS_NOT_HOT_PLUG or 0.
384
412
     */
385
 
    DECLR3CALLBACKMEMBER(int, pfnDetachSelf,(PPDMDRVINS pDrvIns));
 
413
    DECLR3CALLBACKMEMBER(int, pfnDetachSelf,(PPDMDRVINS pDrvIns, uint32_t fFlags));
386
414
 
387
415
    /**
388
416
     * Prepare a media mount.
472
500
    DECLR3CALLBACKMEMBER(int, pfnVMSetRuntimeErrorV,(PPDMDRVINS pDrvIns, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va));
473
501
 
474
502
    /**
 
503
     * Gets the VM state.
 
504
     *
 
505
     * @returns VM state.
 
506
     * @param   pDrvIns         The driver instance.
 
507
     * @thread  Any thread (just keep in mind that it's volatile info).
 
508
     */
 
509
    DECLR3CALLBACKMEMBER(VMSTATE, pfnVMState, (PPDMDRVINS pDrvIns));
 
510
 
 
511
    /**
 
512
     * Checks if the VM was teleported and hasn't been fully resumed yet.
 
513
     *
 
514
     * @returns true / false.
 
515
     * @param   pDrvIns         The driver instance.
 
516
     * @thread  Any thread.
 
517
     */
 
518
    DECLR3CALLBACKMEMBER(bool, pfnVMTeleportedAndNotFullyResumedYet,(PPDMDRVINS pDrvIns));
 
519
 
 
520
    /**
475
521
     * Create a queue.
476
522
     *
477
523
     * @returns VBox status code.
481
527
     * @param   cMilliesInterval    Number of milliseconds between polling the queue.
482
528
     *                              If 0 then the emulation thread will be notified whenever an item arrives.
483
529
     * @param   pfnCallback         The consumer function.
 
530
     * @param   pszName             The queue base name. The instance number will be
 
531
     *                              appended automatically.
484
532
     * @param   ppQueue             Where to store the queue handle on success.
485
533
     * @thread  The emulation thread.
486
534
     */
487
 
    DECLR3CALLBACKMEMBER(int, pfnPDMQueueCreate,(PPDMDRVINS pDrvIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval, PFNPDMQUEUEDRV pfnCallback, PPDMQUEUE *ppQueue));
488
 
 
489
 
    /**
490
 
     * Register a poller function.
491
 
     * TEMPORARY HACK FOR NETWORKING! DON'T USE!
492
 
     *
493
 
     * @returns VBox status code.
494
 
     * @param   pDrvIns             Driver instance.
495
 
     * @param   pfnPoller           The callback function.
496
 
     */
497
 
    DECLR3CALLBACKMEMBER(int, pfnPDMPollerRegister,(PPDMDRVINS pDrvIns, PFNPDMDRVPOLLER pfnPoller));
 
535
    DECLR3CALLBACKMEMBER(int, pfnPDMQueueCreate,(PPDMDRVINS pDrvIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
 
536
                                                 PFNPDMQUEUEDRV pfnCallback, const char *pszName, PPDMQUEUE *ppQueue));
498
537
 
499
538
    /**
500
539
     * Query the virtual timer frequency.
535
574
     *
536
575
     * @returns VBox status.
537
576
     * @param   pDrvIns         Driver instance.
538
 
     * @param   pszName         Data unit name.
539
 
     * @param   u32Instance     The instance identifier of the data unit.
540
 
     *                          This must together with the name be unique.
541
 
     * @param   u32Version      Data layout version number.
 
577
     * @param   uVersion        Data layout version number.
542
578
     * @param   cbGuess         The approximate amount of data in the unit.
543
579
     *                          Only for progress indicators.
 
580
     *
 
581
     * @param   pfnLivePrep     Prepare live save callback, optional.
 
582
     * @param   pfnLiveExec     Execute live save callback, optional.
 
583
     * @param   pfnLiveVote     Vote live save callback, optional.
 
584
     *
544
585
     * @param   pfnSavePrep     Prepare save callback, optional.
545
586
     * @param   pfnSaveExec     Execute save callback, optional.
546
587
     * @param   pfnSaveDone     Done save callback, optional.
 
588
     *
547
589
     * @param   pfnLoadPrep     Prepare load callback, optional.
548
590
     * @param   pfnLoadExec     Execute load callback, optional.
549
591
     * @param   pfnLoadDone     Done load callback, optional.
550
592
     */
551
 
    DECLR3CALLBACKMEMBER(int, pfnSSMRegister,(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
 
593
    DECLR3CALLBACKMEMBER(int, pfnSSMRegister,(PPDMDRVINS pDrvIns, uint32_t uVersion, size_t cbGuess,
 
594
                                              PFNSSMDRVLIVEPREP pfnLivePrep, PFNSSMDRVLIVEEXEC pfnLiveExec, PFNSSMDRVLIVEVOTE pfnLiveVote,
552
595
                                              PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
553
596
                                              PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone));
554
597
 
558
601
     * @returns VBox status.
559
602
     * @param   pDrvIns         Driver instance.
560
603
     * @param   pszName         Data unit name.
561
 
     * @param   u32Instance     The instance identifier of the data unit.
 
604
     * @param   uInstance       The instance identifier of the data unit.
562
605
     *                          This must together with the name be unique.
563
606
     */
564
 
    DECLR3CALLBACKMEMBER(int, pfnSSMDeregister,(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance));
 
607
    DECLR3CALLBACKMEMBER(int, pfnSSMDeregister,(PPDMDRVINS pDrvIns, const char *pszName, uint32_t uInstance));
565
608
 
566
609
    /**
567
610
     * Registers a statistics sample if statistics are enabled.
654
697
    DECLR3CALLBACKMEMBER(int, pfnUSBRegisterHub,(PPDMDRVINS pDrvIns, uint32_t fVersions, uint32_t cPorts, PCPDMUSBHUBREG pUsbHubReg, PPCPDMUSBHUBHLP ppUsbHubHlp));
655
698
 
656
699
    /**
 
700
     * Set up asynchronous handling of a suspend, reset or power off notification.
 
701
     *
 
702
     * This shall only be called when getting the notification.  It must be called
 
703
     * for each one.
 
704
     *
 
705
     * @returns VBox status code.
 
706
     * @param   pDrvIns             The driver instance.
 
707
     * @param   pfnAsyncNotify      The callback.
 
708
     * @thread  EMT(0)
 
709
     */
 
710
    DECLR3CALLBACKMEMBER(int, pfnSetAsyncNotification, (PPDMDRVINS pDrvIns, PFNPDMDRVASYNCNOTIFY pfnAsyncNotify));
 
711
 
 
712
    /**
 
713
     * Notify EMT(0) that the driver has completed the asynchronous notification
 
714
     * handling.
 
715
     *
 
716
     * This can be called at any time, spurious calls will simply be ignored.
 
717
     *
 
718
     * @param   pDrvIns             The driver instance.
 
719
     * @thread  Any
 
720
     */
 
721
    DECLR3CALLBACKMEMBER(void, pfnAsyncNotificationCompleted, (PPDMDRVINS pDrvIns));
 
722
 
 
723
    /**
657
724
     * Creates a PDM thread.
658
725
     *
659
726
     * This differs from the RTThreadCreate() API in that PDM takes care of suspending,
673
740
    DECLR3CALLBACKMEMBER(int, pfnPDMThreadCreate,(PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
674
741
                                                  PFNPDMTHREADWAKEUPDRV pfnWakeup, size_t cbStack, RTTHREADTYPE enmType, const char *pszName));
675
742
 
676
 
    /**
677
 
     * Gets the VM state.
678
 
     *
679
 
     * @returns VM state.
680
 
     * @param   pDrvIns         The driver instance.
681
 
     * @thread  Any thread (just keep in mind that it's volatile info).
682
 
     */
683
 
    DECLR3CALLBACKMEMBER(VMSTATE, pfnVMState, (PPDMDRVINS pDrvIns));
684
 
 
685
743
#ifdef VBOX_WITH_PDM_ASYNC_COMPLETION
686
744
    /**
687
745
     * Creates a async completion template for a driver instance.
709
767
typedef const PDMDRVHLP *PCPDMDRVHLP;
710
768
 
711
769
/** Current DRVHLP version number. */
712
 
#define PDM_DRVHLP_VERSION  0x90040000
 
770
#define PDM_DRVHLP_VERSION  0x90050000
713
771
 
714
772
 
715
773
 
822
880
#ifdef IN_RING3
823
881
 
824
882
/**
 
883
 * @copydoc PDMDRVHLP::pfnAttach
 
884
 */
 
885
DECLINLINE(int) PDMDrvHlpAttach(PPDMDRVINS pDrvIns, uint32_t fFlags, PPDMIBASE *ppBaseInterface)
 
886
{
 
887
    return pDrvIns->pDrvHlp->pfnAttach(pDrvIns, fFlags, ppBaseInterface);
 
888
}
 
889
 
 
890
/**
 
891
 * Check that there is no driver below the us that we should attach to.
 
892
 *
 
893
 * @returns VERR_PDM_NO_ATTACHED_DRIVER if there is no driver.
 
894
 * @param   pDrvIns     The driver instance.
 
895
 */
 
896
DECLINLINE(int) PDMDrvHlpNoAttach(PPDMDRVINS pDrvIns)
 
897
{
 
898
    return pDrvIns->pDrvHlp->pfnAttach(pDrvIns, 0, NULL);
 
899
}
 
900
 
 
901
/**
 
902
 * @copydoc PDMDRVHLP::pfnDetach
 
903
 */
 
904
DECLINLINE(int) PDMDrvHlpDetach(PPDMDRVINS pDrvIns, uint32_t fFlags)
 
905
{
 
906
    return pDrvIns->pDrvHlp->pfnDetach(pDrvIns, fFlags);
 
907
}
 
908
 
 
909
/**
 
910
 * @copydoc PDMDRVHLP::pfnDetachSelf
 
911
 */
 
912
DECLINLINE(int) PDMDrvHlpDetachSelf(PPDMDRVINS pDrvIns, uint32_t fFlags)
 
913
{
 
914
    return pDrvIns->pDrvHlp->pfnDetachSelf(pDrvIns, fFlags);
 
915
}
 
916
 
 
917
/**
 
918
 * @copydoc PDMDRVHLP::pfnVMState
 
919
 */
 
920
DECLINLINE(VMSTATE) PDMDrvHlpVMState(PPDMDRVINS pDrvIns)
 
921
{
 
922
    return pDrvIns->pDrvHlp->pfnVMState(pDrvIns);
 
923
}
 
924
 
 
925
/**
 
926
 * @copydoc PDMDRVHLP::pfnVMTeleportedAndNotFullyResumedYet
 
927
 */
 
928
DECLINLINE(bool) PDMDrvHlpVMTeleportedAndNotFullyResumedYet(PPDMDRVINS pDrvIns)
 
929
{
 
930
    return pDrvIns->pDrvHlp->pfnVMTeleportedAndNotFullyResumedYet(pDrvIns);
 
931
}
 
932
 
 
933
/**
825
934
 * @copydoc PDMDRVHLP::pfnPDMQueueCreate
826
935
 */
827
936
DECLINLINE(int) PDMDrvHlpPDMQueueCreate(PPDMDRVINS pDrvIns, RTUINT cbItem, RTUINT cItems, uint32_t cMilliesInterval,
828
 
                                        PFNPDMQUEUEDRV pfnCallback, PPDMQUEUE *ppQueue)
 
937
                                        PFNPDMQUEUEDRV pfnCallback, const char *pszName, PPDMQUEUE *ppQueue)
829
938
{
830
 
    return pDrvIns->pDrvHlp->pfnPDMQueueCreate(pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, ppQueue);
 
939
    return pDrvIns->pDrvHlp->pfnPDMQueueCreate(pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, ppQueue);
831
940
}
832
941
 
833
942
/**
855
964
}
856
965
 
857
966
/**
 
967
 * Register a save state data unit.
 
968
 *
 
969
 * @returns VBox status.
 
970
 * @param   pDrvIns         Driver instance.
 
971
 * @param   uVersion        Data layout version number.
 
972
 * @param   cbGuess         The approximate amount of data in the unit.
 
973
 *                          Only for progress indicators.
 
974
 * @param   pfnSaveExec     Execute save callback, optional.
 
975
 * @param   pfnLoadExec     Execute load callback, optional.
 
976
 */
 
977
DECLINLINE(int) PDMDrvHlpSSMRegister(PPDMDRVINS pDrvIns, uint32_t uVersion, size_t cbGuess,
 
978
                                     PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVLOADEXEC pfnLoadExec)
 
979
{
 
980
    return pDrvIns->pDrvHlp->pfnSSMRegister(pDrvIns, uVersion, cbGuess,
 
981
                                            NULL /*pfnLivePrep*/, NULL /*pfnLiveExec*/, NULL /*pfnLiveVote*/,
 
982
                                            NULL /*pfnSavePrep*/, pfnSaveExec,          NULL /*pfnSaveDone*/,
 
983
                                            NULL /*pfnLoadPrep*/, pfnLoadExec,          NULL /*pfnLoadDone*/);
 
984
}
 
985
 
 
986
/**
858
987
 * @copydoc PDMDRVHLP::pfnSSMRegister
859
988
 */
860
 
DECLINLINE(int) PDMDrvHlpSSMRegister(PPDMDRVINS pDrvIns, const char *pszName, uint32_t u32Instance, uint32_t u32Version, size_t cbGuess,
861
 
                                     PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
862
 
                                     PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone)
 
989
DECLINLINE(int) PDMDrvHlpSSMRegisterEx(PPDMDRVINS pDrvIns, uint32_t uVersion, size_t cbGuess,
 
990
                                       PFNSSMDRVLIVEPREP pfnLivePrep, PFNSSMDRVLIVEEXEC pfnLiveExec, PFNSSMDRVLIVEVOTE pfnLiveVote,
 
991
                                       PFNSSMDRVSAVEPREP pfnSavePrep, PFNSSMDRVSAVEEXEC pfnSaveExec, PFNSSMDRVSAVEDONE pfnSaveDone,
 
992
                                       PFNSSMDRVLOADPREP pfnLoadPrep, PFNSSMDRVLOADEXEC pfnLoadExec, PFNSSMDRVLOADDONE pfnLoadDone)
863
993
{
864
 
    return pDrvIns->pDrvHlp->pfnSSMRegister(pDrvIns, pszName, u32Instance, u32Version, cbGuess,
 
994
    return pDrvIns->pDrvHlp->pfnSSMRegister(pDrvIns, uVersion, cbGuess,
 
995
                                            pfnLivePrep, pfnLiveExec, pfnLiveVote,
865
996
                                            pfnSavePrep, pfnSaveExec, pfnSaveDone,
866
997
                                            pfnLoadPrep, pfnLoadExec, pfnLoadDone);
867
998
}
868
999
 
869
1000
/**
 
1001
 * Register a load done callback.
 
1002
 *
 
1003
 * @returns VBox status.
 
1004
 * @param   pDrvIns         Driver instance.
 
1005
 * @param   pfnLoadDone         Done load callback, optional.
 
1006
 */
 
1007
DECLINLINE(int) PDMDrvHlpSSMRegisterLoadDone(PPDMDRVINS pDrvIns, PFNSSMDRVLOADDONE pfnLoadDone)
 
1008
{
 
1009
    return pDrvIns->pDrvHlp->pfnSSMRegister(pDrvIns, 0 /*uVersion*/, 0 /*cbGuess*/,
 
1010
                                            NULL /*pfnLivePrep*/, NULL /*pfnLiveExec*/, NULL /*pfnLiveVote*/,
 
1011
                                            NULL /*pfnSavePrep*/, NULL /*pfnSaveExec*/, NULL /*pfnSaveDone*/,
 
1012
                                            NULL /*pfnLoadPrep*/, NULL /*pfnLoadExec*/, pfnLoadDone);
 
1013
}
 
1014
 
 
1015
/**
870
1016
 * @copydoc PDMDRVHLP::pfnSTAMRegister
871
1017
 */
872
1018
DECLINLINE(void) PDMDrvHlpSTAMRegister(PPDMDRVINS pDrvIns, void *pvSample, STAMTYPE enmType, const char *pszName, STAMUNIT enmUnit, const char *pszDesc)
903
1049
}
904
1050
 
905
1051
/**
 
1052
 * @copydoc PDMDRVHLP::pfnSetAsyncNotification
 
1053
 */
 
1054
DECLINLINE(int) PDMDrvHlpSetAsyncNotification(PPDMDRVINS pDrvIns, PFNPDMDRVASYNCNOTIFY pfnAsyncNotify)
 
1055
{
 
1056
    return pDrvIns->pDrvHlp->pfnSetAsyncNotification(pDrvIns, pfnAsyncNotify);
 
1057
}
 
1058
 
 
1059
/**
 
1060
 * @copydoc PDMDRVHLP::pfnAsyncNotificationCompleted
 
1061
 */
 
1062
DECLINLINE(void) PDMDrvHlpAsyncNotificationCompleted(PPDMDRVINS pDrvIns)
 
1063
{
 
1064
    pDrvIns->pDrvHlp->pfnAsyncNotificationCompleted(pDrvIns);
 
1065
}
 
1066
 
 
1067
/**
906
1068
 * @copydoc PDMDRVHLP::pfnPDMThreadCreate
907
1069
 */
908
1070
DECLINLINE(int) PDMDrvHlpPDMThreadCreate(PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
911
1073
    return pDrvIns->pDrvHlp->pfnPDMThreadCreate(pDrvIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
912
1074
}
913
1075
 
914
 
/**
915
 
 * @copydoc PDMDRVHLP::pfnVMState
916
 
 */
917
 
DECLINLINE(VMSTATE) PDMDrvHlpVMState(PPDMDRVINS pDrvIns)
918
 
{
919
 
    return pDrvIns->pDrvHlp->pfnVMState(pDrvIns);
920
 
}
921
 
 
922
1076
#ifdef VBOX_WITH_PDM_ASYNC_COMPLETION
923
1077
/**
924
1078
 * @copydoc PDMDRVHLP::pfnPDMAsyncCompletionTemplateCreate