Changeset 62118 in vbox for trunk/src

Timestamp:

Jul 7, 2016 4:16:44 PM (8 years ago)

Author:

vboxsync

Message:

ValidationKit/tests/storage: More hacking on the storage benchmark testcase

Location:

trunk/src/VBox/ValidationKit/tests/storage

Files:

• remoteexecutor.py (modified) (7 diffs)
• storagecfg.py (modified) (8 diffs)
• tdStorageBenchmark1.py (modified) (6 diffs)

trunk/src/VBox/ValidationKit/tests/storage/remoteexecutor.py

@@ -34 +34 @@
 import os;
 import shutil;
+import subprocess;
 
 # Validation Kit imports.
@@ -41 +42 @@
 class StdInOutBuffer(object):
     """ Standard input output buffer """
+
     def __init__(self, sInput = None):
         if sInput is not None:
@@ -65 +67 @@
         """file.read"""
         cb = min(cb, len(self.sInput) - self.offInput);
-        sReturn = self.sInput[self.offInput:(self.offInput + cb)];
-        self.offInput += cb;
+        if cb > 0:
+            sReturn = self.sInput[self.offInput:(self.offInput + cb)];
+            self.offInput += cb;
+        else:
+            sReturn = '';
         return sReturn;
 
@@ -80 +85 @@
         return self.sOutput;
 
+    def close(self):
+        """ file.close """
+        return;
 
 class RemoteExecutor(object):
@@ -122 +130 @@
         reporter.flushall();
         try:
-            oStdIn = None;
-            if sInput is not None:
-                oStdIn = StdInOutBuffer(sInput);
-            sOutput = utils.sudoProcessOutputChecked(asArgs, stdin= oStdIn, shell = False, close_fds = False);
+            oProcess = utils.sudoProcessPopen(asArgs, stdout=subprocess.PIPE, stdin=subprocess.PIPE,
+                                              shell = False, close_fds = False);
+
+            sOutput, _ = oProcess.communicate(sInput);
+            iExitCode  = oProcess.poll();
+
+            if iExitCode is not 0:
+                print(sOutput);
+                raise subprocess.CalledProcessError(iExitCode, asArgs);
         except:
             reporter.errorXcpt();
             return (False, None);
         reporter.log('Exit code [sudo]: %s (%s)' % (True, asArgs));
-        return (True, sOutput);
+        return (True, str(sOutput));
 
     def _execLocallyOrThroughTxs(self, sExec, asArgs, sInput):
@@ -168 +181 @@
         return (fRc, sOutput);
 
+    def execBinaryNoStdOut(self, sExec, asArgs, sInput = None):
+        """
+        Executes the given binary with the given arguments
+        providing some optional input through stdin and
+        returning whether the process exited successfully.
+        """
+        fRc, _ = self.execBinary(sExec, asArgs, sInput);
+        return fRc;
+
     def copyFile(self, sLocalFile, sFilename, cMsTimeout = 30000):
         """
@@ -216 +238 @@
 
         return sFileId;
+
+    def mkDir(self, sDir, fMode = 0700, cMsTimeout = 30000):
+        """
+        Creates a new directory at the given location.
+        """
+        fRc = True;
+        if self.oTxsSession is not None:
+            fRc = self.oTxsSession.syncMkDir(sDir, fMode, cMsTimeout);
+        else:
+            fRc = self.execBinaryNoStdOut('mkdir', ('-m', format(fMode, 'o'), sDir));
+
+        return fRc;
+
+    def rmDir(self, sDir, cMsTimeout = 30000):
+        """
+        Removes the given directory.
+        """
+        fRc = True;
+        if self.oTxsSession is not None:
+            fRc = self.oTxsSession.syncRmDir(sDir, cMsTimeout);
+        else:
+            fRc = self.execBinaryNoStdOut('rmdir', (sDir,));
+
+        return fRc;
+

trunk/src/VBox/ValidationKit/tests/storage/storagecfg.py

@@ -157 +157 @@
     def __init__(self):
         StorageConfigOs.__init__(self);
+        self.dSimplePools = { }; # Simple storage pools which don't use lvm (just one partition)
+        self.dMounts      = { }; # Pool/Volume to mountpoint mapping.
+
+    def _getDmRaidLevelFromLvl(self, sRaidLvl):
+        """
+        Converts our raid level indicators to something mdadm can understand.
+        """
+        if sRaidLvl == 'raid5':
+            return '5';
+        elif sRaidLvl == 'raid1':
+            return 'mirror';
+        elif sRaidLvl == 'raid0' or sRaidLvl is None:
+            return 'stripe';
+
+        return 'stripe';
 
     def getDisksMatchingRegExp(self, sRegExp):
@@ -175 +190 @@
         """
         fRc = True;
-        _ = oExec;
-        _ = sPool;
-        _ = asDisks;
-        _ = sRaidLvl;
+        if len(asDisks) == 1 and sRaidLvl is None:
+            # Doesn't require LVM, put into the simple pools dictionary so we can
+            # use it when creating a volume later.
+            self.dSimplePools[sPool] = asDisks[0];
+        else:
+            # If a RAID is required use dm-raid first to create one.
+            asLvmPvDisks = asDisks;
+            fRc = oExec.execBinaryNoStdOut('mdadm', ('--create', '/dev/md0', '--assume-clean',
+                                                     '--level=' + self._getDmRaidLevelFromLvl(sRaidLvl),
+                                                     '--raid-devices=' + str(len(asDisks))) + tuple(asDisks));
+            if fRc:
+                # /dev/md0 is the only block device to use for our volume group.
+                asLvmPvDisks = [ '/dev/md0' ];
+
+            # Create a physical volume on every disk first.
+            for sLvmPvDisk in asLvmPvDisks:
+                fRc = oExec.execBinaryNoStdOut('pvcreate', (sLvmPvDisk, ));
+                if not fRc:
+                    break;
+
+            if fRc:
+                # Create volume group with all physical volumes included
+                fRc = oExec.execBinaryNoStdOut('vgcreate', (sPool, ) + tuple(asLvmPvDisks));
         return fRc;
 
@@ -187 +221 @@
         """
         fRc = True;
-        _ = oExec;
-        _ = sPool;
-        _ = sVol;
-        _ = sMountPoint;
-        _ = cbVol;
+        sBlkDev = None;
+        if self.dSimplePools.has_key(sPool):
+            sDiskPath = self.dSimplePools.get(sPool);
+            # Create a partition with the requested size
+            sFdiskScript = ';\n'; # Single partition filling everything
+            if cbVol is not None:
+                sFdiskScript = ',' + str(cbVol / 512) + '\n'; # Get number of sectors
+            fRc, _ = oExec.execBinary('sfdisk', ('--no-reread', '--wipe', 'always', '-q', '-f', sDiskPath), sFdiskScript);
+            if fRc:
+                sBlkDev = sDiskPath + '1';
+        else:
+            if cbVol is None:
+                fRc = oExec.execBinaryNoStdOut('lvcreate', ('-l', '100%FREE', '-n', sVol, sPool));
+            else:
+                fRc = oExec.execBinaryNoStdOut('lvcreate', ('-L', str(cbVol), '-n', sVol, sPool));
+            if fRc:
+                sBlkDev = '/dev/mapper' + sPool + '-' + sVol;
+
+        if fRc is True and sBlkDev is not None:
+            # Create a filesystem and mount it
+            fRc = oExec.execBinaryNoStdOut('mkfs.ext4', ('-F', '-F', sBlkDev,));
+            fRc = fRc and oExec.mkDir(sMountPoint);
+            fRc = fRc and oExec.execBinaryNoStdOut('mount', (sBlkDev, sMountPoint));
+            if fRc:
+                self.dMounts[sPool + '/' + sVol] = sMountPoint;
         return fRc;
 
@@ -198 +252 @@
         Destroys the given volume.
         """
-        fRc, _ = oExec.execBinary('lvremove', (sPool + '/' + sVol,));
+        # Unmount first
+        sMountPoint = self.dMounts[sPool + '/' + sVol];
+        fRc, _ = oExec.execBinary('umount', (sMountPoint,));
+        self.dMounts.pop(sPool + '/' + sVol);
+        oExec.rmDir(sMountPoint);
+        if self.dSimplePools.has_key(sPool):
+            # Wipe partition table
+            sDiskPath = self.dSimplePools.get(sPool);
+            fRc = oExec.execBinaryNoStdOut('sfdisk', ('--no-reread', '--wipe', 'always', '-q', '-f', sDiskPath));
+        else:
+            fRc = oExec.execBinaryNoStdOut('lvremove', (sPool + '/' + sVol,));
         return fRc;
 
@@ -205 +269 @@
         Destroys the given storage pool.
         """
-        fRc, _ = oExec.execBinary('vgremove', (sPool,));
+        fRc = True;
+        if self.dSimplePools.has_key(sPool):
+            self.dSimplePools.pop(sPool);
+        else:
+            fRc = oExec.execBinaryNoStdOut('vgremove', (sPool,));
         return fRc;
 
@@ -213 +281 @@
     """
 
-    kdStorageCfgs = {
-        'testboxstor1.de.oracle.com': ('solaris', r'c[3-9]t\dd0\Z')
-    };
-
-    def __init__(self, oExec, sHostname = None):
+    def __init__(self, oExec, sTargetOs, oDiskCfg):
         self.oExec    = oExec;
         self.lstDisks = [ ]; # List of disks present in the system.
@@ -225 +289 @@
         self.iVolId   = 0;
 
-        sOs, oDiskCfg = self.kdStorageCfgs.get(sHostname);
-
         fRc = True;
         oStorOs = None;
-        if sOs == 'solaris':
+        if sTargetOs == 'solaris':
             oStorOs = StorageConfigOsSolaris();
-        elif sOs == 'linux':
+        elif sTargetOs == 'linux':
             oStorOs = StorageConfigOsLinux(); # pylint: disable=R0204
         else:
@@ -388 +450 @@
         return fRc;
 
+    def mkDirOnVolume(self, sMountPoint, sDir, fMode = 0700):
+        """
+        Creates a new directory on the volume pointed to by the given mount point.
+        """
+        return self.oExec.mkDir(sMountPoint + '/' + sDir, fMode);
+

trunk/src/VBox/ValidationKit/tests/storage/tdStorageBenchmark1.py

@@ -230 +230 @@
     """
 
+    # Global storage configs for the testbox
+    kdStorageCfgs = {
+        'testboxstor1.de.oracle.com': r'c[3-9]t\dd0\Z',
+        'adaris': [ '/dev/sda' ]
+    };
+
     def __init__(self):
         vbox.TestDriver.__init__(self);
@@ -236 +242 @@
         self.oGuestToGuestSess = None;
         self.oGuestToGuestTxs  = None;
-        self.asTestVMsDef      = ['tst-debian'];
+        self.asTestVMsDef      = ['tst-storage'];
         self.asTestVMs         = self.asTestVMsDef;
         self.asSkipVMs         = [];
@@ -249 +255 @@
         self.asTestsDef        = ['iozone', 'fio'];
         self.asTests           = self.asTestsDef;
-        self.asIscsiTargetsDef = ['aurora|iqn.2011-03.home.aurora:aurora.storagebench|1'];
+        self.asIscsiTargetsDef = [ ]; # @todo: Configure one target for basic iSCSI testing
         self.asIscsiTargets    = self.asIscsiTargetsDef;
         self.fTestHost         = False;
+        self.oStorCfg          = None;
 
     #
@@ -352 +359 @@
         if self.asRsrcs is None:
             self.asRsrcs = [];
-            if 'tst-debian' in self.asTestVMs:
-                self.asRsrcs.append('4.2/storage/debian.vdi');
+            if 'tst-storage' in self.asTestVMs:
+                self.asRsrcs.append('5.1/storage/tst-storage.vdi');
 
         return self.asRsrcs;
@@ -368 +375 @@
 
         # Linux VMs
-        if 'tst-debian' in self.asTestVMs:
-            oVM = self.createTestVM('tst-debian', 1, '4.2/storage/debian.vdi', sKind = 'Debian_64', fIoApic = True, \
+        if 'tst-storage' in self.asTestVMs:
+            oVM = self.createTestVM('tst-storage', 1, '5.1/storage/tst-storage.vdi', sKind = 'ArchLinux_64', fIoApic = True, \
                                     eNic0AttachType = vboxcon.NetworkAttachmentType_NAT, \
                                     eNic0Type = vboxcon.NetworkAdapterType_Am79C973);
@@ -389 +396 @@
     #
 
-    def test1Benchmark(self, sTargetOs, sBenchmark, oTxsSession = None):
-        """
-        Runs the given benchmark on the test host.
-        """
-        lstBinaryPaths = ['/bin', '/sbin', '/usr/bin', '/usr/sbin', \
-                          '/opt/csw/bin', '/usr/ccs/bin', '/usr/sfw/bin'];
-        oExecutor = remoteexecutor.RemoteExecutor(oTxsSession, lstBinaryPaths, self.sScratchPath);
-
+    def prepareStorage(self, oStorCfg):
+        """
+        Prepares the host storage for disk images or direct testing on the host.
+        """
         # Create a basic pool with the default configuration.
-        oStorCfg = storagecfg.StorageCfg(oExecutor, socket.gethostname().lower());
+        sMountPoint = None;
         fRc, sPoolId = oStorCfg.createStoragePool();
         if fRc:
-            fRc, sMountpoint = oStorCfg.createVolume(sPoolId);
+            fRc, sMountPoint = oStorCfg.createVolume(sPoolId);
+            if not fRc:
+                sMountPoint = None;
+                oStorCfg.cleanup();
+
+        return sMountPoint;
+
+    def cleanupStorage(self, oStorCfg):
+        """
+        Cleans up any created storage space for a test.
+        """
+        return oStorCfg.cleanup();
+
+    def testBenchmark(self, sTargetOs, sBenchmark, sMountpoint, oExecutor):
+        """
+        Runs the given benchmark on the test host.
+        """
+        # Create a basic config
+        dCfg = {
+            'RecordSize':  '64k',
+            'TestsetSize': '100m',
+            'QueueDepth':  '32',
+            'FilePath': sMountpoint,
+            'TargetOs': sTargetOs
+        };
+
+        oTst = None;
+        if sBenchmark == 'iozone':
+            oTst = IozoneTest(oExecutor, dCfg);
+        elif sBenchmark == 'fio':
+            oTst = FioTest(oExecutor, dCfg); # pylint: disable=R0204
+
+        if oTst is not None:
+            reporter.testStart(sBenchmark);
+            fRc = oTst.prepare();
             if fRc:
-                # Create a basic config
-                dCfg = {
-                    'RecordSize':  '64k',
-                    'TestsetSize': '20g',
-                    'QueueDepth':  '32',
-                    'FilePath': sMountpoint,
-                    'TargetOs': sTargetOs
-                };
-
-                oTst = None;
-                if sBenchmark == 'iozone':
-                    oTst = IozoneTest(oExecutor, dCfg);
-                elif sBenchmark == 'fio':
-                    oTst = FioTest(oExecutor, dCfg); # pylint: disable=R0204
-
-                if oTst is not None:
-                    reporter.testStart(sBenchmark);
-                    fRc = oTst.prepare();
-                    if fRc:
-                        fRc = oTst.run();
-                        if fRc:
-                            fRc = oTst.reportResult();
+                fRc = oTst.run();
+                if fRc:
+                    fRc = oTst.reportResult();
+                else:
+                    reporter.testFailure('Running the testcase failed');
+            else:
+                reporter.testFailure('Preparing the testcase failed');
+
+        oTst.cleanup();
+        reporter.testDone();
+
+        return fRc;
+
+    def testBenchmarks(self, sTargetOs, sMountPoint, oExecutor):
+        """
+        Runs all the configured benchmarks on the target.
+        """
+        for sTest in self.asTests:
+            self.testBenchmark(sTargetOs, sTest, sMountPoint, oExecutor);
+
+    def test1OneCfg(self, sVmName, eStorageController, sDiskFormat, sDiskPath, cCpus, fHwVirt, fNestedPaging):
+        """
+        Runs the specified VM thru test #1.
+
+        Returns a success indicator on the general test execution. This is not
+        the actual test result.
+        """
+        oVM = self.getVmByName(sVmName);
+
+        # Reconfigure the VM
+        fRc = True;
+        oSession = self.openSession(oVM);
+        if oSession is not None:
+            # Attach HD
+            fRc = oSession.ensureControllerAttached(_ControllerTypeToName(eStorageController));
+            fRc = fRc and oSession.setStorageControllerType(eStorageController, _ControllerTypeToName(eStorageController));
+
+            if sDiskFormat == "iSCSI":
+                listNames = [];
+                listValues = [];
+                listValues = sDiskPath.split('|');
+                listNames.append('TargetAddress');
+                listNames.append('TargetName');
+                listNames.append('LUN');
+
+                if self.fpApiVer >= 5.0:
+                    oHd = oSession.oVBox.createMedium(sDiskFormat, sDiskPath, vboxcon.AccessMode_ReadWrite, \
+                                                      vboxcon.DeviceType_HardDisk);
+                else:
+                    oHd = oSession.oVBox.createHardDisk(sDiskFormat, sDiskPath);
+                oHd.type = vboxcon.MediumType_Normal;
+                oHd.setProperties(listNames, listValues);
+
+                # Attach it.
+                if fRc is True:
+                    try:
+                        if oSession.fpApiVer >= 4.0:
+                            oSession.o.machine.attachDevice(_ControllerTypeToName(eStorageController), \
+                                                            1, 0, vboxcon.DeviceType_HardDisk, oHd);
                         else:
-                            reporter.testFailure('Running the testcase failed');
+                            oSession.o.machine.attachDevice(_ControllerTypeToName(eStorageController), \
+                                                            1, 0, vboxcon.DeviceType_HardDisk, oHd.id);
+                    except:
+                        reporter.errorXcpt('attachDevice("%s",%s,%s,HardDisk,"%s") failed on "%s"' \
+                                           % (_ControllerTypeToName(eStorageController), 1, 0, oHd.id, oSession.sName) );
+                        fRc = False;
                     else:
-                        reporter.testFailure('Preparing the testcase failed');
-
-                    oTst.cleanup();
+                        reporter.log('attached "%s" to %s' % (sDiskPath, oSession.sName));
+            else:
+                fRc = fRc and oSession.createAndAttachHd(sDiskPath, sDiskFormat, _ControllerTypeToName(eStorageController), \
+                                                         cb = 300*1024*1024*1024, iPort = 1, fImmutable = False);
+            fRc = fRc and oSession.enableVirtEx(fHwVirt);
+            fRc = fRc and oSession.enableNestedPaging(fNestedPaging);
+            fRc = fRc and oSession.setCpuCount(cCpus);
+            fRc = fRc and oSession.saveSettings();
+            fRc = oSession.close() and fRc and True; # pychecker hack.
+            oSession = None;
+        else:
+            fRc = False;
+
+        # Start up.
+        if fRc is True:
+            self.logVmInfo(oVM);
+            oSession, oTxsSession = self.startVmAndConnectToTxsViaTcp(sVmName, fCdWait = False, fNatForwardingForTxs = True);
+            if oSession is not None:
+                self.addTask(oSession);
+
+                # Fudge factor - Allow the guest to finish starting up.
+                self.sleep(5);
+
+                # Prepare the storage on the guest
+                lstBinaryPaths = ['/bin', '/sbin', '/usr/bin', '/usr/sbin' ];
+                oExecVm = remoteexecutor.RemoteExecutor(oTxsSession, lstBinaryPaths, '${SCRATCH}');
+                oStorCfgVm = storagecfg.StorageCfg(oExecVm, 'linux', [ '/dev/sdb' ]);
+
+                sMountPoint = self.prepareStorage(oStorCfgVm);
+                if sMountPoint is not None:
+                    self.testBenchmarks('linux', sMountPoint, oExecVm);
+                    self.cleanupStorage(oStorCfgVm);
+                else:
+                    reporter.testFailure('Failed to prepare storage for the guest benchmark');
+
+                # cleanup.
+                self.removeTask(oTxsSession);
+                self.terminateVmBySession(oSession)
+
+                # Remove disk
+                oSession = self.openSession(oVM);
+                if oSession is not None:
+                    try:
+                        oSession.o.machine.detachDevice(_ControllerTypeToName(eStorageController), 1, 0);
+
+                        # Remove storage controller if it is not an IDE controller.
+                        if     eStorageController is not vboxcon.StorageControllerType_PIIX3 \
+                           and eStorageController is not vboxcon.StorageControllerType_PIIX4:
+                            oSession.o.machine.removeStorageController(_ControllerTypeToName(eStorageController));
+
+                        oSession.saveSettings();
+                        self.oVBox.deleteHdByLocation(sDiskPath);
+                        oSession.saveSettings();
+                        oSession.close();
+                        oSession = None;
+                    except:
+                        reporter.errorXcpt('failed to detach/delete disk %s from storage controller' % (sDiskPath));
+                else:
+                    fRc = False;
+            else:
+                fRc = False;
+        return fRc;
+
+    def testBenchmarkOneVM(self, sVmName):
+        """
+        Runs one VM thru the various benchmark configurations.
+        """
+        reporter.testStart(sVmName);
+        fRc = True;
+        for sStorageCtrl in self.asStorageCtrls:
+            reporter.testStart(sStorageCtrl);
+
+            if sStorageCtrl == 'AHCI':
+                eStorageCtrl = vboxcon.StorageControllerType_IntelAhci;
+            elif sStorageCtrl == 'IDE':
+                eStorageCtrl = vboxcon.StorageControllerType_PIIX4;
+            elif sStorageCtrl == 'LsiLogicSAS':
+                eStorageCtrl = vboxcon.StorageControllerType_LsiLogicSas;
+            elif sStorageCtrl == 'LsiLogic':
+                eStorageCtrl = vboxcon.StorageControllerType_LsiLogic;
+            elif sStorageCtrl == 'BusLogic':
+                eStorageCtrl = vboxcon.StorageControllerType_BusLogic;
+            else:
+                eStorageCtrl = None;
+
+            for sDiskFormat in self.asDiskFormats:
+                reporter.testStart('%s' % (sDiskFormat));
+
+                if sDiskFormat == "iSCSI":
+                    asPaths = self.asIscsiTargets;
+                else:
+                    # Create a new default storage config on the host
+                    sMountPoint = self.prepareStorage(self.oStorCfg);
+                    if sMountPoint is not None:
+                        asPaths = [ sMountPoint ];
+                    else:
+                        asPaths = [];
+                        fRc = False;
+                        reporter.testFailure('Failed to prepare storage for VM');
+
+                for sPath in asPaths:
+                    reporter.testStart('%s' % (sPath));
+
+                    if sDiskFormat == "iSCSI":
+                        sPath = sPath;
+                    else:
+                         # Create a directory where every normal user can write to.
+                        self.oStorCfg.mkDirOnVolume(sPath, 'test', 0777);
+                        sPath = sPath + "/test/test.disk";
+
+                    for cCpus in self.acCpus:
+                        if cCpus == 1:  reporter.testStart('1 cpu');
+                        else:           reporter.testStart('%u cpus' % (cCpus));
+
+                        for sVirtMode in self.asVirtModes:
+                            if sVirtMode == 'raw' and cCpus > 1:
+                                continue;
+                            hsVirtModeDesc = {};
+                            hsVirtModeDesc['raw']       = 'Raw-mode';
+                            hsVirtModeDesc['hwvirt']    = 'HwVirt';
+                            hsVirtModeDesc['hwvirt-np'] = 'NestedPaging';
+                            reporter.testStart(hsVirtModeDesc[sVirtMode]);
+
+                            fHwVirt       = sVirtMode != 'raw';
+                            fNestedPaging = sVirtMode == 'hwvirt-np';
+                            fRc = self.test1OneCfg(sVmName, eStorageCtrl, sDiskFormat, sPath, \
+                                                   cCpus, fHwVirt, fNestedPaging)  and  fRc and True; # pychecker hack.
+                            reporter.testDone();
+
+                        reporter.testDone();
                     reporter.testDone();
-            else:
-                reporter.testFailure('Creating a storage volume on the target failed');
-
-            oStorCfg.cleanup();
+                reporter.testDone();
+            reporter.testDone();
+        reporter.testDone();
+        return fRc;
+
+    def test1(self):
+        """
+        Executes test #1.
+        """
+
+        fRc = True;
+        oDiskCfg = self.kdStorageCfgs.get(socket.gethostname().lower());
+
+        # Test the host first if requested
+        if oDiskCfg is not None:
+            lstBinaryPaths = ['/bin', '/sbin', '/usr/bin', '/usr/sbin', \
+                              '/opt/csw/bin', '/usr/ccs/bin', '/usr/sfw/bin'];
+            oExecutor = remoteexecutor.RemoteExecutor(None, lstBinaryPaths, self.sScratchPath);
+            self.oStorCfg = storagecfg.StorageCfg(oExecutor, utils.getHostOs(), oDiskCfg);
+
+            if self.fTestHost:
+                reporter.testStart('Host');
+                sMountPoint = self.prepareStorage(self.oStorCfg);
+                if sMountPoint is not None:
+                    fRc = self.testBenchmarks(utils.getHostOs(), sMountPoint, oExecutor);
+                    self.cleanupStorage(self.oStorCfg);
+                else:
+                    reporter.testFailure('Failed to prepare host storage');
+                reporter.testDone();
+
+            if fRc:
+                # Loop thru the test VMs.
+                for sVM in self.asTestVMs:
+                    # run test on the VM.
+                    if not self.testBenchmarkOneVM(sVM):
+                        fRc = False;
+                    else:
+                        fRc = True;
         else:
-            reporter.testFailure('Creating a storage pool on the target failed');
-
-        return fRc;
-
-    def test1Benchmarks(self, sTargetOs, oTxsSession = None):
-        """
-        Runs all the configured benchmarks on the target.
-        """
-        reporter.testStart('Host');
-        for sTest in self.asTests:
-            self.test1Benchmark(sTargetOs, sTest, oTxsSession);
-        reporter.testDone();
-
-    def test1(self):
-        """
-        Executes test #1.
-        """
-
-        # Test the host first if requested
-        fRc = True;
-        if self.fTestHost:
-            fRc = self.test1Benchmarks(utils.getHostOs());
-
-        # Loop thru the test VMs.
-        #for sVM in self.asTestVMs:
-        #    # run test on the VM.
-        #    if not self.test1OneVM(sVM):
-        #        fRc = False;
-        #    else:
-        #        fRc = True;
+            fRc = False;
 
         return fRc;