common/dmerror - external/git.kernel.org/fs/xfs/xfstests-dev - Git at Google

 ##/bin/bash
 # SPDX-License-Identifier: GPL-2.0
 # Copyright (c) 2015 Oracle.  All Rights Reserved.
 #
 # common functions for setting up and tearing down a dmerror device

 _dmerror_setup_vars()
 {
 	local backing_dev="$1"
 	local tag="$2"
 	local target="$3"

 	test -z "$target" && target=error
 	local blk_dev_size=$(blockdev --getsz "$backing_dev")

 	eval export "DMLINEAR_${tag}TABLE=\"0 $blk_dev_size linear $backing_dev 0\""
 	eval export "DMERROR_${tag}TABLE=\"0 $blk_dev_size $target $backing_dev 0\""
 }

 _dmerror_setup()
 {
 	local rt_target=
 	local log_target=

 	for arg in "$@"; do
 		case "${arg}" in
 		no_rt)		rt_target=linear;;
 		no_log)		log_target=linear;;
 		*)		echo "${arg}: Unknown _dmerror_setup arg.";;
 		esac
 	done

 	# Scratch device
 	export DMERROR_DEV='/dev/mapper/error-test'
 	_dmerror_setup_vars $SCRATCH_DEV

 	# Realtime device.  We reassign SCRATCH_RTDEV so that all the scratch
 	# helpers continue to work unmodified.
 	if [ -n "$SCRATCH_RTDEV" ]; then
 		if [ -z "$NON_ERROR_RTDEV" ]; then
 			# Set up the device switch
 			local dm_backing_dev=$SCRATCH_RTDEV
 			export NON_ERROR_RTDEV="$SCRATCH_RTDEV"
 			SCRATCH_RTDEV='/dev/mapper/error-rttest'
 		else
 			# Already set up; recreate tables
 			local dm_backing_dev="$NON_ERROR_RTDEV"
 		fi

 		_dmerror_setup_vars $dm_backing_dev RT $rt_target
 	fi

 	# External log device.  We reassign SCRATCH_LOGDEV so that all the
 	# scratch helpers continue to work unmodified.
 	if [ -n "$SCRATCH_LOGDEV" ]; then
 		if [ -z "$NON_ERROR_LOGDEV" ]; then
 			# Set up the device switch
 			local dm_backing_dev=$SCRATCH_LOGDEV
 			export NON_ERROR_LOGDEV="$SCRATCH_LOGDEV"
 			SCRATCH_LOGDEV='/dev/mapper/error-logtest'
 		else
 			# Already set up; recreate tables
 			local dm_backing_dev="$NON_ERROR_LOGDEV"
 		fi

 		_dmerror_setup_vars $dm_backing_dev LOG $log_target
 	fi
 }

 _dmerror_init()
 {
 	_dmerror_setup "$@"

 	_dmsetup_remove error-test
 	_dmsetup_create error-test --table "$DMLINEAR_TABLE" || \
 		_fatal "failed to create dm linear device"

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		_dmsetup_remove error-rttest
 		_dmsetup_create error-rttest --table "$DMLINEAR_RTTABLE" || \
 			_fatal "failed to create dm linear rt device"
 	fi

 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		_dmsetup_remove error-logtest
 		_dmsetup_create error-logtest --table "$DMLINEAR_LOGTABLE" || \
 			_fatal "failed to create dm linear log device"
 	fi
 }

 _dmerror_mount()
 {
 	_scratch_options mount
 	$MOUNT_PROG -t $FSTYP `_common_dev_mount_options $*` $SCRATCH_OPTIONS \
 		$DMERROR_DEV $SCRATCH_MNT
 }

 _dmerror_unmount()
 {
 	umount $SCRATCH_MNT
 }

 _dmerror_cleanup()
 {
 	test -n "$NON_ERROR_LOGDEV" && $DMSETUP_PROG resume error-logtest &>/dev/null
 	test -n "$NON_ERROR_RTDEV" && $DMSETUP_PROG resume error-rttest &>/dev/null
 	$DMSETUP_PROG resume error-test > /dev/null 2>&1

 	$UMOUNT_PROG $SCRATCH_MNT > /dev/null 2>&1

 	test -n "$NON_ERROR_LOGDEV" && _dmsetup_remove error-logtest
 	test -n "$NON_ERROR_RTDEV" && _dmsetup_remove error-rttest
 	_dmsetup_remove error-test

 	unset DMERROR_DEV DMLINEAR_TABLE DMERROR_TABLE

 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		SCRATCH_LOGDEV="$NON_ERROR_LOGDEV"
 		unset NON_ERROR_LOGDEV DMLINEAR_LOGTABLE DMERROR_LOGTABLE
 	fi

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		SCRATCH_RTDEV="$NON_ERROR_RTDEV"
 		unset NON_ERROR_RTDEV DMLINEAR_RTTABLE DMERROR_RTTABLE
 	fi
 }

 _dmerror_load_error_table()
 {
 	local load_res=0
 	local resume_res=0

 	suspend_opt="--nolockfs"

 	if [ "$1" = "lockfs" ]; then
 		suspend_opt=""
 	elif [ -n "$*" ]; then
 		suspend_opt="$*"
 	fi

 	# If the full environment is set up, configure ourselves for shutdown
 	type _prepare_for_eio_shutdown &>/dev/null && \
 		_prepare_for_eio_shutdown $DMERROR_DEV

 	# Suspend the scratch device before the log and realtime devices so
 	# that the kernel can freeze and flush the filesystem if the caller
 	# wanted a freeze.
 	$DMSETUP_PROG suspend $suspend_opt error-test
 	[ $? -ne 0 ] && _fail  "dmsetup suspend failed"

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		$DMSETUP_PROG suspend $suspend_opt error-rttest
 		[ $? -ne 0 ] && _fail "failed to suspend error-rttest"
 	fi

 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		$DMSETUP_PROG suspend $suspend_opt error-logtest
 		[ $? -ne 0 ] && _fail "failed to suspend error-logtest"
 	fi

 	# Load new table
 	$DMSETUP_PROG load error-test --table "$DMERROR_TABLE"
 	load_res=$?

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		$DMSETUP_PROG load error-rttest --table "$DMERROR_RTTABLE"
 		[ $? -ne 0 ] && _fail "failed to load error table into error-rttest"
 	fi

 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		$DMSETUP_PROG load error-logtest --table "$DMERROR_LOGTABLE"
 		[ $? -ne 0 ] && _fail "failed to load error table into error-logtest"
 	fi

 	# Resume devices in the opposite order that we suspended them.
 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		$DMSETUP_PROG resume error-logtest
 		[ $? -ne 0 ] && _fail  "failed to resume error-logtest"
 	fi

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		$DMSETUP_PROG resume error-rttest
 		[ $? -ne 0 ] && _fail  "failed to resume error-rttest"
 	fi

 	$DMSETUP_PROG resume error-test
 	resume_res=$?

 	[ $load_res -ne 0 ] && _fail "dmsetup failed to load error table"
 	[ $resume_res -ne 0 ] && _fail  "dmsetup resume failed"
 }

 _dmerror_load_working_table()
 {
 	local load_res=0
 	local resume_res=0

 	suspend_opt="--nolockfs"

 	if [ "$1" = "lockfs" ]; then
 		suspend_opt=""
 	elif [ -n "$*" ]; then
 		suspend_opt="$*"
 	fi

 	# Suspend the scratch device before the log and realtime devices so
 	# that the kernel can freeze and flush the filesystem if the caller
 	# wanted a freeze.
 	$DMSETUP_PROG suspend $suspend_opt error-test
 	[ $? -ne 0 ] && _fail  "dmsetup suspend failed"

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		$DMSETUP_PROG suspend $suspend_opt error-rttest
 		[ $? -ne 0 ] && _fail "failed to suspend error-rttest"
 	fi

 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		$DMSETUP_PROG suspend $suspend_opt error-logtest
 		[ $? -ne 0 ] && _fail "failed to suspend error-logtest"
 	fi

 	# Load new table
 	$DMSETUP_PROG load error-test --table "$DMLINEAR_TABLE"
 	load_res=$?

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		$DMSETUP_PROG load error-rttest --table "$DMLINEAR_RTTABLE"
 		[ $? -ne 0 ] && _fail "failed to load working table into error-rttest"
 	fi

 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		$DMSETUP_PROG load error-logtest --table "$DMLINEAR_LOGTABLE"
 		[ $? -ne 0 ] && _fail "failed to load working table into error-logtest"
 	fi

 	# Resume devices in the opposite order that we suspended them.
 	if [ -n "$NON_ERROR_LOGDEV" ]; then
 		$DMSETUP_PROG resume error-logtest
 		[ $? -ne 0 ] && _fail  "failed to resume error-logtest"
 	fi

 	if [ -n "$NON_ERROR_RTDEV" ]; then
 		$DMSETUP_PROG resume error-rttest
 		[ $? -ne 0 ] && _fail  "failed to resume error-rttest"
 	fi

 	$DMSETUP_PROG resume error-test
 	resume_res=$?

 	[ $load_res -ne 0 ] && _fail "dmsetup failed to load error table"
 	[ $resume_res -ne 0 ] && _fail  "dmsetup resume failed"
 }

 # Given a list of (start, length) tuples on stdin, combine adjacent tuples into
 # larger ones and write the new list to stdout.
 __dmerror_combine_extents()
 {
 	local awk_program='
 	BEGIN {
 		start = 0; len = 0;
 	}
 	{
 		if (start + len == $1) {
 			len += $2;
 		} else {
 			if (len > 0)
 				printf("%d %d\n", start, len);
 			start = $1;
 			len = $2;
 		}
 	}
 	END {
 		if (len > 0)
 			printf("%d %d\n", start, len);
 	}'

 	awk "$awk_program"
 }

 # Given a block device, the name of a preferred dm target, the name of an
 # implied dm target, and a list of (start, len) tuples on stdin, create a new
 # dm table which maps each of the tuples to the preferred target and all other
 # areas to the implied dm target.
 __dmerror_recreate_map()
 {
 	local device="$1"
 	local preferred_tgt="$2"
 	local implied_tgt="$3"
 	local size=$(blockdev --getsz "$device")

 	local awk_program='
 	BEGIN {
 		implied_start = 0;
 	}
 	{
 		extent_start = $1;
 		extent_len = $2;

 		if (extent_start > size) {
 			extent_start = size;
 			extent_len = 0;
 		} else if (extent_start + extent_len > size) {
 			extent_len = size - extent_start;
 		}

 		if (implied_start < extent_start)
 			printf("%d %d %s %s %d\n", implied_start,
 					extent_start - implied_start,
 					implied_tgt, device, implied_start);
 		printf("%d %d %s %s %d\n", extent_start, extent_len,
 				preferred_tgt, device, extent_start);
 		implied_start = extent_start + extent_len;
 	}
 	END {
 		if (implied_start < size)
 			printf("%d %d %s %s %d\n", implied_start,
 					size - implied_start, implied_tgt,
 					device, implied_start);
 	}'

 	awk -v device="$device" -v size=$size -v implied_tgt="$implied_tgt" \
 		-v preferred_tgt="$preferred_tgt" "$awk_program"
 }

 # Update the dm error table so that the range (start, len) maps to the
 # preferred dm target, overriding anything that maps to the implied dm target.
 # This assumes that the only desired targets for this dm device are the
 # preferred and and implied targets.  The fifth argument is the scratch device
 # that we want to change the table for.
 __dmerror_change()
 {
 	local start="$1"
 	local len="$2"
 	local preferred_tgt="$3"
 	local implied_tgt="$4"
 	local whichdev="$5"
 	local old_table
 	local new_table

 	case "$whichdev" in
 	"SCRATCH_DEV"|"")	whichdev="$SCRATCH_DEV";;
 	"SCRATCH_LOGDEV"|"LOG")	whichdev="$NON_ERROR_LOGDEV";;
 	"SCRATCH_RTDEV"|"RT")	whichdev="$NON_ERROR_RTDEV";;
 	esac

 	case "$whichdev" in
 	"$SCRATCH_DEV")		old_table="$DMERROR_TABLE";;
 	"$NON_ERROR_LOGDEV")	old_table="$DMERROR_LOGTABLE";;
 	"$NON_ERROR_RTDEV")	old_table="$DMERROR_RTTABLE";;
 	*)
 		echo "$whichdev: Unknown dmerror device."
 		return
 		;;
 	esac

 	new_table="$( (echo "$old_table"; echo "$start $len $preferred_tgt") | \
 		awk -v type="$preferred_tgt" '{if ($3 == type) print $0;}' | \
 		sort -g | \
 		__dmerror_combine_extents | \
 		__dmerror_recreate_map "$whichdev" "$preferred_tgt" \
 				"$implied_tgt" )"

 	case "$whichdev" in
 	"$SCRATCH_DEV")		DMERROR_TABLE="$new_table";;
 	"$NON_ERROR_LOGDEV")	DMERROR_LOGTABLE="$new_table";;
 	"$NON_ERROR_RTDEV")	DMERROR_RTTABLE="$new_table";;
 	esac
 }

 # Reset the dm error table to everything ok.  The dm device itself must be
 # remapped by calling _dmerror_load_error_table.
 _dmerror_reset_table()
 {
 	DMERROR_TABLE="$DMLINEAR_TABLE"
 	DMERROR_LOGTABLE="$DMLINEAR_LOGTABLE"
 	DMERROR_RTTABLE="$DMLINEAR_RTTABLE"
 }

 # Update the dm error table so that IOs to the given range will return EIO.
 # The dm device itself must be remapped by calling _dmerror_load_error_table.
 _dmerror_mark_range_bad()
 {
 	local start="$1"
 	local len="$2"
 	local dev="$3"

 	__dmerror_change "$start" "$len" error linear "$dev"
 }

 # Update the dm error table so that IOs to the given range will succeed.
 # The dm device itself must be remapped by calling _dmerror_load_error_table.
 _dmerror_mark_range_good()
 {
 	local start="$1"
 	local len="$2"
 	local dev="$3"

 	__dmerror_change "$start" "$len" linear error "$dev"
 }
	##/bin/bash
	# SPDX-License-Identifier: GPL-2.0
	# Copyright (c) 2015 Oracle. All Rights Reserved.
	#
	# common functions for setting up and tearing down a dmerror device

	_dmerror_setup_vars()
	{
	local backing_dev="$1"
	local tag="$2"
	local target="$3"

	test -z "$target" && target=error
	local blk_dev_size=$(blockdev --getsz "$backing_dev")

	eval export "DMLINEAR_${tag}TABLE=\"0 $blk_dev_size linear $backing_dev 0\""
	eval export "DMERROR_${tag}TABLE=\"0 $blk_dev_size $target $backing_dev 0\""
	}

	_dmerror_setup()
	{
	local rt_target=
	local log_target=

	for arg in "$@"; do
	case "${arg}" in
	no_rt) rt_target=linear;;
	no_log) log_target=linear;;
	*) echo "${arg}: Unknown _dmerror_setup arg.";;
	esac
	done

	# Scratch device
	export DMERROR_DEV='/dev/mapper/error-test'
	_dmerror_setup_vars $SCRATCH_DEV

	# Realtime device. We reassign SCRATCH_RTDEV so that all the scratch
	# helpers continue to work unmodified.
	if [ -n "$SCRATCH_RTDEV" ]; then
	if [ -z "$NON_ERROR_RTDEV" ]; then
	# Set up the device switch
	local dm_backing_dev=$SCRATCH_RTDEV
	export NON_ERROR_RTDEV="$SCRATCH_RTDEV"
	SCRATCH_RTDEV='/dev/mapper/error-rttest'
	else
	# Already set up; recreate tables
	local dm_backing_dev="$NON_ERROR_RTDEV"
	fi

	_dmerror_setup_vars $dm_backing_dev RT $rt_target
	fi

	# External log device. We reassign SCRATCH_LOGDEV so that all the
	# scratch helpers continue to work unmodified.
	if [ -n "$SCRATCH_LOGDEV" ]; then
	if [ -z "$NON_ERROR_LOGDEV" ]; then
	# Set up the device switch
	local dm_backing_dev=$SCRATCH_LOGDEV
	export NON_ERROR_LOGDEV="$SCRATCH_LOGDEV"
	SCRATCH_LOGDEV='/dev/mapper/error-logtest'
	else
	# Already set up; recreate tables
	local dm_backing_dev="$NON_ERROR_LOGDEV"
	fi

	_dmerror_setup_vars $dm_backing_dev LOG $log_target
	fi
	}

	_dmerror_init()
	{
	_dmerror_setup "$@"

	_dmsetup_remove error-test
	_dmsetup_create error-test --table "$DMLINEAR_TABLE" \|\| \
	_fatal "failed to create dm linear device"

	if [ -n "$NON_ERROR_RTDEV" ]; then
	_dmsetup_remove error-rttest
	_dmsetup_create error-rttest --table "$DMLINEAR_RTTABLE" \|\| \
	_fatal "failed to create dm linear rt device"
	fi

	if [ -n "$NON_ERROR_LOGDEV" ]; then
	_dmsetup_remove error-logtest
	_dmsetup_create error-logtest --table "$DMLINEAR_LOGTABLE" \|\| \
	_fatal "failed to create dm linear log device"
	fi
	}

	_dmerror_mount()
	{
	_scratch_options mount
	$MOUNT_PROG -t $FSTYP `_common_dev_mount_options $*` $SCRATCH_OPTIONS \
	$DMERROR_DEV $SCRATCH_MNT
	}

	_dmerror_unmount()
	{
	umount $SCRATCH_MNT
	}

	_dmerror_cleanup()
	{
	test -n "$NON_ERROR_LOGDEV" && $DMSETUP_PROG resume error-logtest &>/dev/null
	test -n "$NON_ERROR_RTDEV" && $DMSETUP_PROG resume error-rttest &>/dev/null
	$DMSETUP_PROG resume error-test > /dev/null 2>&1

	$UMOUNT_PROG $SCRATCH_MNT > /dev/null 2>&1

	test -n "$NON_ERROR_LOGDEV" && _dmsetup_remove error-logtest
	test -n "$NON_ERROR_RTDEV" && _dmsetup_remove error-rttest
	_dmsetup_remove error-test

	unset DMERROR_DEV DMLINEAR_TABLE DMERROR_TABLE

	if [ -n "$NON_ERROR_LOGDEV" ]; then
	SCRATCH_LOGDEV="$NON_ERROR_LOGDEV"
	unset NON_ERROR_LOGDEV DMLINEAR_LOGTABLE DMERROR_LOGTABLE
	fi

	if [ -n "$NON_ERROR_RTDEV" ]; then
	SCRATCH_RTDEV="$NON_ERROR_RTDEV"
	unset NON_ERROR_RTDEV DMLINEAR_RTTABLE DMERROR_RTTABLE
	fi
	}

	_dmerror_load_error_table()
	{
	local load_res=0
	local resume_res=0

	suspend_opt="--nolockfs"

	if [ "$1" = "lockfs" ]; then
	suspend_opt=""
	elif [ -n "$*" ]; then
	suspend_opt="$*"
	fi

	# If the full environment is set up, configure ourselves for shutdown
	type _prepare_for_eio_shutdown &>/dev/null && \
	_prepare_for_eio_shutdown $DMERROR_DEV

	# Suspend the scratch device before the log and realtime devices so
	# that the kernel can freeze and flush the filesystem if the caller
	# wanted a freeze.
	$DMSETUP_PROG suspend $suspend_opt error-test
	[ $? -ne 0 ] && _fail "dmsetup suspend failed"

	if [ -n "$NON_ERROR_RTDEV" ]; then
	$DMSETUP_PROG suspend $suspend_opt error-rttest
	[ $? -ne 0 ] && _fail "failed to suspend error-rttest"
	fi

	if [ -n "$NON_ERROR_LOGDEV" ]; then
	$DMSETUP_PROG suspend $suspend_opt error-logtest
	[ $? -ne 0 ] && _fail "failed to suspend error-logtest"
	fi

	# Load new table
	$DMSETUP_PROG load error-test --table "$DMERROR_TABLE"
	load_res=$?

	if [ -n "$NON_ERROR_RTDEV" ]; then
	$DMSETUP_PROG load error-rttest --table "$DMERROR_RTTABLE"
	[ $? -ne 0 ] && _fail "failed to load error table into error-rttest"
	fi

	if [ -n "$NON_ERROR_LOGDEV" ]; then
	$DMSETUP_PROG load error-logtest --table "$DMERROR_LOGTABLE"
	[ $? -ne 0 ] && _fail "failed to load error table into error-logtest"
	fi

	# Resume devices in the opposite order that we suspended them.
	if [ -n "$NON_ERROR_LOGDEV" ]; then
	$DMSETUP_PROG resume error-logtest
	[ $? -ne 0 ] && _fail "failed to resume error-logtest"
	fi

	if [ -n "$NON_ERROR_RTDEV" ]; then
	$DMSETUP_PROG resume error-rttest
	[ $? -ne 0 ] && _fail "failed to resume error-rttest"
	fi

	$DMSETUP_PROG resume error-test
	resume_res=$?

	[ $load_res -ne 0 ] && _fail "dmsetup failed to load error table"
	[ $resume_res -ne 0 ] && _fail "dmsetup resume failed"
	}

	_dmerror_load_working_table()
	{
	local load_res=0
	local resume_res=0

	suspend_opt="--nolockfs"

	if [ "$1" = "lockfs" ]; then
	suspend_opt=""
	elif [ -n "$*" ]; then
	suspend_opt="$*"
	fi

	# Suspend the scratch device before the log and realtime devices so
	# that the kernel can freeze and flush the filesystem if the caller
	# wanted a freeze.
	$DMSETUP_PROG suspend $suspend_opt error-test
	[ $? -ne 0 ] && _fail "dmsetup suspend failed"

	if [ -n "$NON_ERROR_RTDEV" ]; then
	$DMSETUP_PROG suspend $suspend_opt error-rttest
	[ $? -ne 0 ] && _fail "failed to suspend error-rttest"
	fi

	if [ -n "$NON_ERROR_LOGDEV" ]; then
	$DMSETUP_PROG suspend $suspend_opt error-logtest
	[ $? -ne 0 ] && _fail "failed to suspend error-logtest"
	fi

	# Load new table
	$DMSETUP_PROG load error-test --table "$DMLINEAR_TABLE"
	load_res=$?

	if [ -n "$NON_ERROR_RTDEV" ]; then
	$DMSETUP_PROG load error-rttest --table "$DMLINEAR_RTTABLE"
	[ $? -ne 0 ] && _fail "failed to load working table into error-rttest"
	fi

	if [ -n "$NON_ERROR_LOGDEV" ]; then
	$DMSETUP_PROG load error-logtest --table "$DMLINEAR_LOGTABLE"
	[ $? -ne 0 ] && _fail "failed to load working table into error-logtest"
	fi

	# Resume devices in the opposite order that we suspended them.
	if [ -n "$NON_ERROR_LOGDEV" ]; then
	$DMSETUP_PROG resume error-logtest
	[ $? -ne 0 ] && _fail "failed to resume error-logtest"
	fi

	if [ -n "$NON_ERROR_RTDEV" ]; then
	$DMSETUP_PROG resume error-rttest
	[ $? -ne 0 ] && _fail "failed to resume error-rttest"
	fi

	$DMSETUP_PROG resume error-test
	resume_res=$?

	[ $load_res -ne 0 ] && _fail "dmsetup failed to load error table"
	[ $resume_res -ne 0 ] && _fail "dmsetup resume failed"
	}

	# Given a list of (start, length) tuples on stdin, combine adjacent tuples into
	# larger ones and write the new list to stdout.
	__dmerror_combine_extents()
	{
	local awk_program='
	BEGIN {
	start = 0; len = 0;
	}
	{
	if (start + len == $1) {
	len += $2;
	} else {
	if (len > 0)
	printf("%d %d\n", start, len);
	start = $1;
	len = $2;
	}
	}
	END {
	if (len > 0)
	printf("%d %d\n", start, len);
	}'

	awk "$awk_program"
	}

	# Given a block device, the name of a preferred dm target, the name of an
	# implied dm target, and a list of (start, len) tuples on stdin, create a new
	# dm table which maps each of the tuples to the preferred target and all other
	# areas to the implied dm target.
	__dmerror_recreate_map()
	{
	local device="$1"
	local preferred_tgt="$2"
	local implied_tgt="$3"
	local size=$(blockdev --getsz "$device")

	local awk_program='
	BEGIN {
	implied_start = 0;
	}
	{
	extent_start = $1;
	extent_len = $2;

	if (extent_start > size) {
	extent_start = size;
	extent_len = 0;
	} else if (extent_start + extent_len > size) {
	extent_len = size - extent_start;
	}

	if (implied_start < extent_start)
	printf("%d %d %s %s %d\n", implied_start,
	extent_start - implied_start,
	implied_tgt, device, implied_start);
	printf("%d %d %s %s %d\n", extent_start, extent_len,
	preferred_tgt, device, extent_start);
	implied_start = extent_start + extent_len;
	}
	END {
	if (implied_start < size)
	printf("%d %d %s %s %d\n", implied_start,
	size - implied_start, implied_tgt,
	device, implied_start);
	}'

	awk -v device="$device" -v size=$size -v implied_tgt="$implied_tgt" \
	-v preferred_tgt="$preferred_tgt" "$awk_program"
	}

	# Update the dm error table so that the range (start, len) maps to the
	# preferred dm target, overriding anything that maps to the implied dm target.
	# This assumes that the only desired targets for this dm device are the
	# preferred and and implied targets. The fifth argument is the scratch device
	# that we want to change the table for.
	__dmerror_change()
	{
	local start="$1"
	local len="$2"
	local preferred_tgt="$3"
	local implied_tgt="$4"
	local whichdev="$5"
	local old_table
	local new_table

	case "$whichdev" in
	"SCRATCH_DEV"\|"") whichdev="$SCRATCH_DEV";;
	"SCRATCH_LOGDEV"\|"LOG") whichdev="$NON_ERROR_LOGDEV";;
	"SCRATCH_RTDEV"\|"RT") whichdev="$NON_ERROR_RTDEV";;
	esac

	case "$whichdev" in
	"$SCRATCH_DEV") old_table="$DMERROR_TABLE";;
	"$NON_ERROR_LOGDEV") old_table="$DMERROR_LOGTABLE";;
	"$NON_ERROR_RTDEV") old_table="$DMERROR_RTTABLE";;
	*)
	echo "$whichdev: Unknown dmerror device."
	return
	;;
	esac

	new_table="$( (echo "$old_table"; echo "$start $len $preferred_tgt") \| \
	awk -v type="$preferred_tgt" '{if ($3 == type) print $0;}' \| \
	sort -g \| \
	__dmerror_combine_extents \| \
	__dmerror_recreate_map "$whichdev" "$preferred_tgt" \
	"$implied_tgt" )"

	case "$whichdev" in
	"$SCRATCH_DEV") DMERROR_TABLE="$new_table";;
	"$NON_ERROR_LOGDEV") DMERROR_LOGTABLE="$new_table";;
	"$NON_ERROR_RTDEV") DMERROR_RTTABLE="$new_table";;
	esac
	}

	# Reset the dm error table to everything ok. The dm device itself must be
	# remapped by calling _dmerror_load_error_table.
	_dmerror_reset_table()
	{
	DMERROR_TABLE="$DMLINEAR_TABLE"
	DMERROR_LOGTABLE="$DMLINEAR_LOGTABLE"
	DMERROR_RTTABLE="$DMLINEAR_RTTABLE"
	}

	# Update the dm error table so that IOs to the given range will return EIO.
	# The dm device itself must be remapped by calling _dmerror_load_error_table.
	_dmerror_mark_range_bad()
	{
	local start="$1"
	local len="$2"
	local dev="$3"

	__dmerror_change "$start" "$len" error linear "$dev"
	}

	# Update the dm error table so that IOs to the given range will succeed.
	# The dm device itself must be remapped by calling _dmerror_load_error_table.
	_dmerror_mark_range_good()
	{
	local start="$1"
	local len="$2"
	local dev="$3"

	__dmerror_change "$start" "$len" linear error "$dev"
	}