def test_not_supported(self): with namedTemporaryDir() as tmpdir: # Prepare file poisoned with "x" path = os.path.join(tmpdir, "backing_file") with io.open(path, "wb") as f: f.write(b"x" * SIZE) # And discard it - this will fail silently. blockdev.discard(path) # File should not be modified with io.open(path, "rb") as f: data = f.read(SIZE) self.assertEqual(data, b"x" * SIZE, "data was modified")
def test_not_supported(self): with namedTemporaryDir() as tmpdir: # Prepare file poisoned with "x" path = os.path.join(tmpdir, "backing_file") with io.open(path, "wb") as f: f.write(b"x" * FILE_SIZE) # And discard it - this will fail silently. blockdev.discard(path) # File should not be modified with io.open(path, "rb") as f: data = f.read(FILE_SIZE) assert data == b"x" * FILE_SIZE
def test_supported(self): with namedTemporaryDir() as tmpdir: # Prepare backing file poisoned with "x" backing_file = os.path.join(tmpdir, "backing_file") with io.open(backing_file, "wb") as f: f.write(b"x" * SIZE) # Create a loop device with loopback.Device(backing_file) as loop_device: # And discard it blockdev.discard(loop_device.path) stat = os.stat(backing_file) self.assertEqual(stat.st_blocks, 0)
def test_supported(self): with namedTemporaryDir() as tmpdir: # Prepare backing file poisoned with "x" backing_file = os.path.join(tmpdir, "backing_file") with io.open(backing_file, "wb") as f: f.write(b"x" * SIZE) # Create a loop device with loopback.Device(backing_file) as loop_device: # And discard it blockdev.discard(loop_device.path) stat = os.stat(backing_file) self.assertEqual(stat.st_blocks, 0)
def test_supported(self, loop_device): # Write some data to the device. with directio.open(loop_device.path, "r+") as f: f.write(DATA) f.seek(FILE_SIZE - len(DATA)) f.write(DATA) # Discard entire device. blockdev.discard(loop_device.path) # Check that all data was discarded. stat = os.stat(loop_device.backing_file) assert stat.st_blocks == 0
def test_not_supported(self, tmpdir): # Prepare file poisoned with "x" path = str(tmpdir.join("backing_file")) with io.open(path, "wb") as f: f.write(DATA) # And discard it - this will fail silently. blockdev.discard(path) # File should not be modified with io.open(path, "rb") as f: data = f.read(len(DATA)) assert data == DATA
def test_supported(self, loop_device): # Write some data to the device. with directio.open(loop_device.path, "r+") as f: f.write(DATA) f.seek(FILE_SIZE - len(DATA)) f.write(DATA) # Discard entire device. blockdev.discard(loop_device.path) # Check that all data was discarded. stat = os.stat(loop_device.backing_file) assert stat.st_blocks == 0
def test_not_supported(self, tmpdir): # Prepare file poisoned with "x" path = str(tmpdir.join("backing_file")) with io.open(path, "wb") as f: f.write(DATA) # And discard it - this will fail silently. blockdev.discard(path) # File should not be modified with io.open(path, "rb") as f: data = f.read(len(DATA)) assert data == DATA
def test_supported(self, loop_device): # If the loop device backing file is on a file system that does not # support discard, discard is not supported. cp = subprocess.run( ["blkdiscard", loop_device.path], stderr=subprocess.PIPE) if cp.returncode != 0: pytest.skip("blkdiscard not supported: %s" % cp.stderr) # Write some data to the device. with directio.open(loop_device.path, "r+") as f: f.write(DATA) f.seek(FILE_SIZE - len(DATA)) f.write(DATA) # Discard entire device. blockdev.discard(loop_device.path) # Check that all data was discarded. stat = os.stat(loop_device.backing_file) assert stat.st_blocks == 0
def delete(self, postZero, force, discard): """ Delete volume 'postZero' - zeroing file before deletion 'force' is required to remove shared and internal volumes 'discard' - discard lv before deletion """ self.log.info("Request to delete LV %s of image %s in VG %s ", self.volUUID, self.imgUUID, self.sdUUID) vol_path = self.getVolumePath() # On block storage domains we store a volume's parent UUID in two # places: 1) in the domain's metadata LV, and 2) in a LV tag attached # to the volume LV itself. The LV tag is more efficient to access # than the domain metadata but it may only be updated by the SPM. # # This means that after a live merge completes the domain metadata LV # will be updated but the LV tag will not. We can detect this case # here and fix the LV tag since this is an SPM verb. # # File domains do not have this complexity because the metadata is # stored in only one place and that metadata is updated by the HSM # host when the live merge finishes. sync = False for childID in self.getChildren(): child = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, childID) metaParent = child.getParentMeta() tagParent = child.getParentTag() if metaParent != tagParent: self.log.debug( "Updating stale PUUID LV tag from %s to %s for " "volume %s", tagParent, metaParent, child.volUUID) child.setParentTag(metaParent) sync = True if sync: self.recheckIfLeaf() if not force: self.validateDelete() # Mark volume as illegal before deleting self.setLegality(sc.ILLEGAL_VOL) if postZero or discard: self.prepare(justme=True, rw=True, chainrw=force, setrw=True, force=True) try: if postZero: blockdev.zero(vol_path, task=vars.task) if discard: blockdev.discard(vol_path) finally: self.teardown(self.sdUUID, self.volUUID, justme=True) # try to cleanup as much as possible eFound = se.CannotDeleteVolume(self.volUUID) puuid = None try: # We need to blank parent record in our metadata # for parent to become leaf successfully. puuid = self.getParent() self.setParent(sc.BLANK_UUID) if puuid and puuid != sc.BLANK_UUID: pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, puuid) pvol.recheckIfLeaf() except Exception as e: eFound = e self.log.warning("cannot finalize parent volume %s", puuid, exc_info=True) # Basically, we want to mark the volume _remove_me at the beginning of # the delete; however, with the current delete logic, if marking the # volume fails, and the deleted volume is a leaf, we end up with a # chain with a valid leaf volume. # The ultimate solution of volume deletion requires changes in # image.syncVolumeChain to disconnect the volume from the chain, # and probably there mark it as _remove_me. manifest = sdCache.produce_manifest(self.sdUUID) manifest.markForDelVols(self.sdUUID, self.imgUUID, [self.volUUID], sc.REMOVED_IMAGE_PREFIX) try: lvm.removeLVs(self.sdUUID, (self.volUUID, )) except se.CannotRemoveLogicalVolume as e: self.log.exception( "Failed to delete volume %s/%s. The " "logical volume must be removed manually.", self.sdUUID, self.volUUID) try: self.log.info("Unlinking %s", vol_path) os.unlink(vol_path) return True except Exception as e: eFound = e self.log.error("cannot delete volume's %s/%s link path: %s", self.sdUUID, self.volUUID, vol_path, exc_info=True) raise eFound
def test_supported(self, loop_device): blockdev.discard(loop_device.path) stat = os.stat(loop_device.backing_file) assert stat.st_blocks == 0
def delete(self, postZero, force, discard): """ Delete volume 'postZero' - zeroing file before deletion 'force' is required to remove shared and internal volumes 'discard' - discard lv before deletion """ self.log.info("Request to delete LV %s of image %s in VG %s ", self.volUUID, self.imgUUID, self.sdUUID) vol_path = self.getVolumePath() offs = self.getMetaOffset() # On block storage domains we store a volume's parent UUID in two # places: 1) in the domain's metadata LV, and 2) in a LV tag attached # to the volume LV itself. The LV tag is more efficient to access # than the domain metadata but it may only be updated by the SPM. # # This means that after a live merge completes the domain metadata LV # will be updated but the LV tag will not. We can detect this case # here and fix the LV tag since this is an SPM verb. # # File domains do not have this complexity because the metadata is # stored in only one place and that metadata is updated by the HSM # host when the live merge finishes. sync = False for childID in self.getChildren(): child = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, childID) metaParent = child.getParentMeta() tagParent = child.getParentTag() if metaParent != tagParent: self.log.debug("Updating stale PUUID LV tag from %s to %s for " "volume %s", tagParent, metaParent, child.volUUID) child.setParentTag(metaParent) sync = True if sync: self.recheckIfLeaf() if not force: self.validateDelete() # Mark volume as illegal before deleting self.setLegality(sc.ILLEGAL_VOL) if postZero or discard: self.prepare(justme=True, rw=True, chainrw=force, setrw=True, force=True) try: if postZero: blockdev.zero(vol_path, task=vars.task) if discard: blockdev.discard(vol_path) finally: self.teardown(self.sdUUID, self.volUUID, justme=True) # try to cleanup as much as possible eFound = se.CannotDeleteVolume(self.volUUID) puuid = None try: # We need to blank parent record in our metadata # for parent to become leaf successfully. puuid = self.getParent() self.setParent(sc.BLANK_UUID) if puuid and puuid != sc.BLANK_UUID: pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, puuid) pvol.recheckIfLeaf() except Exception as e: eFound = e self.log.warning("cannot finalize parent volume %s", puuid, exc_info=True) try: try: lvm.removeLVs(self.sdUUID, self.volUUID) except se.CannotRemoveLogicalVolume: # At this point LV is already marked as illegal, we will # try to cleanup whatever we can... pass self.removeMetadata([self.sdUUID, offs]) except Exception as e: eFound = e self.log.error("cannot remove volume %s/%s", self.sdUUID, self.volUUID, exc_info=True) try: self.log.debug("Unlinking %s", vol_path) os.unlink(vol_path) return True except Exception as e: eFound = e self.log.error("cannot delete volume's %s/%s link path: %s", self.sdUUID, self.volUUID, vol_path, exc_info=True) raise eFound
def delete(self, postZero, force, discard): """ Delete volume 'postZero' - zeroing file before deletion 'force' is required to remove shared and internal volumes 'discard' - discard lv before deletion """ self.log.info("Request to delete LV %s of image %s in VG %s ", self.volUUID, self.imgUUID, self.sdUUID) vol_path = self.getVolumePath() slot = self.getMetaSlot() # On block storage domains we store a volume's parent UUID in two # places: 1) in the domain's metadata LV, and 2) in a LV tag attached # to the volume LV itself. The LV tag is more efficient to access # than the domain metadata but it may only be updated by the SPM. # # This means that after a live merge completes the domain metadata LV # will be updated but the LV tag will not. We can detect this case # here and fix the LV tag since this is an SPM verb. # # File domains do not have this complexity because the metadata is # stored in only one place and that metadata is updated by the HSM # host when the live merge finishes. sync = False for childID in self.getChildren(): child = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, childID) metaParent = child.getParentMeta() tagParent = child.getParentTag() if metaParent != tagParent: self.log.debug("Updating stale PUUID LV tag from %s to %s for " "volume %s", tagParent, metaParent, child.volUUID) child.setParentTag(metaParent) sync = True if sync: self.recheckIfLeaf() if not force: self.validateDelete() # Mark volume as illegal before deleting self.setLegality(sc.ILLEGAL_VOL) if postZero or discard: self.prepare(justme=True, rw=True, chainrw=force, setrw=True, force=True) try: if postZero: blockdev.zero(vol_path, task=vars.task) if discard: blockdev.discard(vol_path) finally: self.teardown(self.sdUUID, self.volUUID, justme=True) # try to cleanup as much as possible eFound = se.CannotDeleteVolume(self.volUUID) puuid = None try: # We need to blank parent record in our metadata # for parent to become leaf successfully. puuid = self.getParent() self.setParent(sc.BLANK_UUID) if puuid and puuid != sc.BLANK_UUID: pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, puuid) pvol.recheckIfLeaf() except Exception as e: eFound = e self.log.warning("cannot finalize parent volume %s", puuid, exc_info=True) # Basically, we want to mark the volume _remove_me at the beginning of # the delete; however, with the current delete logic, if marking the # volume fails, and the deleted volume is a leaf, we end up with a # chain with a valid leaf volume. # The ultimate solution of volume deletion requires changes in # image.syncVolumeChain to disconnect the volume from the chain, # and probably there mark it as _remove_me. manifest = sdCache.produce_manifest(self.sdUUID) manifest.markForDelVols(self.sdUUID, self.imgUUID, [self.volUUID], sc.REMOVED_IMAGE_PREFIX) try: lvm.removeLVs(self.sdUUID, self.volUUID) except se.CannotRemoveLogicalVolume as e: self.log.exception("Failed to delete volume %s/%s. The " "logical volume must be removed manually.", self.sdUUID, self.volUUID) else: # If removing the LV fails, we don't want to remove the # metadata. As the volume still exists on the storage, and is # accessible, removing the metadata will cause unexpected # errors when accessing the metadata that was wiped. This is a # minimal solution for: https://bugzilla.redhat.com/1574631 try: self.removeMetadata([self.sdUUID, slot]) except se.VolumeMetadataWriteError as e: eFound = e self.log.exception("Failed to delete volume %s/%s metadata.", self.sdUUID, self.volUUID) try: self.log.info("Unlinking %s", vol_path) os.unlink(vol_path) return True except Exception as e: eFound = e self.log.error("cannot delete volume's %s/%s link path: %s", self.sdUUID, self.volUUID, vol_path, exc_info=True) raise eFound
def test_supported(self, loop_device): blockdev.discard(loop_device.path) stat = os.stat(loop_device.backing_file) assert stat.st_blocks == 0
def delete(self, postZero, force, discard): """ Delete volume 'postZero' - zeroing file before deletion 'force' is required to remove shared and internal volumes 'discard' - discard lv before deletion """ self.log.info("Request to delete LV %s of image %s in VG %s ", self.volUUID, self.imgUUID, self.sdUUID) vol_path = self.getVolumePath() offs = self.getMetaOffset() # On block storage domains we store a volume's parent UUID in two # places: 1) in the domain's metadata LV, and 2) in a LV tag attached # to the volume LV itself. The LV tag is more efficient to access # than the domain metadata but it may only be updated by the SPM. # # This means that after a live merge completes the domain metadata LV # will be updated but the LV tag will not. We can detect this case # here and fix the LV tag since this is an SPM verb. # # File domains do not have this complexity because the metadata is # stored in only one place and that metadata is updated by the HSM # host when the live merge finishes. sync = False for childID in self.getChildren(): child = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, childID) metaParent = child.getParentMeta() tagParent = child.getParentTag() if metaParent != tagParent: self.log.debug("Updating stale PUUID LV tag from %s to %s for " "volume %s", tagParent, metaParent, child.volUUID) child.setParentTag(metaParent) sync = True if sync: self.recheckIfLeaf() if not force: self.validateDelete() # Mark volume as illegal before deleting self.setLegality(sc.ILLEGAL_VOL) discard_needed = discard or blockdev.discard_enabled() if postZero or discard_needed: self.prepare(justme=True, rw=True, chainrw=force, setrw=True, force=True) try: if postZero: blockdev.zero(vol_path, task=vars.task) if discard_needed: blockdev.discard(vol_path) finally: self.teardown(self.sdUUID, self.volUUID, justme=True) # try to cleanup as much as possible eFound = se.CannotDeleteVolume(self.volUUID) puuid = None try: # We need to blank parent record in our metadata # for parent to become leaf successfully. puuid = self.getParent() self.setParent(sc.BLANK_UUID) if puuid and puuid != sc.BLANK_UUID: pvol = BlockVolume(self.repoPath, self.sdUUID, self.imgUUID, puuid) pvol.recheckIfLeaf() except Exception as e: eFound = e self.log.warning("cannot finalize parent volume %s", puuid, exc_info=True) try: try: lvm.removeLVs(self.sdUUID, self.volUUID) except se.CannotRemoveLogicalVolume: # At this point LV is already marked as illegal, we will # try to cleanup whatever we can... pass self.removeMetadata([self.sdUUID, offs]) except Exception as e: eFound = e self.log.error("cannot remove volume %s/%s", self.sdUUID, self.volUUID, exc_info=True) try: self.log.debug("Unlinking %s", vol_path) os.unlink(vol_path) return True except Exception as e: eFound = e self.log.error("cannot delete volume's %s/%s link path: %s", self.sdUUID, self.volUUID, vol_path, exc_info=True) raise eFound