1#!/usr/bin/env bash 2# 3# Copyright (C) 2009 Red Hat, Inc. 4# Copyright (c) 2000-2006 Silicon Graphics, Inc. All Rights Reserved. 5# 6# This program is free software; you can redistribute it and/or modify 7# it under the terms of the GNU General Public License as published by 8# the Free Software Foundation; either version 2 of the License, or 9# (at your option) any later version. 10# 11# This program is distributed in the hope that it will be useful, 12# but WITHOUT ANY WARRANTY; without even the implied warranty of 13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14# GNU General Public License for more details. 15# 16# You should have received a copy of the GNU General Public License 17# along with this program. If not, see <http://www.gnu.org/licenses/>. 18# 19 20SED= 21for sed in sed gsed; do 22 ($sed --version | grep 'GNU sed') > /dev/null 2>&1 23 if [ "$?" -eq 0 ]; then 24 SED=$sed 25 break 26 fi 27done 28if [ -z "$SED" ]; then 29 echo "$0: GNU sed not found" 30 exit 1 31fi 32 33dd() 34{ 35 if [ "$HOSTOS" == "Linux" ] 36 then 37 command dd --help | grep noxfer > /dev/null 2>&1 38 39 if [ "$?" -eq 0 ] 40 then 41 command dd status=noxfer $@ 42 else 43 command dd $@ 44 fi 45 else 46 command dd $@ 47 fi 48} 49 50# poke_file 'test.img' 512 '\xff\xfe' 51poke_file() 52{ 53 printf "$3" | dd "of=$1" bs=1 "seek=$2" conv=notrunc &>/dev/null 54} 55 56# poke_file_le $img_filename $offset $byte_width $value 57# Example: poke_file_le "$TEST_IMG" 512 2 65534 58poke_file_le() 59{ 60 local img=$1 ofs=$2 len=$3 val=$4 str='' 61 62 while ((len--)); do 63 str+=$(printf '\\x%02x' $((val & 0xff))) 64 val=$((val >> 8)) 65 done 66 67 poke_file "$img" "$ofs" "$str" 68} 69 70# poke_file_be $img_filename $offset $byte_width $value 71# Example: poke_file_be "$TEST_IMG" 512 2 65279 72poke_file_be() 73{ 74 local img=$1 ofs=$2 len=$3 val=$4 75 local str=$(printf "%0$((len * 2))x\n" $val | sed 's/\(..\)/\\x\1/g') 76 77 poke_file "$img" "$ofs" "$str" 78} 79 80# peek_file_le 'test.img' 512 2 => 65534 81peek_file_le() 82{ 83 local val=0 shift=0 byte 84 85 # coreutils' od --endian is not portable, so manually assemble bytes. 86 for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do 87 val=$(( val | (byte << shift) )) 88 shift=$((shift + 8)) 89 done 90 printf %llu $val 91} 92 93# peek_file_be 'test.img' 512 2 => 65279 94peek_file_be() 95{ 96 local val=0 byte 97 98 # coreutils' od --endian is not portable, so manually assemble bytes. 99 for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do 100 val=$(( (val << 8) | byte )) 101 done 102 printf %llu $val 103} 104 105# peek_file_raw 'test.img' 512 2 => '\xff\xfe'. Do not use if the raw data 106# is likely to contain \0 or trailing \n. 107peek_file_raw() 108{ 109 dd if="$1" bs=1 skip="$2" count="$3" status=none 110} 111 112 113if ! . ./common.config 114 then 115 echo "$0: failed to source common.config" 116 exit 1 117fi 118 119# Set the variables to the empty string to turn Valgrind off 120# for specific processes, e.g. 121# $ VALGRIND_QEMU_IO= ./check -qcow2 -valgrind 015 122 123: ${VALGRIND_QEMU_VM=$VALGRIND_QEMU} 124: ${VALGRIND_QEMU_IMG=$VALGRIND_QEMU} 125: ${VALGRIND_QEMU_IO=$VALGRIND_QEMU} 126: ${VALGRIND_QEMU_NBD=$VALGRIND_QEMU} 127 128# The Valgrind own parameters may be set with 129# its environment variable VALGRIND_OPTS, e.g. 130# $ VALGRIND_OPTS="--leak-check=yes" ./check -qcow2 -valgrind 015 131 132_qemu_proc_exec() 133{ 134 local VALGRIND_LOGFILE="$1" 135 shift 136 if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then 137 exec valgrind --log-file="${VALGRIND_LOGFILE}" --error-exitcode=99 "$@" 138 else 139 exec "$@" 140 fi 141} 142 143_qemu_proc_valgrind_log() 144{ 145 local VALGRIND_LOGFILE="$1" 146 local RETVAL="$2" 147 if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then 148 if [ $RETVAL == 99 ]; then 149 cat "${VALGRIND_LOGFILE}" 150 fi 151 rm -f "${VALGRIND_LOGFILE}" 152 fi 153} 154 155_qemu_wrapper() 156{ 157 local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind 158 ( 159 if [ -n "${QEMU_NEED_PID}" ]; then 160 echo $BASHPID > "${QEMU_TEST_DIR}/qemu-${_QEMU_HANDLE}.pid" 161 fi 162 VALGRIND_QEMU="${VALGRIND_QEMU_VM}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \ 163 "$QEMU_PROG" $QEMU_OPTIONS "$@" 164 ) 165 RETVAL=$? 166 _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL 167 return $RETVAL 168} 169 170_qemu_img_wrapper() 171{ 172 local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind 173 ( 174 VALGRIND_QEMU="${VALGRIND_QEMU_IMG}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \ 175 "$QEMU_IMG_PROG" $QEMU_IMG_OPTIONS "$@" 176 ) 177 RETVAL=$? 178 _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL 179 return $RETVAL 180} 181 182_qemu_io_wrapper() 183{ 184 local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind 185 local QEMU_IO_ARGS="$QEMU_IO_OPTIONS" 186 if [ "$IMGOPTSSYNTAX" = "true" ]; then 187 QEMU_IO_ARGS="--image-opts $QEMU_IO_ARGS" 188 if [ -n "$IMGKEYSECRET" ]; then 189 QEMU_IO_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IO_ARGS" 190 fi 191 fi 192 ( 193 VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \ 194 "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@" 195 ) 196 RETVAL=$? 197 _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL 198 return $RETVAL 199} 200 201_qemu_nbd_wrapper() 202{ 203 local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind 204 ( 205 VALGRIND_QEMU="${VALGRIND_QEMU_NBD}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \ 206 "$QEMU_NBD_PROG" --pid-file="${QEMU_TEST_DIR}/qemu-nbd.pid" \ 207 $QEMU_NBD_OPTIONS "$@" 208 ) 209 RETVAL=$? 210 _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL 211 return $RETVAL 212} 213 214# Valgrind bug #409141 https://bugs.kde.org/show_bug.cgi?id=409141 215# Until valgrind 3.16+ is ubiquitous, we must work around a hang in 216# valgrind when issuing sigkill. Disable valgrind for this invocation. 217_NO_VALGRIND() 218{ 219 NO_VALGRIND="y" "$@" 220} 221 222export QEMU=_qemu_wrapper 223export QEMU_IMG=_qemu_img_wrapper 224export QEMU_IO=_qemu_io_wrapper 225export QEMU_NBD=_qemu_nbd_wrapper 226 227if [ "$IMGOPTSSYNTAX" = "true" ]; then 228 DRIVER="driver=$IMGFMT" 229 QEMU_IMG_EXTRA_ARGS="--image-opts $QEMU_IMG_EXTRA_ARGS" 230 if [ -n "$IMGKEYSECRET" ]; then 231 QEMU_IMG_EXTRA_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IMG_EXTRA_ARGS" 232 fi 233 if [ "$IMGFMT" = "luks" ]; then 234 DRIVER="$DRIVER,key-secret=keysec0" 235 fi 236 if [ "$IMGPROTO" = "file" ]; then 237 TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT 238 TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT" 239 elif [ "$IMGPROTO" = "nbd" ]; then 240 TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT 241 TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix" 242 TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd" 243 elif [ "$IMGPROTO" = "ssh" ]; then 244 TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT 245 TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE" 246 elif [ "$IMGPROTO" = "nfs" ]; then 247 TEST_DIR="$DRIVER,file.driver=nfs,file.filename=nfs://127.0.0.1/$TEST_DIR" 248 TEST_IMG=$TEST_DIR/t.$IMGFMT 249 else 250 TEST_IMG="$DRIVER,file.driver=$IMGPROTO,file.filename=$TEST_DIR/t.$IMGFMT" 251 fi 252else 253 QEMU_IMG_EXTRA_ARGS= 254 if [ "$IMGPROTO" = "file" ]; then 255 TEST_IMG=$TEST_DIR/t.$IMGFMT 256 elif [ "$IMGPROTO" = "nbd" ]; then 257 TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT 258 TEST_IMG="nbd+unix:///?socket=$SOCK_DIR/nbd" 259 elif [ "$IMGPROTO" = "ssh" ]; then 260 TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT 261 REMOTE_TEST_DIR="ssh://\\($USER@\\)\\?127.0.0.1\\(:[0-9]\\+\\)\\?$TEST_DIR" 262 TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE" 263 elif [ "$IMGPROTO" = "nfs" ]; then 264 TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT 265 REMOTE_TEST_DIR="nfs://127.0.0.1$TEST_DIR" 266 TEST_IMG="nfs://127.0.0.1$TEST_IMG_FILE" 267 else 268 TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT 269 fi 270fi 271ORIG_TEST_IMG="$TEST_IMG" 272 273if [ -z "$TEST_DIR" ]; then 274 TEST_DIR=$PWD/scratch 275fi 276 277QEMU_TEST_DIR="${TEST_DIR}" 278 279if [ ! -e "$TEST_DIR" ]; then 280 mkdir "$TEST_DIR" 281fi 282 283if [ ! -d "$TEST_DIR" ]; then 284 echo "common.rc: Error: \$TEST_DIR ($TEST_DIR) is not a directory" 285 exit 1 286fi 287 288if [ -z "$REMOTE_TEST_DIR" ]; then 289 REMOTE_TEST_DIR="$TEST_DIR" 290fi 291 292if [ ! -d "$SAMPLE_IMG_DIR" ]; then 293 echo "common.rc: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory" 294 exit 1 295fi 296 297_use_sample_img() 298{ 299 SAMPLE_IMG_FILE="${1%\.bz2}" 300 TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE" 301 bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG" 302 if [ $? -ne 0 ] 303 then 304 echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'" 305 exit 1 306 fi 307} 308 309_stop_nbd_server() 310{ 311 if [ -f "${QEMU_TEST_DIR}/qemu-nbd.pid" ]; then 312 local QEMU_NBD_PID 313 read QEMU_NBD_PID < "${QEMU_TEST_DIR}/qemu-nbd.pid" 314 kill ${QEMU_NBD_PID} 315 rm -f "${QEMU_TEST_DIR}/qemu-nbd.pid" "$SOCK_DIR/nbd" 316 fi 317} 318 319# Gets the data_file value from IMGOPTS and replaces the '$TEST_IMG' 320# pattern by '$1' 321# Caution: The replacement is done with sed, so $1 must be escaped 322# properly. (The delimiter is '#'.) 323_get_data_file() 324{ 325 if ! echo "$IMGOPTS" | grep -q 'data_file='; then 326 return 1 327 fi 328 329 echo "$IMGOPTS" | sed -e 's/.*data_file=\([^,]*\).*/\1/' \ 330 | sed -e "s#\\\$TEST_IMG#$1#" 331} 332 333_make_test_img() 334{ 335 # extra qemu-img options can be added by tests 336 # at least one argument (the image size) needs to be added 337 local extra_img_options="" 338 local optstr="" 339 local img_name="" 340 local use_backing=0 341 local backing_file="" 342 local object_options="" 343 local opts_param=false 344 local misc_params=() 345 346 if [ -n "$TEST_IMG_FILE" ]; then 347 img_name=$TEST_IMG_FILE 348 else 349 img_name=$TEST_IMG 350 fi 351 352 if [ -n "$IMGOPTS" ]; then 353 imgopts_expanded=$(echo "$IMGOPTS" | sed -e "s#\\\$TEST_IMG#$img_name#") 354 optstr=$(_optstr_add "$optstr" "$imgopts_expanded") 355 fi 356 if [ -n "$IMGKEYSECRET" ]; then 357 object_options="--object secret,id=keysec0,data=$IMGKEYSECRET" 358 optstr=$(_optstr_add "$optstr" "key-secret=keysec0") 359 fi 360 361 for param; do 362 if [ "$use_backing" = "1" -a -z "$backing_file" ]; then 363 backing_file=$param 364 continue 365 elif $opts_param; then 366 optstr=$(_optstr_add "$optstr" "$param") 367 opts_param=false 368 continue 369 fi 370 371 case "$param" in 372 -b) 373 use_backing=1 374 ;; 375 376 -o) 377 opts_param=true 378 ;; 379 380 --no-opts) 381 optstr="" 382 ;; 383 384 *) 385 misc_params=("${misc_params[@]}" "$param") 386 ;; 387 esac 388 done 389 390 if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then 391 optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE") 392 fi 393 394 if [ -n "$optstr" ]; then 395 extra_img_options="-o $optstr $extra_img_options" 396 fi 397 398 if [ $IMGPROTO = "nbd" ]; then 399 _stop_nbd_server 400 fi 401 402 # XXX(hch): have global image options? 403 ( 404 if [ $use_backing = 1 ]; then 405 $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" "${misc_params[@]}" 2>&1 406 else 407 $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" "${misc_params[@]}" 2>&1 408 fi 409 ) | _filter_img_create 410 411 # Start an NBD server on the image file, which is what we'll be talking to. 412 # Once NBD gains resize support, we may also want to use -f raw at the 413 # server and interpret format over NBD, but for now, the format is 414 # interpreted at the server and raw data sent over NBD. 415 if [ $IMGPROTO = "nbd" ]; then 416 # Pass a sufficiently high number to -e that should be enough for all 417 # tests 418 eval "$QEMU_NBD -v -t -k '$SOCK_DIR/nbd' -f $IMGFMT -e 42 -x '' $TEST_IMG_FILE >/dev/null &" 419 sleep 1 # FIXME: qemu-nbd needs to be listening before we continue 420 fi 421} 422 423_rm_test_img() 424{ 425 local img=$1 426 if [ "$IMGFMT" = "vmdk" ]; then 427 # Remove all the extents for vmdk 428 "$QEMU_IMG" info "$img" 2>/dev/null | grep 'filename:' | cut -f 2 -d: \ 429 | xargs -I {} rm -f "{}" 430 elif [ "$IMGFMT" = "qcow2" ]; then 431 # Remove external data file 432 if data_file=$(_get_data_file "$img"); then 433 rm -f "$data_file" 434 fi 435 fi 436 rm -f "$img" 437} 438 439_cleanup_test_img() 440{ 441 case "$IMGPROTO" in 442 443 nbd) 444 _stop_nbd_server 445 rm -f "$TEST_IMG_FILE" 446 ;; 447 448 file) 449 _rm_test_img "$TEST_DIR/t.$IMGFMT" 450 _rm_test_img "$TEST_DIR/t.$IMGFMT.orig" 451 _rm_test_img "$TEST_DIR/t.$IMGFMT.base" 452 if [ -n "$SAMPLE_IMG_FILE" ] 453 then 454 rm -f "$TEST_DIR/$SAMPLE_IMG_FILE" 455 SAMPLE_IMG_FILE= 456 TEST_IMG="$ORIG_TEST_IMG" 457 fi 458 ;; 459 460 rbd) 461 rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null 462 ;; 463 464 sheepdog) 465 collie vdi delete "$TEST_DIR/t.$IMGFMT" 466 ;; 467 468 esac 469} 470 471_check_test_img() 472{ 473 ( 474 if [ "$IMGOPTSSYNTAX" = "true" ]; then 475 $QEMU_IMG check $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 476 else 477 $QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1 478 fi 479 ) | _filter_testdir | _filter_qemu_img_check 480 481 # return real qemu_img check status, to analyze in 482 # _check_test_img_ignore_leaks 483 return ${PIPESTATUS[0]} 484} 485 486_check_test_img_ignore_leaks() 487{ 488 out=$(_check_test_img "$@") 489 status=$? 490 if [ $status = 3 ]; then 491 # This must correspond to success output in dump_human_image_check() 492 echo "No errors were found on the image." 493 return 0 494 fi 495 echo "$out" 496 return $status 497} 498 499_img_info() 500{ 501 if [[ "$1" == "--format-specific" ]]; then 502 local format_specific=1 503 shift 504 else 505 local format_specific=0 506 fi 507 508 discard=0 509 regex_json_spec_start='^ *"format-specific": \{' 510 $QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 | \ 511 sed -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \ 512 -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \ 513 -e "s#$TEST_DIR#TEST_DIR#g" \ 514 -e "s#$IMGFMT#IMGFMT#g" \ 515 -e "/^disk size:/ D" \ 516 -e "/actual-size/ D" | \ 517 while IFS='' read -r line; do 518 if [[ $format_specific == 1 ]]; then 519 discard=0 520 elif [[ $line == "Format specific information:" ]]; then 521 discard=1 522 elif [[ $line =~ $regex_json_spec_start ]]; then 523 discard=2 524 regex_json_spec_end="^${line%%[^ ]*}\\},? *$" 525 fi 526 if [[ $discard == 0 ]]; then 527 echo "$line" 528 elif [[ $discard == 1 && ! $line ]]; then 529 echo 530 discard=0 531 elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then 532 discard=0 533 fi 534 done 535} 536 537# bail out, setting up .notrun file 538# 539_notrun() 540{ 541 echo "$*" >"$OUTPUT_DIR/$seq.notrun" 542 echo "$seq not run: $*" 543 status=0 544 exit 545} 546 547# bail out, setting up .casenotrun file 548# The function _casenotrun() is used as a notifier. It is the 549# caller's responsibility to make skipped a particular test. 550# 551_casenotrun() 552{ 553 echo " [case not run] $*" >>"$OUTPUT_DIR/$seq.casenotrun" 554} 555 556# just plain bail out 557# 558_fail() 559{ 560 echo "$*" | tee -a "$OUTPUT_DIR/$seq.full" 561 echo "(see $seq.full for details)" 562 status=1 563 exit 1 564} 565 566# tests whether $IMGFMT is one of the supported image formats for a test 567# 568_supported_fmt() 569{ 570 # "generic" is suitable for most image formats. For some formats it doesn't 571 # work, however (most notably read-only formats), so they can opt out by 572 # setting IMGFMT_GENERIC to false. 573 for f; do 574 if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then 575 if [ "$IMGFMT" = "luks" ]; then 576 _require_working_luks 577 fi 578 return 579 fi 580 done 581 582 _notrun "not suitable for this image format: $IMGFMT" 583} 584 585# tests whether $IMGFMT is one of the unsupported image format for a test 586# 587_unsupported_fmt() 588{ 589 for f; do 590 if [ "$f" = "$IMGFMT" ]; then 591 _notrun "not suitable for this image format: $IMGFMT" 592 fi 593 done 594} 595 596# tests whether $IMGPROTO is one of the supported image protocols for a test 597# 598_supported_proto() 599{ 600 for f; do 601 if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then 602 return 603 fi 604 done 605 606 _notrun "not suitable for this image protocol: $IMGPROTO" 607} 608 609# tests whether $IMGPROTO is specified as an unsupported image protocol for a test 610# 611_unsupported_proto() 612{ 613 for f; do 614 if [ "$f" = "$IMGPROTO" ]; then 615 _notrun "not suitable for this image protocol: $IMGPROTO" 616 return 617 fi 618 done 619} 620 621# tests whether the host OS is one of the supported OSes for a test 622# 623_supported_os() 624{ 625 for h 626 do 627 if [ "$h" = "$HOSTOS" ] 628 then 629 return 630 fi 631 done 632 633 _notrun "not suitable for this OS: $HOSTOS" 634} 635 636_supported_cache_modes() 637{ 638 for mode; do 639 if [ "$mode" = "$CACHEMODE" ]; then 640 return 641 fi 642 done 643 _notrun "not suitable for cache mode: $CACHEMODE" 644} 645 646# Check whether the filesystem supports O_DIRECT 647_check_o_direct() 648{ 649 $QEMU_IMG create -f raw "$TEST_IMG".test_o_direct 1M > /dev/null 650 out=$($QEMU_IO -f raw -t none -c quit "$TEST_IMG".test_o_direct 2>&1) 651 rm -f "$TEST_IMG".test_o_direct 652 653 [[ "$out" != *"O_DIRECT"* ]] 654} 655 656_require_o_direct() 657{ 658 if ! _check_o_direct; then 659 _notrun "file system on $TEST_DIR does not support O_DIRECT" 660 fi 661} 662 663_check_cache_mode() 664{ 665 if [ $CACHEMODE == "none" ] || [ $CACHEMODE == "directsync" ]; then 666 _require_o_direct 667 fi 668} 669 670_check_cache_mode 671 672# $1 - cache mode to use by default 673# $2 - (optional) cache mode to use by default if O_DIRECT is not supported 674_default_cache_mode() 675{ 676 if $CACHEMODE_IS_DEFAULT; then 677 if [ -z "$2" ] || _check_o_direct; then 678 CACHEMODE="$1" 679 else 680 CACHEMODE="$2" 681 fi 682 QEMU_IO="$QEMU_IO --cache $CACHEMODE" 683 _check_cache_mode 684 return 685 fi 686} 687_supported_aio_modes() 688{ 689 for mode; do 690 if [ "$mode" = "$AIOMODE" ]; then 691 return 692 fi 693 done 694 _notrun "not suitable for aio mode: $AIOMODE" 695} 696_default_aio_mode() 697{ 698 AIOMODE="$1" 699 QEMU_IO="$QEMU_IO --aio $1" 700} 701 702_unsupported_imgopts() 703{ 704 for bad_opt 705 do 706 if echo "$IMGOPTS" | grep -q 2>/dev/null "$bad_opt" 707 then 708 _notrun "not suitable for image option: $bad_opt" 709 fi 710 done 711} 712 713# Caution: Overwrites $TEST_DIR/t.luks 714_require_working_luks() 715{ 716 file="$TEST_DIR/t.luks" 717 718 output=$( 719 $QEMU_IMG create -f luks \ 720 --object secret,id=sec0,data=hunter0 \ 721 -o key-secret=sec0 \ 722 -o iter-time=10 \ 723 "$file" \ 724 1M \ 725 2>&1 726 ) 727 status=$? 728 729 IMGFMT='luks' _rm_test_img "$file" 730 731 if [ $status != 0 ]; then 732 reason=$(echo "$output" | grep "$file:" | $SED -e "s#.*$file: *##") 733 if [ -z "$reason" ]; then 734 reason="Failed to create a LUKS image" 735 fi 736 _notrun "$reason" 737 fi 738} 739 740# this test requires that a specified command (executable) exists 741# 742_require_command() 743{ 744 if [ "$1" = "QEMU" ]; then 745 c=$QEMU_PROG 746 elif [ "$1" = "QEMU_IMG" ]; then 747 c=$QEMU_IMG_PROG 748 elif [ "$1" = "QEMU_IO" ]; then 749 c=$QEMU_IO_PROG 750 elif [ "$1" = "QEMU_NBD" ]; then 751 c=$QEMU_NBD_PROG 752 else 753 eval c=\$$1 754 fi 755 [ -x "$c" ] || _notrun "$1 utility required, skipped this test" 756} 757 758# Check that a set of drivers has been whitelisted in the QEMU binary 759# 760_require_drivers() 761{ 762 available=$($QEMU -drive format=help | \ 763 sed -e '/Supported formats:/!d' -e 's/Supported formats://') 764 for driver 765 do 766 if ! echo "$available" | grep -q " $driver\( \|$\)"; then 767 _notrun "$driver not available" 768 fi 769 done 770} 771 772# Check that we have a file system that allows huge (but very sparse) files 773# 774_require_large_file() 775{ 776 if ! truncate --size="$1" "$TEST_IMG"; then 777 _notrun "file system on $TEST_DIR does not support large enough files" 778 fi 779 rm "$TEST_IMG" 780} 781 782# Check that a set of devices is available in the QEMU binary 783# 784_require_devices() 785{ 786 available=$($QEMU -M none -device help | \ 787 grep ^name | sed -e 's/^name "//' -e 's/".*$//') 788 for device 789 do 790 if ! echo "$available" | grep -q "$device" ; then 791 _notrun "$device not available" 792 fi 793 done 794} 795 796# make sure this script returns success 797true 798