mirror of
git://sourceware.org/git/lvm2.git
synced 2024-12-21 13:34:40 +03:00
773bc01377
Reduce shellcheck warnings about missing {} for possible array
dereference.
Make sure we are not loosing error code when assigning local vars
and explicitely ignore 'errors' from standalone lines when needed.
Add some missing quotes.
Use $() instead of ancient ``
Avoid writing some temporary data into /tmp - test need to store
files within its own 'testdir' - so it can be properly discarded.
356 lines
9.3 KiB
Bash
Executable File
356 lines
9.3 KiB
Bash
Executable File
#!/bin/bash
|
|
#
|
|
# Wrapper script for 'naive' emulation of vdo manager tool for systems
|
|
# that no longer have this tool present
|
|
#
|
|
|
|
set -euE -o pipefail
|
|
|
|
# tool for formatting 'old' VDO metadata format
|
|
LVM_VDO_FORMAT=${LVM_VDO_FORMAT-"oldvdoformat"}
|
|
# tool for shifting VDO metadata header by 2MiB
|
|
LVM_VDO_PREPARE=${LVM_VDO_PREPARE-"oldvdoprepareforlvm"}
|
|
# default vdo conf file
|
|
LVM_VDO_DEFAULT_CONF=${LVM_VDO_DEFAULT_CONF-"/tmp/vdoconf.yml"}
|
|
|
|
vdo_die_() {
|
|
echo -e "$@" >&2
|
|
return 1
|
|
}
|
|
|
|
vdo_verbose_() {
|
|
test -z "$vdo_verbose" || echo "$0:" "$@"
|
|
}
|
|
|
|
vdo_dry_() {
|
|
if test -n "$vdo_dry"; then
|
|
vdo_verbose_ "Dry execution" "$@"
|
|
return 0
|
|
fi
|
|
vdo_verbose_ "Executing" "$@"
|
|
"$@"
|
|
}
|
|
|
|
vdo_get_kb_size_with_unit_() {
|
|
local sz=${2-1} # 2nd. arg as unit - default 'k'
|
|
|
|
case "$sz" in
|
|
[mM]) sz=1024 ;;
|
|
esac
|
|
|
|
case "$1" in
|
|
*[mM]) sz=1024 ;;
|
|
*[gG]) sz=$(( 1024 * 1024 )) ;;
|
|
*[tT]) sz=$(( 1024 * 1024 * 1024 )) ;;
|
|
*[pP]) sz=$(( 1024 * 1024 * 1024 * 1024 )) ;;
|
|
esac
|
|
|
|
echo $(( sz * ${1%[kKmMgGtTpP]} ))
|
|
}
|
|
|
|
#
|
|
# Emulate functionality of deprecated 'vdo create'
|
|
#
|
|
vdo_create_() {
|
|
local cachesize=
|
|
local devsize=
|
|
local emulate512=disabled
|
|
local logicalsize=
|
|
local maxdiscardsize=
|
|
local slabbits=0 # 4k
|
|
local slabsize=
|
|
local sparse=
|
|
local table=
|
|
local vdo_compression_msg=
|
|
local vdo_dry=
|
|
local vdo_index_msg=
|
|
local vdo_logicalBlockSize=
|
|
local vdo_verbose=
|
|
|
|
local vdo_ackThreads=${vdo_ackThreads-1}
|
|
local vdo_bioRotationInterval=${vdo_bioRotationInterval-64}
|
|
local vdo_bioThreads=${vdo_bioThreads-4}
|
|
local vdo_blockMapCacheSize=${vdo_blockMapCacheSize-128M}
|
|
local vdo_blockMapPeriod=${vdo_blockMapPeriod-16380}
|
|
local vdo_compression=${vdo_compression-enabled}
|
|
local vdo_confFile=$LVM_VDO_DEFAULT_CONF # place some file in /tmp
|
|
local vdo_cpuThreads=${vdo_cpuThreads-2}
|
|
local vdo_deduplication=${vdo_deduplication-enabled}
|
|
local vdo_hashZoneThreads=${vdo_hashZoneThreads-1}
|
|
local vdo_indexCfreq=${vdo_indexCfreq-0}
|
|
local vdo_indexMemory=${vdo_indexMemory-0.25}
|
|
local vdo_indexSparse=${vdo_indexSparse-disabled}
|
|
local vdo_indexThreads=${vdo_indexThreads-0}
|
|
local vdo_logicalSize=${vdo_logicalSize-0}
|
|
local vdo_logicalThreads=${vdo_logicalThreads-1}
|
|
local vdo_maxDiscardSize=${vdo_maxDiscardSize-4K}
|
|
local vdo_name=${vdo_name-VDONAME}
|
|
local vdo_physicalThreads=${vdo_physicalThreads-1}
|
|
local vdo_slabSize=${vdo_slabSize-2G}
|
|
local vdo_writePolicy=${vdo_writePolicy-auto}
|
|
local vdo_uuid
|
|
|
|
vdo_uuid="VDO-$(uuidgen || echo \"f7a3ecdc-40a0-4e43-814c-4a7039a75de4\")"
|
|
|
|
while [ "$#" -ne 0 ]
|
|
do
|
|
case "$1" in
|
|
"--blockMapCacheSize") shift; vdo_blockMapCacheSize=$1 ;;
|
|
"--blockMapPeriod") shift; vdo_blockMapPeriod=$1 ;;
|
|
"--compression") shift; vdo_compression=$1 ;;
|
|
"--confFile"|"-f") shift; vdo_confFile=$1 ;;
|
|
"--deduplication") shift; vdo_deduplication=$1 ;;
|
|
"--device") shift; vdo_device=$1 ;;
|
|
"--emulate512") shift; emulate512=$1 ;;
|
|
"--indexMem") shift; vdo_indexMemory=$1 ;;
|
|
"--maxDiscardSize") shift; vdo_maxDiscardSize=$1 ;;
|
|
"--name"|"-n") shift; vdo_name=$1 ;;
|
|
"--sparseIndex") shift; vdo_indexSparse=$1 ;;
|
|
"--uuid") shift ;; # ignored
|
|
"--vdoAckThreads") shift; vdo_ackThreads=$1 ;;
|
|
"--vdoBioRotationInterval") shift; vdo_bioRotationInterval=$1 ;;
|
|
"--vdoBioThreads") shift; vdo_bioThreads=$1 ;;
|
|
"--vdoCpuThreads") shift; vdo_cpuThreads=$1 ;;
|
|
"--vdoHashZoneThreads") shift; vdo_hashZoneThreads=$1 ;;
|
|
"--vdoLogicalSize") shift; vdo_logicalSize=$1 ;;
|
|
"--vdoLogicalThreads") shift; vdo_logicalThreads=$1 ;;
|
|
"--vdoLogLevel") shift ;; # ignored
|
|
"--vdoPhysicalThreads") shift; vdo_physicalThreads=$1 ;;
|
|
"--vdoSlabSize") shift; vdo_slabSize=$1 ;;
|
|
"--verbose"|"-d"|"--debug") vdo_verbose="-v" ;;
|
|
"--writePolicy") shift; vdo_writePolicy=$1 ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# Convert when set
|
|
case "$emulate512" in
|
|
"enabled") vdo_logicalBlockSize=512 ;;
|
|
"disabled") vdo_logicalBlockSize=4096 ;;
|
|
*) vdo_die_ "Invalid emulate512 setting."
|
|
esac
|
|
|
|
case "$vdo_deduplication" in
|
|
"enabled") vdo_index_msg="index-enable" ;;
|
|
"disabled") vdo_index_msg="index-disable";;
|
|
*) vdo_die_ "Invalid deduplication setting."
|
|
esac
|
|
|
|
case "$vdo_compression" in
|
|
"enabled") vdo_compression_msg="compression on" ;;
|
|
"disabled") vdo_compression_msg="compression off";;
|
|
*) vdo_die_ "Invalid compression setting."
|
|
esac
|
|
|
|
test -n "${vdo_device-}" || vdo_die_ "VDO device is missing"
|
|
|
|
blkid -c /dev/null -s UUID -o value "${vdo_device}" || true
|
|
|
|
devsize=$(blockdev --getsize64 "$vdo_device")
|
|
devsize=$(( devsize / 4096 )) # convert to 4KiB units
|
|
|
|
logicalsize=$(vdo_get_kb_size_with_unit_ "$vdo_logicalSize" M)
|
|
logicalsize=$(( logicalsize * 2 )) # 512B units
|
|
|
|
cachesize=$(vdo_get_kb_size_with_unit_ "$vdo_blockMapCacheSize" M)
|
|
cachesize=$(( cachesize / 4 )) # 4KiB units
|
|
|
|
maxdiscardsize=$(vdo_get_kb_size_with_unit_ "$vdo_maxDiscardSize" M)
|
|
maxdiscardsize=$(( maxdiscardsize / 4 )) # 4KiB units
|
|
|
|
test -e "$vdo_confFile" || {
|
|
cat > "$vdo_confFile" <<EOF
|
|
####################################################################
|
|
# THIS FILE IS MACHINE GENERATED. DO NOT EDIT THIS FILE BY HAND.
|
|
####################################################################
|
|
config: !Configuration
|
|
vdos:
|
|
EOF
|
|
}
|
|
|
|
cat >> "$vdo_confFile" <<EOF
|
|
$vdo_name: !VDOService
|
|
_operationState: finished
|
|
ackThreads: $vdo_ackThreads
|
|
activated: enabled
|
|
bioRotationInterval: $vdo_bioRotationInterval
|
|
bioThreads: $vdo_bioThreads
|
|
blockMapCacheSize: $(( cachesize * 4 ))K
|
|
blockMapPeriod: $vdo_blockMapPeriod
|
|
compression: $vdo_compression
|
|
cpuThreads: $vdo_cpuThreads
|
|
deduplication: $vdo_deduplication
|
|
device: $vdo_device
|
|
hashZoneThreads: $vdo_hashZoneThreads
|
|
indexCfreq: $vdo_indexCfreq
|
|
indexMemory: $vdo_indexMemory
|
|
indexSparse: $vdo_indexSparse
|
|
indexThreads: $vdo_indexThreads
|
|
logicalBlockSize: $vdo_logicalBlockSize
|
|
logicalSize: $(( logicalsize / 2 ))K
|
|
logicalThreads: $vdo_logicalThreads
|
|
maxDiscardSize: $(( maxdiscardsize * 4 ))K
|
|
name: $vdo_name
|
|
physicalSize: $(( devsize * 4 ))K
|
|
physicalThreads: $vdo_physicalThreads
|
|
slabSize: $vdo_slabSize
|
|
uuid: $vdo_uuid
|
|
writePolicy: $vdo_writePolicy
|
|
version: 538380551
|
|
EOF
|
|
|
|
slabsize=$(vdo_get_kb_size_with_unit_ "$vdo_slabSize")
|
|
while test "$slabsize" -gt 4 ; do
|
|
slabbits=$(( slabbits + 1 ))
|
|
slabsize=$(( slabsize / 2 ))
|
|
done
|
|
|
|
case "$vdo_indexSparse" in
|
|
"enabled") sparse="--uds-sparse" ;;
|
|
esac
|
|
|
|
vdo_dry_ "$LVM_VDO_FORMAT" $vdo_verbose $sparse\
|
|
--logical-size "$vdo_logicalSize" --slab-bits "$slabbits"\
|
|
--uds-checkpoint-frequency "$vdo_indexCfreq"\
|
|
--uds-memory-size "$vdo_indexMemory" "$vdo_device"
|
|
|
|
# V2 format
|
|
table="0 $logicalsize vdo V2 $vdo_device\
|
|
$devsize\
|
|
$vdo_logicalBlockSize\
|
|
$cachesize\
|
|
$vdo_blockMapPeriod\
|
|
on\
|
|
$vdo_writePolicy\
|
|
$vdo_name\
|
|
maxDiscard $maxdiscardsize\
|
|
ack $vdo_ackThreads\
|
|
bio $vdo_bioThreads\
|
|
bioRotationInterval $vdo_bioRotationInterval\
|
|
cpu $vdo_cpuThreads\
|
|
hash $vdo_hashZoneThreads\
|
|
logical $vdo_logicalThreads\
|
|
physical $vdo_physicalThreads"
|
|
|
|
vdo_dry_ dmsetup create "$vdo_name" --uuid "$vdo_uuid" --table "$table"
|
|
vdo_dry_ dmsetup message "$vdo_name" 0 "$vdo_index_msg"
|
|
vdo_dry_ dmsetup message "$vdo_name" 0 "$vdo_compression_msg"
|
|
}
|
|
|
|
#
|
|
# vdo stop
|
|
#
|
|
vdo_stop_() {
|
|
local vdo_confFile=$LVM_VDO_DEFAULT_CONF
|
|
local vdo_dry=
|
|
local vdo_force=
|
|
local vdo_name=
|
|
local vdo_verbose=
|
|
|
|
while [ "$#" -ne 0 ]
|
|
do
|
|
case "$1" in
|
|
"--confFile"|"-f") shift; vdo_confFile=$1 ;;
|
|
"--name"|"-n") shift; vdo_name=$1 ;;
|
|
"--verbose"|"-d"|"--debug") vdo_verbose="-v" ;;
|
|
"--force") vdo_force="--force" ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
vdo_dry_ dmsetup status --target vdo "$vdo_name" 2>/dev/null || return 0
|
|
vdo_dry_ dmsetup remove $vdo_force "$vdo_name" || true
|
|
}
|
|
|
|
#
|
|
# vdo remove
|
|
#
|
|
vdo_remove_() {
|
|
local vdo_confFile=$LVM_VDO_DEFAULT_CONF
|
|
local vdo_name=
|
|
|
|
vdo_stop_ "$@"
|
|
while [ "$#" -ne 0 ]
|
|
do
|
|
case "$1" in
|
|
"--confFile"|"-f") shift; vdo_confFile=$1 ;;
|
|
"--name"|"-n") shift; vdo_name=$1 ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# remove entry from conf file
|
|
awk -v vdovolname="$vdo_name" 'BEGIN { have=0 }
|
|
$0 ~ "!VDOService" { have=0 }
|
|
$0 ~ vdovolname":" { have=1 }
|
|
{ if (have==0) { print } ;}
|
|
' "$vdo_confFile" >"${vdo_confFile}.new"
|
|
|
|
mv "${vdo_confFile}.new" "$vdo_confFile"
|
|
grep "!VDOService" "$vdo_confFile" || rm -f "$vdo_confFile"
|
|
}
|
|
|
|
|
|
#
|
|
# print_config_file
|
|
#
|
|
vdo_print_config_file_() {
|
|
local vdo_confFile=$LVM_VDO_DEFAULT_CONF
|
|
|
|
while [ "$#" -ne 0 ]
|
|
do
|
|
case "$1" in
|
|
"--confFile"|"-f") shift; vdo_confFile=$1 ;;
|
|
"--verbose"|"-d"|"--debug") ;;
|
|
"--logfile") shift ;; # ignore
|
|
esac
|
|
shift
|
|
done
|
|
|
|
cat "$vdo_confFile"
|
|
}
|
|
|
|
#
|
|
# vdo convert
|
|
#
|
|
vdo_convert_() {
|
|
local vdo_confFile=$LVM_VDO_DEFAULT_CONF
|
|
local vdo_dry=
|
|
local vdo_force=
|
|
local vdo_name=
|
|
local vdo_verbose=
|
|
local vdo_device=
|
|
|
|
while [ "$#" -ne 0 ]
|
|
do
|
|
case "$1" in
|
|
"--confFile"|"-f") shift; vdo_confFile=$1 ;;
|
|
"--name"|"-n") shift; vdo_name=$1 ;;
|
|
"--verbose"|"-d"|"--debug") vdo_verbose="-v" ;;
|
|
"--force") vdo_force="--force" ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
vdo_device=$(awk -v vdovolname="$vdo_name" 'BEGIN { have=0 }
|
|
$0 ~ "!VDOService" { have=0 }
|
|
$0 ~ vdovolname":" { have=1 }
|
|
{ if (have==1 && $0 ~ "device:" ) { print $2 } ;}'\
|
|
"$vdo_confFile")
|
|
|
|
#dmsetup status --target vdo "$vdo_name" || true
|
|
vdo_dry_ "$LVM_VDO_PREPARE" "$vdo_device"
|
|
vdo_dry_ vdo_remove_ -f "$vdo_confFile" -n "$vdo_name" || true
|
|
}
|
|
|
|
#
|
|
# MAIN
|
|
#
|
|
case "${1-}" in
|
|
"create") shift; vdo_create_ "$@" ;;
|
|
"remove") shift; vdo_remove_ "$@" ;;
|
|
"stop") shift; vdo_stop_ "$@" ;;
|
|
"convert") shift; vdo_convert_ "$@" ;;
|
|
"printConfigFile") shift; vdo_print_config_file_ "$@" ;;
|
|
esac
|