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