Changeset 40418 in vbox for trunk/src/VBox

Timestamp:

Mar 9, 2012 10:00:56 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

76749

Message:

Main: Extended IMachine and the settings XML with three tracing related properties.

Location:

trunk/src/VBox

Files:

• Frontends/VBoxManage/VBoxManageHelp.cpp (modified) (1 diff)
• Frontends/VBoxManage/VBoxManageInfo.cpp (modified) (3 diffs)
• Frontends/VBoxManage/VBoxManageModifyVM.cpp (modified) (3 diffs)
• Main/glue/string.cpp (modified) (2 diffs)
• Main/idl/VirtualBox.xidl (modified) (5 diffs)
• Main/include/MachineImpl.h (modified) (6 diffs)
• Main/include/VirtualBoxBase.h (modified) (3 diffs)
• Main/src-client/ConsoleImpl2.cpp (modified) (6 diffs)
• Main/src-server/MachineImpl.cpp (modified) (10 diffs)
• Main/src-server/SnapshotImpl.cpp (modified) (3 diffs)
• Main/xml/Settings.cpp (modified) (9 diffs)

trunk/src/VBox/Frontends/VBoxManage/VBoxManageHelp.cpp

@@ -321 +321 @@
                      "                            [--teleporteraddress <address|empty>\n"
                      "                            [--teleporterpassword <password>]\n"
+                     "                            [--tracing-enabled on|off]\n"
+                     "                            [--tracing-config <config-string>]\n"
+                     "                            [--tracing-allow-vm-access on|off]\n"
 #if 0
                      "                            [--iocache on|off]\n"

trunk/src/VBox/Frontends/VBoxManage/VBoxManageInfo.cpp

@@ -196 +196 @@
 }
 
+/**
+ * This takes care of escaping double quotes and slashes that the string might
+ * contain.
+ *
+ * @param   pszName             The variable name.
+ * @param   pbstrValue          The value.
+ */
+static void outputMachineReadableString(const char *pszName, Bstr const *pbstrValue)
+{
+    Assert(strpbrk(pszName, "\"\\") == NULL);
+
+    com::Utf8Str strValue(*pbstrValue);
+    if (    strValue.isEmpty()
+        || (   !strValue.count('"')
+            && !strValue.count('\\')))
+        RTPrintf("%s=\"%s\"\n", pszName, strValue.c_str());
+    else
+    {
+        /* The value needs escaping. */
+        RTPrintf("%s=\"", pszName);
+        const char *psz = strValue.c_str();
+        for (;;)
+        {
+            const char *pszNext = strpbrk(psz, "\"\\");
+            if (!pszNext)
+            {
+                RTPrintf("%s", psz);
+                break;
+            }
+            RTPrintf(".*s\\%c", psz - pszNext, *pszNext);
+            psz = pszNext + 1;
+        }
+        RTPrintf("\"\n");
+    }
+}
+
+
 /* Disable global optimizations for MSC 8.0/64 to make it compile in reasonable
    time. MSC 7.1/32 doesn't have quite as much trouble with it, but still
@@ -211 +248 @@
     HRESULT rc;
 
+#define SHOW_BOOLEAN_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman) \
+    do \
+    { \
+        BOOL f; \
+        CHECK_ERROR2_RET(machine, COMGETTER(a_Prop)(&f), hrcCheck); \
+        if (details == VMINFO_MACHINEREADABLE) \
+            RTPrintf( a_szMachine "=\"%s\"\n", f ? "on" : "off"); \
+        else \
+            RTPrintf("%-16s %s\n", a_szHuman ":", f ? "on" : "off"); \
+    } while (0)
+
+#define SHOW_STRING_PROP(a_pObj, a_Prop, a_szMachine, a_szHuman) \
+    do \
+    { \
+        Bstr bstr; \
+        CHECK_ERROR2_RET(machine, COMGETTER(a_Prop)(bstr.asOutParam()), hrcCheck); \
+        if (details == VMINFO_MACHINEREADABLE) \
+            outputMachineReadableString(a_szMachine, &bstr); \
+        else \
+            RTPrintf("%-16s %ls\n", a_szHuman ":", bstr.raw()); \
+    } while (0)
+
+
     /*
      * The rules for output in -argdump format:
-     * 1) the key part (the [0-9a-zA-Z_]+ string before the '=' delimiter)
+     * 1) the key part (the [0-9a-zA-Z_\-]+ string before the '=' delimiter)
      *    is all lowercase for "VBoxManage modifyvm" parameters. Any
      *    other values printed are in CamelCase.
@@ -681 +741 @@
     else
         RTPrintf("Teleporter Password: %ls\n", teleporterPassword.raw());
+
+    SHOW_BOOLEAN_PROP(machine, TracingEnabled, "tracing-enabled", "Tracing Enabled");
+    SHOW_BOOLEAN_PROP(machine, AllowTracingToAccessVM, "tracing-allow-vm-access", "Allow Tracing to Access VM");
+    SHOW_STRING_PROP(machine, TracingConfig, "tracing-config", "Tracing Configuration");
 
     /*

trunk/src/VBox/Frontends/VBoxManage/VBoxManageModifyVM.cpp

@@ -164 +164 @@
     MODIFYVM_TELEPORTER_ADDRESS,
     MODIFYVM_TELEPORTER_PASSWORD,
+    MODIFYVM_TRACING_ENABLED,
+    MODIFYVM_TRACING_CONFIG,
+    MODIFYVM_TRACING_ALLOW_VM_ACCESS,
     MODIFYVM_HARDWARE_UUID,
     MODIFYVM_HPET,
@@ -299 +302 @@
     { "--teleporteraddress",        MODIFYVM_TELEPORTER_ADDRESS,        RTGETOPT_REQ_STRING },
     { "--teleporterpassword",       MODIFYVM_TELEPORTER_PASSWORD,       RTGETOPT_REQ_STRING },
+    { "--tracing-enabled",          MODIFYVM_TRACING_ENABLED,           RTGETOPT_REQ_BOOL_ONOFF },
+    { "--tracing-config",           MODIFYVM_TRACING_CONFIG,            RTGETOPT_REQ_STRING },
+    { "--tracing-allow-vm-access",  MODIFYVM_TRACING_ALLOW_VM_ACCESS,   RTGETOPT_REQ_BOOL_ONOFF },
     { "--hardwareuuid",             MODIFYVM_HARDWARE_UUID,             RTGETOPT_REQ_STRING },
     { "--hpet",                     MODIFYVM_HPET,                      RTGETOPT_REQ_BOOL_ONOFF },
@@ -2204 +2210 @@
             }
 
+            case MODIFYVM_TRACING_ENABLED:
+            {
+                CHECK_ERROR(machine, COMSETTER(TracingEnabled)(ValueUnion.f));
+                break;
+            }
+
+            case MODIFYVM_TRACING_CONFIG:
+            {
+                CHECK_ERROR(machine, COMSETTER(TracingConfig)(Bstr(ValueUnion.psz).raw()));
+                break;
+            }
+
+            case MODIFYVM_TRACING_ALLOW_VM_ACCESS:
+            {
+                CHECK_ERROR(machine, COMSETTER(AllowTracingToAccessVM)(ValueUnion.f));
+                break;
+            }
+
             case MODIFYVM_FAULT_TOLERANCE:
             {

trunk/src/VBox/Main/glue/string.cpp

@@ -85 +85 @@
         throw std::bad_alloc();
     memcpy(*pstr, c_str(), cb);
+}
+
+HRESULT Utf8Str::cloneToEx(char **pstr) const
+{
+    size_t cb = length() + 1;
+    *pstr = (char*)nsMemory::Alloc(cb);
+    if (RT_UNLIKELY(!*pstr))
+        return E_OUTOFMEMORY;
+    memcpy(*pstr, c_str(), cb);
+    return S_OK;
 }
 #endif
@@ -188 +198 @@
 }
 
+/**
+ * A variant of Utf8Str::copyFrom that does not throw any exceptions but returns
+ * E_OUTOFMEMORY instead.
+ *
+ * @param   a_pbstr         The source string.
+ * @returns S_OK or E_OUTOFMEMORY.
+ */
+HRESULT Utf8Str::copyFromEx(CBSTR a_pbstr)
+{
+    if (a_pbstr && *a_pbstr)
+    {
+        int vrc = RTUtf16ToUtf8Ex((PCRTUTF16)a_pbstr,
+                                  RTSTR_MAX,        // size_t cwcString: translate entire string
+                                  &m_psz,           // char **ppsz: output buffer
+                                  0,                // size_t cch: if 0, func allocates buffer in *ppsz
+                                  &m_cch);          // size_t *pcch: receives the size of the output string, excluding the terminator.
+        if (RT_SUCCESS(vrc))
+            m_cbAllocated = m_cch + 1;
+        else
+        {
+            if (   vrc != VERR_NO_STR_MEMORY
+                && vrc != VERR_NO_MEMORY)
+            {
+                /* ASSUME: input is valid Utf-16. Fake out of memory error. */
+                AssertLogRelMsgFailed(("%Rrc %.*Rhxs\n", vrc, RTUtf16Len(a_pbstr) * sizeof(RTUTF16), a_pbstr));
+            }
+
+            m_cch = 0;
+            m_cbAllocated = 0;
+            m_psz = NULL;
+
+            return E_OUTOFMEMORY;
+        }
+    }
+    else
+    {
+        m_cch = 0;
+        m_cbAllocated = 0;
+        m_psz = NULL;
+    }
+    return S_OK;
+}
+
 } /* namespace com */

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -488 +488 @@
       -->
     </const>
+    <const name="v1_13"     value="15">
+      <desc>Settings version "1.13", written by VirtualBox 4.2.x.</desc>
+      <!--
+          Machine changes: tracing config;
+      -->
+    </const>
 
     <const name="Future"     value="99999">
-      <desc>Settings version greater than "1.12", written by a future VirtualBox version.</desc>
+      <desc>Settings version greater than "1.13", written by a future VirtualBox version.</desc>
     </const>
   </enum>
@@ -3533 +3539 @@
       </desc>
     </attribute>
-
   </interface>
 
@@ -3683 +3688 @@
   <interface
     name="IMachine" extends="$unknown"
-    uuid="116704af-f221-4d9e-8697-c11331622907"
+    uuid="b0ce140d-02b6-469a-80f5-412ef8e1318e"
     wsmap="managed"
     >
@@ -4282 +4287 @@
     </attribute>
 
-    <attribute name="bandwidthControl" type="IBandwidthControl" readonly="yes">
-      <desc>
-        Bandwidth control manager.
-      </desc>
-    </attribute>
-
     <attribute name="pciDeviceAssignments" type="IPciDeviceAttachment" readonly="yes" safearray="yes">
       <desc>Array of PCI devices assigned to this machine, to get list of all
@@ -4295 +4294 @@
         virtual hardware config. Usually, this list keeps host's physical
         devices assigned to the particular machine.
+      </desc>
+    </attribute>
+
+    <attribute name="bandwidthControl" type="IBandwidthControl" readonly="yes">
+      <desc>
+        Bandwidth control manager.
+      </desc>
+    </attribute>
+
+    <attribute name="tracingEnabled" type="boolean">
+      <desc>
+        Enables the tracing facility in the VMM (including PDM devices +
+        drivers).  The VMM will consume about 0.5MB of more memory when
+        enabled and there may be some extra overhead from tracepoints that are
+        always enabled.
+      </desc>
+    </attribute>
+
+    <attribute name="tracingConfig" type="wstring">
+      <desc>
+        Tracepoint configuration to apply at startup when
+        <link to="IMachine::tracingEnabled" /> is true.  The string specifies
+        a space separated of tracepoint group names to enable.  The special
+        group 'all' enables all tracepoints.  Check DBGFR3TracingConfig for
+        more details on available tracepoint groups and such.
+
+        Note that on hosts supporting DTrace (or similar), a lot of the
+        tracepoints may be implemented exclusivly as DTrace probes.  So, the
+        effect of the same config may differ between Solaris and Windows for
+        example.
+      </desc>
+    </attribute>
+
+    <attribute name="allowTracingToAccessVM" type="boolean">
+      <desc>
+        Enables tracepoints in PDM devices and drivers to use the VMCPU or VM
+        structures when firing off trace points.  This is especially useful
+        with DTrace tracepoints, as it allow you to use the VMCPU or VM pointer
+        to obtail useful information such as guest register state.
+
+        This is disabled by default because devices and drivers normally has no
+        business accessing the VMCPU or VM structures, and are therefore unable
+        to get any pointers to these.
       </desc>
     </attribute>

trunk/src/VBox/Main/include/MachineImpl.h

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VirtualBox COM class implementation
+ * Implementation of IMachine in VBoxSVC - Header.
  */
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -297 +297 @@
         typedef std::list<ComObjPtr<PciDeviceAttachment> > PciDeviceAssignmentList;
         PciDeviceAssignmentList mPciDeviceAssignments;
+
+        settings::Debugging  mDebugging;
     };
 
@@ -468 +470 @@
     STDMETHOD(COMGETTER(PciDeviceAssignments))(ComSafeArrayOut(IPciDeviceAttachment *, aAssignments));
     STDMETHOD(COMGETTER(BandwidthControl))(IBandwidthControl **aBandwidthControl);
+    STDMETHOD(COMGETTER(TracingEnabled))(BOOL *pfEnabled);
+    STDMETHOD(COMSETTER(TracingEnabled))(BOOL fEnabled);
+    STDMETHOD(COMGETTER(TracingConfig))(BSTR *pbstrConfig);
+    STDMETHOD(COMSETTER(TracingConfig))(IN_BSTR bstrConfig);
+    STDMETHOD(COMGETTER(AllowTracingToAccessVM))(BOOL *pfAllow);
+    STDMETHOD(COMSETTER(AllowTracingToAccessVM))(BOOL fAllow);
 
     // IMachine methods
@@ -786 +794 @@
                          const Guid &aCurSnapshotId,
                          Snapshot *aParentSnapshot);
-    HRESULT loadHardware(const settings::Hardware &data);
+    HRESULT loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg);
+    HRESULT loadDebugging(const settings::Debugging *pDbg);
     HRESULT loadStorageControllers(const settings::Storage &data,
                                    const Guid *puuidRegistry,
@@ -826 +835 @@
     void copyMachineDataToSettings(settings::MachineConfigFile &config);
     HRESULT saveAllSnapshots(settings::MachineConfigFile &config);
-    HRESULT saveHardware(settings::Hardware &data);
+    HRESULT saveHardware(settings::Hardware &data, settings::Debugging *pDbg);
     HRESULT saveStorageControllers(settings::Storage &data);
     HRESULT saveStorageDevices(ComObjPtr<StorageController> aStorageController,
@@ -1195 +1204 @@
                  IN_GUID aSnapshotId,
                  const Utf8Str &aStateFilePath);
-    HRESULT init(Machine *aMachine,
-                 const settings::Hardware &hardware,
-                 const settings::Storage &storage,
-                 IN_GUID aSnapshotId,
-                 const Utf8Str &aStateFilePath);
+    HRESULT initFromSettings(Machine *aMachine,
+                             const settings::Hardware &hardware,
+                             const settings::Debugging *pDbg,
+                             const settings::Storage &storage,
+                             IN_GUID aSnapshotId,
+                             const Utf8Str &aStateFilePath);
     void uninit();
 

trunk/src/VBox/Main/include/VirtualBoxBase.h

@@ -351 +351 @@
 
 /**
- * Checks that the string argument is not a NULL or empty string and returns
- * E_INVALIDARG + extended error info on failure.
- * @param arg   Input string argument (BSTR etc.).
- */
-#define CheckComArgStrNotEmptyOrNull(arg) \
-    do { \
-        if (RT_UNLIKELY((arg) == NULL || *(arg) == '\0')) \
-            return setError(E_INVALIDARG, \
-                tr("Argument %s is empty or NULL"), #arg); \
+ * Checks that a string input argument is valid (not NULL or obviously invalid
+ * pointer), returning E_INVALIDARG + extended error info if invalid.
+ * @param a_bstrIn  Input string argument (IN_BSTR).
+ */
+#define CheckComArgStr(a_bstrIn) \
+    do { \
+        IN_BSTR const bstrInCheck = (a_bstrIn); /* type check */ \
+        if (RT_UNLIKELY(!RT_VALID_PTR(bstrInCheck))) \
+            return setError(E_INVALIDARG, tr("Argument %s is an invalid pointer"), #a_bstrIn); \
+    } while (0)
+/**
+ * Checks that the string argument is not a NULL, a invalid pointer or an empty
+ * string, returning E_INVALIDARG + extended error info on failure.
+ * @param a_bstrIn  Input string argument (BSTR etc.).
+ */
+#define CheckComArgStrNotEmptyOrNull(a_bstrIn) \
+    do { \
+        IN_BSTR const bstrInCheck = (a_bstrIn); /* type check */ \
+        if (RT_UNLIKELY(!RT_VALID_PTR(bstrInCheck) || *(bstrInCheck) == '\0')) \
+            return setError(E_INVALIDARG, tr("Argument %s is empty or an invalid pointer"), #a_bstrIn); \
     } while (0)
 
@@ -959 +970 @@
      *  Stores the current data pointer in the backup area, allocates new data
      *  using the copy constructor on current data and makes new data active.
+     *
+     *  @deprecated Use backupEx to avoid throwing wild out-of-memory exceptions.
      */
     void backup()
@@ -969 +982 @@
             this->mData = pNewData;
         }
+    }
+
+    /**
+     *  Stores the current data pointer in the backup area, allocates new data
+     *  using the copy constructor on current data and makes new data active.
+     *
+     *  @returns S_OK, E_OUTOFMEMORY or E_FAIL (internal error).
+     */
+    HRESULT backupEx()
+    {
+        AssertMsgReturn(this->mData, ("data must not be NULL"), E_FAIL);
+        if (this->mData && !mBackupData)
+        {
+            try
+            {
+                D *pNewData = new D(*this->mData);
+                mBackupData = this->mData;
+                this->mData = pNewData;
+            }
+            catch (std::bad_alloc &)
+            {
+                return E_OUTOFMEMORY;
+            }
+        }
+        return S_OK;
     }
 

trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBox Console COM Class implementation
+ * VBox Console COM Class implementation - VM Configuration Bits.
  *
  * @remark  We've split out the code that the 64-bit VC++ v8 compiler finds
@@ -10 +10 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2012 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -2588 +2588 @@
             InsertConfigInteger(pInst, "Trusted", 1); /* boolean */
             InsertConfigNode(pInst,    "Config", &pCfg);
-            hrc = BusMgr->assignPciDevice("acpi", pInst);                               H();
+            hrc = BusMgr->assignPciDevice("acpi", pInst);                                   H();
 
             InsertConfigInteger(pCfg,  "RamSize",          cbRam);
@@ -2654 +2654 @@
 
         /*
-         * Set up the default DBGF search paths if all is cool so far.
+         * Configure DBGF (Debug(ger) Facility).
          */
         {
@@ -2660 +2660 @@
             InsertConfigNode(pRoot, "DBGF", &pDbgf);
 
-            hrc = pMachine->COMGETTER(SettingsFilePath)(bstr.asOutParam());         H();
+            /* Paths to search for debug info and such things. */
+            hrc = pMachine->COMGETTER(SettingsFilePath)(bstr.asOutParam());                 H();
             Utf8Str strSettingsPath(bstr);
             bstr.setNull();
@@ -2676 +2677 @@
 
             InsertConfigString(pDbgf, "Path", strPath.c_str());
+
+            /* Tracing configuration. */
+            BOOL fTracingEnabled;
+            hrc = pMachine->COMGETTER(TracingEnabled)(&fTracingEnabled);                    H();
+            if (fTracingEnabled)
+                InsertConfigInteger(pDbgf, "TracingEnabled", 1);
+
+            hrc = pMachine->COMGETTER(TracingConfig)(bstr.asOutParam());                    H();
+            if (fTracingEnabled)
+                InsertConfigString(pDbgf, "TracingConfig", bstr);
+
+            BOOL fAllowTracingToAccessVM;
+            hrc = pMachine->COMGETTER(AllowTracingToAccessVM)(&fAllowTracingToAccessVM);    H();
+            if (fAllowTracingToAccessVM)
+                InsertConfigInteger(pPDM, "AllowTracingToAccessVM", 1);
         }
     }

trunk/src/VBox/Main/src-server/MachineImpl.cpp

@@ -6364 +6364 @@
 }
 
+STDMETHODIMP Machine::COMGETTER(TracingEnabled)(BOOL *pfEnabled)
+{
+    CheckComArgOutPointerValid(pfEnabled);
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+        *pfEnabled = mHWData->mDebugging.fTracingEnabled;
+    }
+    return hrc;
+}
+
+STDMETHODIMP Machine::COMSETTER(TracingEnabled)(BOOL fEnabled)
+{
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = checkStateDependency(MutableStateDep);
+        if (SUCCEEDED(hrc))
+        {
+            hrc = mHWData.backupEx();
+            if (SUCCEEDED(hrc))
+            {
+                setModified(IsModified_MachineData);
+                mHWData->mDebugging.fTracingEnabled = fEnabled != FALSE;
+            }
+        }
+    }
+    return hrc;
+}
+
+STDMETHODIMP Machine::COMGETTER(TracingConfig)(BSTR *pbstrConfig)
+{
+    CheckComArgOutPointerValid(pbstrConfig);
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = mHWData->mDebugging.strTracingConfig.cloneToEx(pbstrConfig);
+    }
+    return hrc;
+}
+
+STDMETHODIMP Machine::COMSETTER(TracingConfig)(IN_BSTR bstrConfig)
+{
+    CheckComArgStr(bstrConfig);
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = checkStateDependency(MutableStateDep);
+        if (SUCCEEDED(hrc))
+        {
+            hrc = mHWData.backupEx();
+            if (SUCCEEDED(hrc))
+            {
+                hrc = mHWData->mDebugging.strTracingConfig.cloneEx(bstrConfig);
+                if (SUCCEEDED(hrc))
+                    setModified(IsModified_MachineData);
+            }
+        }
+    }
+    return hrc;
+
+}
+
+STDMETHODIMP Machine::COMGETTER(AllowTracingToAccessVM)(BOOL *pfAllow)
+{
+    CheckComArgOutPointerValid(pfAllow);
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+        *pfAllow = mHWData->mDebugging.fAllowTracingToAccessVM;
+    }
+    return hrc;
+}
+
+STDMETHODIMP Machine::COMSETTER(AllowTracingToAccessVM)(BOOL fAllow)
+{
+    AutoCaller autoCaller(this);
+    HRESULT hrc = autoCaller.rc();
+    if (SUCCEEDED(hrc))
+    {
+        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+        hrc = checkStateDependency(MutableStateDep);
+        if (SUCCEEDED(hrc))
+        {
+            hrc = mHWData.backupEx();
+            if (SUCCEEDED(hrc))
+            {
+                setModified(IsModified_MachineData);
+                mHWData->mDebugging.fAllowTracingToAccessVM = fAllow != FALSE;
+            }
+        }
+    }
+    return hrc;
+}
+
+
+
 STDMETHODIMP Machine::CloneTo(IMachine *pTarget, CloneMode_T mode, ComSafeArrayIn(CloneOptions_T, options), IProgress **pProgress)
 {
@@ -7707 +7814 @@
 
     // hardware data
-    rc = loadHardware(config.hardwareMachine);
+    rc = loadHardware(config.hardwareMachine, &config.debugging);
     if (FAILED(rc)) return rc;
 
@@ -7775 +7882 @@
     ComObjPtr<SnapshotMachine> pSnapshotMachine;
     pSnapshotMachine.createObject();
-    rc = pSnapshotMachine->init(this,
-                                data.hardware,
-                                data.storage,
-                                data.uuid.ref(),
-                                strStateFile);
+    rc = pSnapshotMachine->initFromSettings(this,
+                                            data.hardware,
+                                            &data.debugging,
+                                            data.storage,
+                                            data.uuid.ref(),
+                                            strStateFile);
     if (FAILED(rc)) return rc;
 
@@ -7822 +7930 @@
 
 /**
- *  @param aNode    <Hardware> node.
+ *  Loads settings into mHWData.
+ *
+ *  @param data     Reference to the hardware settings.
+ *  @param pDbg     Pointer to the debugging settings.
  */
-HRESULT Machine::loadHardware(const settings::Hardware &data)
+HRESULT Machine::loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg)
 {
     AssertReturn(!isSessionMachine(), E_FAIL);
@@ -8051 +8162 @@
         }
 
+        /*
+         * (The following isn't really real hardware, but it lives in HWData
+         * for reasons of convenience.)
+         */
+
 #ifdef VBOX_WITH_GUEST_PROPS
         /* Guest properties (optional) */
@@ -8066 +8182 @@
         mHWData->mGuestPropertyNotificationPatterns = data.strNotificationPatterns;
 #endif /* VBOX_WITH_GUEST_PROPS defined */
+
+        rc = loadDebugging(pDbg);
+        if (FAILED(rc))
+            return rc;
     }
     catch(std::bad_alloc &)
@@ -8074 +8194 @@
     AssertComRC(rc);
     return rc;
+}
+
+/**
+ * Called from Machine::loadHardware() to load the debugging settings of the
+ * machine.
+ *
+ * @param   pDbg        Pointer to the settings.
+ */
+HRESULT Machine::loadDebugging(const settings::Debugging *pDbg)
+{
+    mHWData->mDebugging = *pDbg;
+    /* no more processing currently required, this will probably change. */
+    return S_OK;
 }
 
@@ -8893 +9026 @@
     /// @todo Live Migration:        config.fTeleported = (mData->mMachineState == MachineState_Teleported);
 
-    HRESULT rc = saveHardware(config.hardwareMachine);
+    HRESULT rc = saveHardware(config.hardwareMachine, &config.debugging);
     if (FAILED(rc)) throw rc;
 
@@ -8966 +9099 @@
  *  given node is empty.
  *
- *  @param aNode    <Hardware> node to save the VM hardware configuration to.
+ *  @param data     Reference to the settings object for the hardware config.
+ *  @param pDbg     Pointer to the settings object for the debugging config
+ *                  which happens to live in mHWData.
  */
-HRESULT Machine::saveHardware(settings::Hardware &data)
+HRESULT Machine::saveHardware(settings::Hardware &data, settings::Debugging *pDbg)
 {
     HRESULT rc = S_OK;
@@ -9198 +9333 @@
         mData->mGuestPropertiesModified = FALSE;
 #endif /* VBOX_WITH_GUEST_PROPS defined */
+
+        *pDbg = mHWData->mDebugging;
     }
     catch(std::bad_alloc &)

trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

@@ -773 +773 @@
         data.strStateFile.setNull();
 
-    HRESULT rc = m->pMachine->saveHardware(data.hardware);
+    HRESULT rc = m->pMachine->saveHardware(data.hardware, &data.debugging);
     if (FAILED(rc)) return rc;
 
@@ -1078 +1078 @@
  *  @note Doesn't lock anything.
  */
-HRESULT SnapshotMachine::init(Machine *aMachine,
-                              const settings::Hardware &hardware,
-                              const settings::Storage &storage,
-                              IN_GUID aSnapshotId,
-                              const Utf8Str &aStateFilePath)
+HRESULT SnapshotMachine::initFromSettings(Machine *aMachine,
+                                          const settings::Hardware &hardware,
+                                          const settings::Debugging *pDbg,
+                                          const settings::Storage &storage,
+                                          IN_GUID aSnapshotId,
+                                          const Utf8Str &aStateFilePath)
 {
     LogFlowThisFuncEnter();
@@ -1156 +1157 @@
     /* load hardware and harddisk settings */
 
-    HRESULT rc = loadHardware(hardware);
+    HRESULT rc = loadHardware(hardware, pDbg);
     if (SUCCEEDED(rc))
         rc = loadStorageControllers(storage,

trunk/src/VBox/Main/xml/Settings.cpp

@@ -834 +834 @@
             break;
 
+        case SettingsVersion_v1_13:
+            pcszVersion = "1.13";
+            break;
+
         case SettingsVersion_Future:
             // can be set if this code runs on XML files that were created by a future version of VBox;
             // in that case, downgrade to current version when writing since we can't write future versions...
-            pcszVersion = "1.12";
-            m->sv = SettingsVersion_v1_12;
+            pcszVersion = "1.13";
+            m->sv = SettingsVersion_v1_13;
             break;
 
@@ -1755 +1759 @@
                   && (storage               == s.storage)                   // deep compare
                   && (llChildSnapshots      == s.llChildSnapshots)          // deep compare
+                  && debugging              == s.debugging
                 )
            );
@@ -3160 +3165 @@
 
 /**
+ * Called for reading the <Debugging> element under <Machine> or <Snapshot>.
+ */
+void MachineConfigFile::readDebugging(const xml::ElementNode *pElmDebugging, Debugging *pDbg)
+{
+    if (!pElmDebugging || m->sv < SettingsVersion_v1_13)
+        return;
+
+    const xml::ElementNode * const pelmTracing = pElmDebugging->findChildElement("Tracing");
+    if (pelmTracing)
+    {
+        pelmTracing->getAttributeValue("enabled", pDbg->fTracingEnabled);
+        pelmTracing->getAttributeValue("allowTracingToAccessVM", pDbg->fAllowTracingToAccessVM);
+        pelmTracing->getAttributeValue("config", pDbg->strTracingConfig);
+    }
+}
+
+/**
  * Called initially for the <Snapshot> element under <Machine>, if present,
  * to store the snapshot's data into the given Snapshot structure (which is
@@ -3231 +3253 @@
         // with data from old DVDDrive and FloppyDrive elements
         readDVDAndFloppies_pre1_9(*pelmHardware, snap.storage);
+
+    readDebugging(elmSnapshot.findChildElement("Debugging"), &snap.debugging);
 }
 
@@ -3379 +3403 @@
             else if (pelmMachineChild->nameEquals("MediaRegistry"))
                 readMediaRegistry(*pelmMachineChild, mediaRegistry);
+            else if (pelmMachineChild->nameEquals("Debugging"))
+                readDebugging(pelmMachineChild, &debugging);
         }
 
@@ -4301 +4327 @@
 
 /**
+ * Creates a <Debugging> node under elmParent and then writes out the XML
+ * keys under that. Called for both the <Machine> node and for snapshots.
+ *
+ * @param pElmParent    Pointer to the parent element.
+ * @param pDbg          Pointer to the debugging settings.
+ */
+void MachineConfigFile::buildDebuggingXML(xml::ElementNode *pElmParent, const Debugging *pDbg)
+{
+    if (m->sv < SettingsVersion_v1_13 || pDbg->areDefaultSettings())
+        return;
+
+    xml::ElementNode *pElmDebugging = pElmParent->createChild("Debugging");
+    xml::ElementNode *pElmTracing   = pElmDebugging->createChild("Tracing");
+    pElmTracing->setAttribute("enabled", pDbg->fTracingEnabled);
+    pElmTracing->setAttribute("allowTracingToAccessVM", pDbg->fAllowTracingToAccessVM);
+    pElmTracing->setAttribute("config", pDbg->strTracingConfig);
+}
+
+/**
  * Writes a single snapshot into the DOM tree. Initially this gets called from MachineConfigFile::write()
  * for the root snapshot of a machine, if present; elmParent then points to the <Snapshots> node under the
@@ -4329 +4374 @@
                                     // we only skip removable media for OVF, but we never get here for OVF
                                     // since snapshots never get written then
+    buildDebuggingXML(pelmSnapshot, &snap.debugging);
 
     if (snap.llChildSnapshots.size())
@@ -4476 +4522 @@
                                !!(fl & BuildMachineXML_SkipRemovableMedia),
                                pllElementsWithUuidAttributes);
+    buildDebuggingXML(&elmMachine, &debugging);
 }
 
@@ -4591 +4638 @@
 void MachineConfigFile::bumpSettingsVersionIfNeeded()
 {
+    if (m->sv < SettingsVersion_v1_13)
+    {
+        // VirtualBox 4.2 adds tracing.
+        if (!debugging.areDefaultSettings())
+            m->sv = SettingsVersion_v1_13;
+    }
+
     if (m->sv < SettingsVersion_v1_12)
     {