| import logging, time, re, os |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.virt import virt_vm, virt_utils |
| |
| |
| class EnospcConfig(object): |
| """ |
| Performs setup for the test enospc. This is a borg class, similar to a |
| singleton. The idea is to keep state in memory for when we call cleanup() |
| on postprocessing. |
| """ |
| __shared_state = {} |
| def __init__(self, test, params): |
| self.__dict__ = self.__shared_state |
| root_dir = test.bindir |
| self.tmpdir = test.tmpdir |
| self.qemu_img_binary = params.get('qemu_img_binary') |
| if not os.path.isfile(self.qemu_img_binary): |
| self.qemu_img_binary = os.path.join(root_dir, |
| self.qemu_img_binary) |
| self.raw_file_path = os.path.join(self.tmpdir, 'enospc.raw') |
| # Here we're trying to choose fairly explanatory names so it's less |
| # likely that we run in conflict with other devices in the system |
| self.vgtest_name = params.get("vgtest_name") |
| self.lvtest_name = params.get("lvtest_name") |
| self.lvtest_device = "/dev/%s/%s" % (self.vgtest_name, self.lvtest_name) |
| image_dir = os.path.dirname(params.get("image_name")) |
| self.qcow_file_path = os.path.join(image_dir, 'enospc.qcow2') |
| try: |
| getattr(self, 'loopback') |
| except AttributeError: |
| self.loopback = '' |
| |
| @error.context_aware |
| def setup(self): |
| logging.debug("Starting enospc setup") |
| error.context("performing enospc setup") |
| virt_utils.display_attributes(self) |
| # Double check if there aren't any leftovers |
| self.cleanup() |
| try: |
| utils.run("%s create -f raw %s 10G" % |
| (self.qemu_img_binary, self.raw_file_path)) |
| # Associate a loopback device with the raw file. |
| # Subject to race conditions, that's why try here to associate |
| # it with the raw file as quickly as possible |
| l_result = utils.run("losetup -f") |
| utils.run("losetup -f %s" % self.raw_file_path) |
| self.loopback = l_result.stdout.strip() |
| # Add the loopback device configured to the list of pvs |
| # recognized by LVM |
| utils.run("pvcreate %s" % self.loopback) |
| utils.run("vgcreate %s %s" % (self.vgtest_name, self.loopback)) |
| # Create an lv inside the vg with starting size of 200M |
| utils.run("lvcreate -L 200M -n %s %s" % |
| (self.lvtest_name, self.vgtest_name)) |
| # Create a 10GB qcow2 image in the logical volume |
| utils.run("%s create -f qcow2 %s 10G" % |
| (self.qemu_img_binary, self.lvtest_device)) |
| # Let's symlink the logical volume with the image name that autotest |
| # expects this device to have |
| os.symlink(self.lvtest_device, self.qcow_file_path) |
| except Exception, e: |
| self.cleanup() |
| raise |
| |
| @error.context_aware |
| def cleanup(self): |
| error.context("performing enospc cleanup") |
| if os.path.isfile(self.lvtest_device): |
| utils.run("fuser -k %s" % self.lvtest_device) |
| time.sleep(2) |
| l_result = utils.run("lvdisplay") |
| # Let's remove all volumes inside the volume group created |
| if self.lvtest_name in l_result.stdout: |
| utils.run("lvremove -f %s" % self.lvtest_device) |
| # Now, removing the volume group itself |
| v_result = utils.run("vgdisplay") |
| if self.vgtest_name in v_result.stdout: |
| utils.run("vgremove -f %s" % self.vgtest_name) |
| # Now, if we can, let's remove the physical volume from lvm list |
| if self.loopback: |
| p_result = utils.run("pvdisplay") |
| if self.loopback in p_result.stdout: |
| utils.run("pvremove -f %s" % self.loopback) |
| l_result = utils.run('losetup -a') |
| if self.loopback and (self.loopback in l_result.stdout): |
| try: |
| utils.run("losetup -d %s" % self.loopback) |
| except error.CmdError: |
| logging.error("Failed to liberate loopback %s", self.loopback) |
| if os.path.islink(self.qcow_file_path): |
| os.remove(self.qcow_file_path) |
| if os.path.isfile(self.raw_file_path): |
| os.remove(self.raw_file_path) |
| |
| |
| def run_enospc(test, params, env): |
| """ |
| ENOSPC test |
| |
| 1) Create a virtual disk on lvm |
| 2) Boot up guest with two disks |
| 3) Continually write data to second disk |
| 4) Check images and extend second disk when no space |
| 5) Continue paused guest |
| 6) Repeat step 3~5 several times |
| |
| @param test: KVM test object. |
| @param params: Dictionary with the test parameters. |
| @param env: Dictionary with test environment. |
| """ |
| enospc_config = EnospcConfig(test, params) |
| enospc_config.setup() |
| vm = env.get_vm(params["main_vm"]) |
| vm.create() |
| login_timeout = int(params.get("login_timeout", 360)) |
| session_serial = vm.wait_for_serial_login(timeout=login_timeout) |
| |
| vgtest_name = params.get("vgtest_name") |
| lvtest_name = params.get("lvtest_name") |
| logical_volume = "/dev/%s/%s" % (vgtest_name, lvtest_name) |
| |
| drive_format = params.get("drive_format") |
| if drive_format == "virtio": |
| devname = "/dev/vdb" |
| elif drive_format == "ide": |
| output = session_serial.cmd_output("dir /dev") |
| devname = "/dev/" + re.findall("([sh]db)\s", output)[0] |
| elif drive_format == "scsi": |
| devname = "/dev/sdb" |
| cmd = params.get("background_cmd") |
| cmd %= devname |
| logging.info("Sending background cmd '%s'", cmd) |
| session_serial.sendline(cmd) |
| |
| iterations = int(params.get("repeat_time", 40)) |
| i = 0 |
| pause_n = 0 |
| while i < iterations: |
| status = vm.monitor.cmd("info status") |
| logging.debug(status) |
| if "paused" in status: |
| pause_n += 1 |
| logging.info("Checking all images in use by the VM") |
| for image_name in vm.params.objects("images"): |
| image_params = vm.params.object_params(image_name) |
| try: |
| virt_vm.check_image(image_params, test.bindir) |
| except (virt_vm.VMError, error.TestWarn), e: |
| logging.error(e) |
| logging.info("Guest paused, extending Logical Volume size") |
| try: |
| utils.run("lvextend -L +200M %s" % logical_volume) |
| except error.CmdError, e: |
| logging.debug(e.result_obj.stdout) |
| vm.monitor.cmd("cont") |
| time.sleep(10) |
| i += 1 |
| |
| if pause_n == 0: |
| raise error.TestFail("Guest didn't pause during loop") |
| else: |
| logging.info("Guest paused %s times from %s iterations", |
| pause_n, iterations) |
| |
| logging.info("Final %s", vm.monitor.cmd("info status")) |
| enospc_config.cleanup() |
