def zero(device_path, size=None, task=_NullTask()):
"""
Zero a block device.
Arguments:
device_path (str): Path to block device to wipe
size (int): Number of bytes to write. If not specified, use the device
size. Size must be aligned to `vdsm.storage.constants.BLOCK_SIZE`.
task (`storage.task.Task`): Task running this operation. If specified,
the zero operation will be aborted if the task is aborted.
Raises:
`vdsm.common.exception.ActionStopped` if the wipe was aborted
`vdsm.storage.exception.VolumesZeroingError` if writing to storage
failed.
`vdsm.storage.exception.InvalidParameterException` if size is not
aligned to `vdsm.storage.constants.BLOCK_SIZE`.
"""
if size is None:
# Always aligned to LVM extent size (128MiB).
size = fsutils.size(device_path)
elif size % sc.BLOCK_SIZE:
raise se.InvalidParameterException("size", size)
log.info("Zeroing device %s (size=%d)", device_path, size)
with utils.stopwatch("Zero device %s" % device_path,
level=logging.INFO, log=log):
try:
op = blkdiscard.zeroout_operation(device_path, size)
with task.abort_callback(op.abort):
op.run()
except se.StorageException as e:
raise se.VolumesZeroingError("Zeroing device %s failed: %s"
% (device_path, e))
def zero(device_path, size=None, task=_NullTask()):
"""
Zero a block device.
Arguments:
device_path (str): Path to block device to wipe
size (int): Number of bytes to write. If not specified, use the device
size. Size must be aligned to `vdsm.storage.constants.BLOCK_SIZE`.
task (`storage.task.Task`): Task running this operation. If specified,
the zero operation will be aborted if the task is aborted.
Raises:
`vdsm.common.exception.ActionStopped` if the wipe was aborted
`vdsm.storage.exception.VolumesZeroingError` if writing to storage
failed.
`vdsm.storage.exception.InvalidParameterException` if size is not
aligned to `vdsm.storage.constants.BLOCK_SIZE`.
"""
if size is None:
# Always aligned to LVM extent size (128MiB).
size = fsutils.size(device_path)
elif size % sc.BLOCK_SIZE:
raise se.InvalidParameterException("size", size)
log.info("Zeroing device %s (size=%d)", device_path, size)
with utils.stopwatch("Zero device %s" % device_path,
level=logging.INFO,
log=log):
try:
op = blkdiscard.zeroout_operation(device_path, size)
with task.abort_callback(op.abort):
op.run()
except se.StorageException as e:
raise se.VolumesZeroingError("Zeroing device %s failed: %s" %
(device_path, e))
def zero(device_path, size=None, task=None):
"""
Zero a block device.
Arguments:
device_path (str): Path to block device to wipe
size (int): Number of bytes to write. If not specified, use the device
size. Size must be aligned to `vdsm.storage.constants.BLOCK_SIZE`.
task (`storage.task.Task`): Task running this operation. If specified,
the zero operation will be aborted if the task is aborted.
Raises:
`vdsm.common.exception.ActionStopped` if the wipe was aborted
`vdsm.storage.exception.VolumesZeroingError` if writing to storage
failed.
`vdsm.storage.exception.InvalidParameterException` if size is not
aligned to `vdsm.storage.constants.BLOCK_SIZE`.
"""
if size is None:
# Always aligned to LVM extent size (128MiB).
size = fsutils.size(device_path)
elif size % sc.BLOCK_SIZE:
raise se.InvalidParameterException("size", size)
log.info("Zeroing device %s (size=%d)", device_path, size)
with utils.stopwatch("Zero device %s" % device_path,
level=logging.INFO,
log=log):
try:
# Write optimal size blocks. Images are always aligned to
# optimal size blocks, so we typically have only one call.
blocks = size // OPTIMAL_BLOCK_SIZE
if blocks > 0:
_zero(device_path, 0, OPTIMAL_BLOCK_SIZE, blocks, task=task)
# When zeroing special volumes size may not be aligned to
# optimal block size, so we need to write the last block.
rest = size % OPTIMAL_BLOCK_SIZE
if rest > 0:
offset = blocks * OPTIMAL_BLOCK_SIZE
_zero(device_path, offset, rest, 1, task=task)
except se.StorageException as e:
raise se.VolumesZeroingError("Zeroing device %s failed: %s" %
(device_path, e))
def zero(device_path, size=None, task=None):
"""
Zero a block device.
Arguments:
device_path (str): Path to block device to wipe
size (int): Number of bytes to write. If not specified, use the device
size. Size must be aligned to `vdsm.storage.constants.BLOCK_SIZE`.
task (`storage.task.Task`): Task running this operation. If specified,
the zero operation will be aborted if the task is aborted.
Raises:
`vdsm.common.exception.ActionStopped` if the wipe was aborted
`vdsm.storage.exception.VolumesZeroingError` if writing to storage
failed.
`vdsm.storage.exception.InvalidParameterException` if size is not
aligned to `vdsm.storage.constants.BLOCK_SIZE`.
"""
if size is None:
# Always aligned to LVM extent size (128MiB).
size = fsutils.size(device_path)
elif size % sc.BLOCK_SIZE:
raise se.InvalidParameterException("size", size)
log.info("Zeroing device %s (size=%d)", device_path, size)
with utils.stopwatch("Zero device %s" % device_path,
level=logging.INFO, log=log):
try:
# Write optimal size blocks. Images are always aligned to
# optimal size blocks, so we typically have only one call.
blocks = size // OPTIMAL_BLOCK_SIZE
if blocks > 0:
_zero(device_path, 0, OPTIMAL_BLOCK_SIZE, blocks, task=task)
# When zeroing special volumes size may not be aligned to
# optimal block size, so we need to write the last block.
rest = size % OPTIMAL_BLOCK_SIZE
if rest > 0:
offset = blocks * OPTIMAL_BLOCK_SIZE
_zero(device_path, offset, rest, 1, task=task)
except se.StorageException as e:
raise se.VolumesZeroingError("Zeroing device %s failed: %s"
% (device_path, e))
def zero(device_path, size=None, task=_NullTask()):
"""
Zero a block device.
Arguments:
device_path (str): Path to block device to wipe
size (int): Number of bytes to write. If not specified, use the device
size. Size must be aligned to `vdsm.storage.constants.BLOCK_SIZE`.
task (`storage.task.Task`): Task running this operation. If specified,
the zero operation will be aborted if the task is aborted.
Raises:
`vdsm.common.exception.ActionStopped` if the wipe was aborted
`vdsm.storage.exception.VolumesZeroingError` if writing to storage
failed.
`vdsm.storage.exception.InvalidParameterException` if size is not
aligned to `vdsm.storage.constants.BLOCK_SIZE`.
"""
if size is None:
# Always aligned to LVM extent size (128MiB).
size = fsutils.size(device_path)
elif size % sc.BLOCK_SIZE:
raise se.InvalidParameterException("size", size)
log.info("Zeroing device %s (size=%d)", device_path, size)
with utils.stopwatch("Zero device %s" % device_path,
level=logging.INFO,
log=log):
zero_method = config.get('irs', 'zero_method')
try:
if zero_method == "blkdiscard":
_zero_blkdiscard(device_path, size, task)
elif zero_method == "dd":
_zero_dd(device_path, size, task)
else:
raise exception.InvalidConfiguration(
reason="Unsupported value for irs:zero_method",
zero_method=zero_method)
except se.StorageException as e:
raise se.VolumesZeroingError("Zeroing device %s failed: %s" %
(device_path, e))
def zero(device_path, size=None, task=_NullTask()):
"""
Zero a block device.
Arguments:
device_path (str): Path to block device to wipe
size (int): Number of bytes to write. If not specified, use the device
size. Size must be aligned to `vdsm.storage.constants.BLOCK_SIZE`.
task (`storage.task.Task`): Task running this operation. If specified,
the zero operation will be aborted if the task is aborted.
Raises:
`vdsm.common.exception.ActionStopped` if the wipe was aborted
`vdsm.storage.exception.VolumesZeroingError` if writing to storage
failed.
`vdsm.storage.exception.InvalidParameterException` if size is not
aligned to `vdsm.storage.constants.BLOCK_SIZE`.
"""
if size is None:
# Always aligned to LVM extent size (128MiB).
size = fsutils.size(device_path)
elif size % sc.BLOCK_SIZE:
raise se.InvalidParameterException("size", size)
log.info("Zeroing device %s (size=%d)", device_path, size)
with utils.stopwatch("Zero device %s" % device_path,
level=logging.INFO, log=log):
zero_method = config.get('irs', 'zero_method')
try:
if zero_method == "blkdiscard":
_zero_blkdiscard(device_path, size, task)
elif zero_method == "dd":
_zero_dd(device_path, size, task)
else:
raise exception.InvalidConfiguration(
reason="Unsupported value for irs:zero_method",
zero_method=zero_method)
except se.StorageException as e:
raise se.VolumesZeroingError("Zeroing device %s failed: %s"
% (device_path, e))
def size(self):
return fsutils.size(self._path)
def size(self):
return fsutils.size(self._path)
