tests/qemu-iotests/common.rc

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