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
