← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox/trusty-proposed

« back to all changes in this revision

Viewing changes to include/VBox/vmm/vm.h

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-03-07 16:38:36 UTC
  • mfrom: (1.1.13) (3.1.20 experimental)
  • Revision ID: package-import@ubuntu.com-20130307163836-p93jpbgx39tp3gb4
Tags: 4.2.8-dfsg-0ubuntu1
http://bugs.debian.org/691148
http://bugs.debian.org/700823
https://launchpad.net/bugs/1101867
http://bugs.debian.org/700479
http://bugs.debian.org/686994
http://bugs.debian.org/680053
* New upstream release. (Closes: #691148)
  - Fixes compatibility with kernel 3.8. (Closes: #700823; LP: #1101867)
* Switch to my @debian.org email address.
* Move package to contrib as virtualbox 4.2 needs a non-free compiler to
  build the BIOS.
* Build-depend on libdevmapper-dev.
* Refresh patches.
  - Drop 36-fix-ftbfs-xserver-112.patch, cve-2012-3221.patch,
    CVE-2013-0420.patch 37-kcompat-3.6.patch and 38-kcompat-3.7.patch.
* Drop all virtualbox-ose transitional packages.
* Drop the virtualbox-fuse package as vdfuse fails to build with
  virtualbox 4.2.
* Update install files and VBox.sh.
* Bump required kbuild version to 0.1.9998svn2577.
* Fix path to VBoxCreateUSBNode.sh in virtualbox.postinst. (Closes: #700479)
* Add an init script to virtuabox-guest-x11 which loads the vboxvideo
  kernel module. The X Server 1.13 doesn't load it anymore. (Closes: #686994)
* Update man pages. (Closes: #680053)
* Add 36-python-multiarch.patch from Rico Tzschichholz to fix detection of
  python in multiarch paths using pkg-config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/VBox/vmm/vm.h
3
3
 */
4
4
 
5
5
/*
6
 
 * Copyright (C) 2006-2011 Oracle Corporation
 
6
 * Copyright (C) 2006-2012 Oracle Corporation
7
7
 *
8
8
 * This file is part of VirtualBox Open Source Edition (OSE), as
9
9
 * available from http://www.virtualbox.org. This file is free software;
26
26
#ifndef ___VBox_vmm_vm_h
27
27
#define ___VBox_vmm_vm_h
28
28
 
29
 
#include <VBox/types.h>
30
 
#include <VBox/vmm/cpum.h>
31
 
#include <VBox/vmm/stam.h>
32
 
#include <VBox/vmm/vmapi.h>
33
 
#include <VBox/vmm/vmm.h>
34
 
#include <VBox/sup.h>
 
29
#ifndef VBOX_FOR_DTRACE_LIB
 
30
# include <VBox/types.h>
 
31
# include <VBox/vmm/cpum.h>
 
32
# include <VBox/vmm/stam.h>
 
33
# include <VBox/vmm/vmapi.h>
 
34
# include <VBox/vmm/vmm.h>
 
35
# include <VBox/sup.h>
 
36
#else
 
37
# pragma D depends_on library vbox-types.d
 
38
# pragma D depends_on library CPUMInternal.d
 
39
# define ___CPUMInternal_h
 
40
#endif
 
41
 
35
42
 
36
43
 
37
44
/** @defgroup grp_vm    The Virtual Machine
45
52
 * addition, there are sub-states when started for assisting scheduling (GVMM
46
53
 * mostly).
47
54
 *
48
 
 * The transision out of the STOPPED state is done by a vmR3PowerOn.
49
 
 * The transision back to the STOPPED state is done by vmR3PowerOff.
 
55
 * The transition out of the STOPPED state is done by a vmR3PowerOn.
 
56
 * The transition back to the STOPPED state is done by vmR3PowerOff.
50
57
 *
51
58
 * (Alternatively we could let vmR3PowerOn start CPU 0 only and let the SPIP
52
59
 * handling switch on the other CPUs. Then vmR3Reset would stop all but CPU 0.)
83
90
{
84
91
    /** Per CPU forced action.
85
92
     * See the VMCPU_FF_* \#defines. Updated atomically. */
86
 
    uint32_t volatile       fLocalForcedActions;
 
93
    uint32_t volatile       fLocalForcedActions;                    /* 0 */
87
94
    /** The CPU state. */
88
 
    VMCPUSTATE volatile     enmState;
 
95
    VMCPUSTATE volatile     enmState;                               /* 4 */
89
96
 
90
97
    /** Pointer to the ring-3 UVMCPU structure. */
91
 
    PUVMCPU                 pUVCpu;
 
98
    PUVMCPU                 pUVCpu;                                 /* 8 */
92
99
    /** Ring-3 Host Context VM Pointer. */
93
 
    PVMR3                   pVMR3;
 
100
    PVMR3                   pVMR3;                                  /* 16 / 12 */
94
101
    /** Ring-0 Host Context VM Pointer. */
95
 
    PVMR0                   pVMR0;
96
 
    /** Alignment padding. */
97
 
    RTR0PTR                 pvR0Padding;
 
102
    PVMR0                   pVMR0;                                  /* 24 / 16 */
98
103
    /** Raw-mode Context VM Pointer. */
99
 
    PVMRC                   pVMRC;
 
104
    PVMRC                   pVMRC;                                  /* 32 / 20 */
100
105
    /** The CPU ID.
101
106
     * This is the index into the VM::aCpu array. */
102
 
    VMCPUID                 idCpu;
 
107
    VMCPUID                 idCpu;                                  /* 36 / 24 */
103
108
    /** The native thread handle. */
104
 
    RTNATIVETHREAD          hNativeThread;
 
109
    RTNATIVETHREAD          hNativeThread;                          /* 40 / 28 */
105
110
    /** The native R0 thread handle. (different from the R3 handle!) */
106
 
    RTNATIVETHREAD          hNativeThreadR0;
 
111
    RTNATIVETHREAD          hNativeThreadR0;                        /* 48 / 32 */
107
112
    /** Which host CPU ID is this EMT running on.
108
113
     * Only valid when in RC or HWACCMR0 with scheduling disabled. */
109
 
    RTCPUID volatile        idHostCpu;
110
 
    /** State data for use by ad hoc profiling. */
111
 
    uint32_t                uAdHoc;
112
 
    /** Profiling samples for use by ad hoc profiling. */
113
 
    STAMPROFILEADV          aStatAdHoc[8];
 
114
    RTCPUID volatile        idHostCpu;                              /* 56 / 36 */
114
115
 
115
 
    /** Align the next bit on a 64-byte boundary and make sure it starts at the same
116
 
     *  offset in both 64-bit and 32-bit builds.
 
116
    /** Trace groups enable flags.  */
 
117
    uint32_t                fTraceGroups;                           /* 60 / 40 */
 
118
    /** Align the structures below bit on a 64-byte boundary and make sure it starts
 
119
     * at the same offset in both 64-bit and 32-bit builds.
117
120
     *
118
121
     * @remarks The alignments of the members that are larger than 48 bytes should be
119
122
     *          64-byte for cache line reasons. structs containing small amounts of
120
123
     *          data could be lumped together at the end with a < 64 byte padding
121
124
     *          following it (to grow into and align the struct size).
122
125
     *   */
123
 
    uint8_t                 abAlignment1[HC_ARCH_BITS == 32 ? 16+64 : 56];
 
126
    uint8_t                 abAlignment1[HC_ARCH_BITS == 64 ? 60 : 16+64];
 
127
    /** State data for use by ad hoc profiling. */
 
128
    uint32_t                uAdHoc;
 
129
    /** Profiling samples for use by ad hoc profiling. */
 
130
    STAMPROFILEADV          aStatAdHoc[8];                          /* size: 40*8 = 320 */
124
131
 
125
132
    /** CPUM part. */
126
133
    union
128
135
#ifdef ___CPUMInternal_h
129
136
        struct CPUMCPU      s;
130
137
#endif
131
 
        uint8_t             padding[3456];      /* multiple of 64 */
 
138
        uint8_t             padding[3584];      /* multiple of 64 */
132
139
    } cpum;
133
140
 
134
141
    /** HWACCM part. */
137
144
#ifdef ___HWACCMInternal_h
138
145
        struct HWACCMCPU    s;
139
146
#endif
140
 
        uint8_t             padding[5312];      /* multiple of 64 */
 
147
        uint8_t             padding[5376];      /* multiple of 64 */
141
148
    } hwaccm;
142
149
 
143
150
    /** EM part. */
155
162
#ifdef ___IEMInternal_h
156
163
        struct IEMCPU       s;
157
164
#endif
158
 
        uint8_t             padding[1024];      /* multiple of 64 */
 
165
        uint8_t             padding[3072];      /* multiple of 64 */
159
166
    } iem;
160
167
 
161
168
    /** TRPM part. */
182
189
#ifdef ___VMMInternal_h
183
190
        struct VMMCPU       s;
184
191
#endif
185
 
        uint8_t             padding[384];       /* multiple of 64 */
 
192
        uint8_t             padding[640];       /* multiple of 64 */
186
193
    } vmm;
187
194
 
188
195
    /** PDM part. */
214
221
    } dbgf;
215
222
 
216
223
    /** Align the following members on page boundary. */
217
 
    uint8_t                 abAlignment2[3072];
 
224
    uint8_t                 abAlignment2[1024 - 320 - 128];
218
225
 
219
226
    /** PGM part. */
220
227
    union
228
235
} VMCPU;
229
236
 
230
237
 
 
238
#ifndef VBOX_FOR_DTRACE_LIB
 
239
 
231
240
/** @name Operations on VMCPU::enmState
232
241
 * @{ */
233
242
/** Gets the VMCPU state. */
239
248
#define VMCPU_CMPXCHG_STATE(pVCpu, enmNewState, enmOldState) \
240
249
    ASMAtomicCmpXchgU32((uint32_t volatile *)&(pVCpu)->enmState, (enmNewState), (enmOldState))
241
250
/** Checks the VMCPU state. */
242
 
#define VMCPU_ASSERT_STATE(pVCpu, enmExpectedState) \
 
251
#ifdef VBOX_STRICT
 
252
# define VMCPU_ASSERT_STATE(pVCpu, enmExpectedState) \
243
253
    do { \
244
254
        VMCPUSTATE enmState = VMCPU_GET_STATE(pVCpu); \
245
255
        AssertMsg(enmState == (enmExpectedState), \
246
256
                  ("enmState=%d  enmExpectedState=%d idCpu=%u\n", \
247
257
                  enmState, enmExpectedState, (pVCpu)->idCpu)); \
248
258
    } while (0)
 
259
#else
 
260
# define VMCPU_ASSERT_STATE(pVCpu, enmExpectedState) do { } while (0)
 
261
#endif
249
262
/** Tests if the state means that the CPU is started. */
250
263
#define VMCPUSTATE_IS_STARTED(enmState)     ( (enmState) > VMCPUSTATE_STOPPED )
251
264
/** Tests if the state means that the CPU is stopped. */
482
495
 * @param   pVM     VM Handle.
483
496
 * @param   fFlag   The flag to check.
484
497
 */
485
 
#define VM_FF_ISSET(pVM, fFlag)             (((pVM)->fGlobalForcedActions & (fFlag)) == (fFlag))
 
498
#define VM_FF_IS_SET(pVM, fFlag)            (((pVM)->fGlobalForcedActions & (fFlag)) == (fFlag))
 
499
/** @deprecated  */
 
500
#define VM_FF_ISSET(pVM, fFlag)             VM_FF_IS_SET(pVM, fFlag)
486
501
 
487
502
/** @def VMCPU_FF_ISSET
488
503
 * Checks if a force action flag is set for the given VCPU.
490
505
 * @param   pVCpu   VMCPU Handle.
491
506
 * @param   fFlag   The flag to check.
492
507
 */
493
 
#define VMCPU_FF_ISSET(pVCpu, fFlag)        (((pVCpu)->fLocalForcedActions & (fFlag)) == (fFlag))
 
508
#define VMCPU_FF_IS_SET(pVCpu, fFlag)       (((pVCpu)->fLocalForcedActions & (fFlag)) == (fFlag))
 
509
/** @deprecated  */
 
510
#define VMCPU_FF_ISSET(pVCpu, fFlag)        VMCPU_FF_IS_SET(pVCpu, fFlag)
494
511
 
495
512
/** @def VM_FF_ISPENDING
496
513
 * Checks if one or more force action in the specified set is pending.
498
515
 * @param   pVM     VM Handle.
499
516
 * @param   fFlags  The flags to check for.
500
517
 */
501
 
#define VM_FF_ISPENDING(pVM, fFlags)        ((pVM)->fGlobalForcedActions & (fFlags))
 
518
#define VM_FF_IS_PENDING(pVM, fFlags)       ((pVM)->fGlobalForcedActions & (fFlags))
 
519
/** @deprecated  */
 
520
#define VM_FF_ISPENDING(pVM, fFlags)        VM_FF_IS_PENDING(pVM, fFlags)
502
521
 
503
522
/** @def VM_FF_TESTANDCLEAR
504
523
 * Checks if one (!) force action in the specified set is pending and clears it atomically
508
527
 * @param   pVM     VM Handle.
509
528
 * @param   iBit    Bit position to check and clear
510
529
 */
511
 
#define VM_FF_TESTANDCLEAR(pVM, iBit)        (ASMAtomicBitTestAndClear(&(pVM)->fGlobalForcedActions, iBit##_BIT))
 
530
#define VM_FF_TEST_AND_CLEAR(pVM, iBit)     (ASMAtomicBitTestAndClear(&(pVM)->fGlobalForcedActions, iBit##_BIT))
 
531
/** @deprecated  */
 
532
#define VM_FF_TESTANDCLEAR(pVM, iBit)       (ASMAtomicBitTestAndClear(&(pVM)->fGlobalForcedActions, iBit##_BIT))
512
533
 
513
534
/** @def VMCPU_FF_TESTANDCLEAR
514
535
 * Checks if one (!) force action in the specified set is pending and clears it atomically
518
539
 * @param   pVCpu   VMCPU Handle.
519
540
 * @param   iBit    Bit position to check and clear
520
541
 */
521
 
#define VMCPU_FF_TESTANDCLEAR(pVCpu, iBit)    (ASMAtomicBitTestAndClear(&(pVCpu)->fLocalForcedActions, iBit##_BIT))
 
542
#define VMCPU_FF_TEST_AND_CLEAR(pVCpu, iBit) (ASMAtomicBitTestAndClear(&(pVCpu)->fLocalForcedActions, iBit##_BIT))
 
543
/** @deprecated  */
 
544
#define VMCPU_FF_TESTANDCLEAR(pVCpu, iBit)  (ASMAtomicBitTestAndClear(&(pVCpu)->fLocalForcedActions, iBit##_BIT))
522
545
 
523
546
/** @def VMCPU_FF_ISPENDING
524
547
 * Checks if one or more force action in the specified set is pending for the given VCPU.
526
549
 * @param   pVCpu   VMCPU Handle.
527
550
 * @param   fFlags  The flags to check for.
528
551
 */
529
 
#define VMCPU_FF_ISPENDING(pVCpu, fFlags) ((pVCpu)->fLocalForcedActions & (fFlags))
 
552
#define VMCPU_FF_IS_PENDING(pVCpu, fFlags)  ((pVCpu)->fLocalForcedActions & (fFlags))
 
553
/** @deprecated  */
 
554
#define VMCPU_FF_ISPENDING(pVCpu, fFlags)   VMCPU_FF_IS_PENDING(pVCpu, fFlags)
530
555
 
531
556
/** @def VM_FF_ISPENDING
532
557
 * Checks if one or more force action in the specified set is pending while one
724
749
                         ? VMGetStateName((pVCpu)->pVMR3->enmVMState) : ""), \
725
750
                        (rc))
726
751
 
 
752
#endif /* !VBOX_FOR_DTRACE_LIB */
 
753
 
 
754
 
727
755
 
728
756
/** This is the VM structure.
729
757
 *
772
800
    /** Offset to the VMCPU array starting from beginning of this structure. */
773
801
    uint32_t                    offVMCPU;
774
802
 
775
 
    /** Reserved; alignment. */
776
 
    uint32_t                    u32Reserved[5];
777
 
 
778
 
    /** @name Public VMM Switcher APIs
779
 
     * @{ */
780
 
    /**
781
 
     * Assembly switch entry point for returning to host context.
782
 
     * This function will clean up the stack frame.
783
 
     *
784
 
     * @param   eax         The return code, register.
785
 
     * @param   Ctx         The guest core context.
786
 
     * @remark  Assume interrupts disabled.
787
 
     */
788
 
    RTRCPTR                     pfnVMMGCGuestToHostAsmGuestCtx/*(int32_t eax, CPUMCTXCORE Ctx)*/;
789
 
 
790
 
    /**
791
 
     * Assembly switch entry point for returning to host context.
792
 
     *
793
 
     * This is an alternative entry point which we'll be using when the we have the
794
 
     * hypervisor context and need to save  that before going to the host.
795
 
     *
796
 
     * This is typically useful when abandoning the hypervisor because of a trap
797
 
     * and want the trap state to be saved.
798
 
     *
799
 
     * @param   eax         The return code, register.
800
 
     * @param   ecx         Pointer to the  hypervisor core context, register.
801
 
     * @remark  Assume interrupts disabled.
802
 
     */
803
 
    RTRCPTR                     pfnVMMGCGuestToHostAsmHyperCtx/*(int32_t eax, PCPUMCTXCORE ecx)*/;
804
 
 
805
 
    /**
806
 
     * Assembly switch entry point for returning to host context.
807
 
     *
808
 
     * This is an alternative to the two *Ctx APIs and implies that the context has already
809
 
     * been saved, or that it's just a brief return to HC and that the caller intends to resume
810
 
     * whatever it is doing upon 'return' from this call.
811
 
     *
812
 
     * @param   eax         The return code, register.
813
 
     * @remark  Assume interrupts disabled.
814
 
     */
815
 
    RTRCPTR                     pfnVMMGCGuestToHostAsm/*(int32_t eax)*/;
816
 
    /** @} */
817
 
 
818
 
 
819
 
    /** @name Various VM data owned by VM.
820
 
     * @{ */
821
 
    RTTHREAD                    uPadding1;
822
 
    /** The native handle of ThreadEMT. Getting the native handle
823
 
     * is generally faster than getting the IPRT one (except on OS/2 :-). */
824
 
    RTNATIVETHREAD              uPadding2;
825
 
    /** @} */
826
 
 
 
803
    /**
 
804
     * VMMSwitcher assembly entry point returning to host context.
 
805
     *
 
806
     * Depending on how the host handles the rc status given in @a eax, this may
 
807
     * return and let the caller resume whatever it was doing prior to the call.
 
808
     *
 
809
     *
 
810
     * @param   eax         The return code, register.
 
811
     * @remark  Assume interrupts disabled.
 
812
     * @remark  This method pointer lives here because TRPM needs it.
 
813
     */
 
814
    RTRCPTR                     pfnVMMRCToHostAsm/*(int32_t eax)*/;
 
815
 
 
816
    /**
 
817
     * VMMSwitcher assembly entry point returning to host context without saving the
 
818
     * raw-mode context (hyper) registers.
 
819
     *
 
820
     * Unlike pfnVMMRC2HCAsm, this will not return to the caller.  Instead it
 
821
     * expects the caller to save a RC context in CPUM where one might return if the
 
822
     * return code indicate that this is possible.
 
823
     *
 
824
     * This method pointer lives here because TRPM needs it.
 
825
     *
 
826
     * @param   eax         The return code, register.
 
827
     * @remark  Assume interrupts disabled.
 
828
     * @remark  This method pointer lives here because TRPM needs it.
 
829
     */
 
830
    RTRCPTR                     pfnVMMRCToHostAsmNoReturn/*(int32_t eax)*/;
827
831
 
828
832
    /** @name Various items that are frequently accessed.
829
833
     * @{ */
849
853
    bool                        fUseLargePages;
850
854
    /** @} */
851
855
 
 
856
    /** Alignment padding.. */
 
857
    uint32_t                    uPadding1;
 
858
 
852
859
    /** @name Debugging
853
860
     * @{ */
854
861
    /** Raw-mode Context VM Pointer. */
855
862
    RCPTRTYPE(RTTRACEBUF)       hTraceBufRC;
856
 
    /** Alignment padding */
857
 
    uint32_t                    uPadding3;
858
863
    /** Ring-3 Host Context VM Pointer. */
859
864
    R3PTRTYPE(RTTRACEBUF)       hTraceBufR3;
860
865
    /** Ring-0 Host Context VM Pointer. */
863
868
 
864
869
#if HC_ARCH_BITS == 32
865
870
    /** Alignment padding.. */
866
 
    uint32_t                    uPadding4;
 
871
    uint32_t                    uPadding2;
867
872
#endif
868
873
 
869
874
    /** @name Switcher statistics (remove)
893
898
    STAMPROFILEADV              StatSwitcherTSS;
894
899
    /** @} */
895
900
 
896
 
#if HC_ARCH_BITS != 64
897
901
    /** Padding - the unions must be aligned on a 64 bytes boundary and the unions
898
902
     *  must start at the same offset on both 64-bit and 32-bit hosts. */
899
 
    uint8_t                     abAlignment1[HC_ARCH_BITS == 32 ? 32 : 0];
900
 
#endif
 
903
    uint8_t                     abAlignment3[(HC_ARCH_BITS == 32 ? 24 : 0) + 40];
901
904
 
902
905
    /** CPUM part. */
903
906
    union
905
908
#ifdef ___CPUMInternal_h
906
909
        struct CPUM s;
907
910
#endif
908
 
        uint8_t     padding[1472];      /* multiple of 64 */
 
911
        uint8_t     padding[1536];      /* multiple of 64 */
909
912
    } cpum;
910
913
 
911
914
    /** VMM part. */
941
944
#ifdef ___TRPMInternal_h
942
945
        struct TRPM s;
943
946
#endif
944
 
        uint8_t     padding[5184];      /* multiple of 64 */
 
947
        uint8_t     padding[5248];      /* multiple of 64 */
945
948
    } trpm;
946
949
 
947
950
    /** SELM part. */
950
953
#ifdef ___SELMInternal_h
951
954
        struct SELM s;
952
955
#endif
953
 
        uint8_t     padding[576];       /* multiple of 64 */
 
956
        uint8_t     padding[768];       /* multiple of 64 */
954
957
    } selm;
955
958
 
956
959
    /** MM part. */
1074
1077
 
1075
1078
 
1076
1079
    /** Padding for aligning the cpu array on a page boundary. */
1077
 
    uint8_t         abAlignment2[862];
 
1080
    uint8_t         abAlignment2[542];
1078
1081
 
1079
1082
    /* ---- end small stuff ---- */
1080
1083