qemu/tests/qemu-iotests/common.rc

   1 #!/bin/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 dd()
  21 {
  22    if [ "$HOSTOS" == "Linux" ]
  23    then
  24         command dd --help | grep noxfer > /dev/null 2>&1
  25
  26         if [ "$?" -eq 0 ]
  27             then
  28                 command dd status=noxfer $@
  29             else
  30                 command dd $@
  31             fi
  32    else
  33         command dd $@
  34    fi
  35 }
  36
  37 # poke_file 'test.img' 512 '\xff\xfe'
  38 poke_file()
  39 {
  40     printf "$3" | dd "of=$1" bs=1 "seek=$2" conv=notrunc &>/dev/null
  41 }
  42
  43 # we need common.config
  44 if [ "$iam" != "check" ]
  45 then
  46     if ! . ./common.config
  47         then
  48         echo "$iam: failed to source common.config"
  49         exit 1
  50     fi
  51 fi
  52
  53 # make sure we have a standard umask
  54 umask 022
  55
  56 if [ "$IMGPROTO" = "file" ]; then
  57     TEST_IMG=$TEST_DIR/t.$IMGFMT
  58 elif [ "$IMGPROTO" = "nbd" ]; then
  59     TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
  60     TEST_IMG="nbd:127.0.0.1:10810"
  61 elif [ "$IMGPROTO" = "ssh" ]; then
  62     TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
  63     TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE"
  64 elif [ "$IMGPROTO" = "nfs" ]; then
  65     TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
  66     TEST_IMG=$TEST_DIR/t.$IMGFMT
  67 elif [ "$IMGPROTO" = "archipelago" ]; then
  68     TEST_IMG="archipelago:at.$IMGFMT"
  69 else
  70     TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
  71 fi
  72
  73 _optstr_add()
  74 {
  75     if [ -n "$1" ]; then
  76         echo "$1,$2"
  77     else
  78         echo "$2"
  79     fi
  80 }
  81
  82 _set_default_imgopts()
  83 {
  84     if [ "$IMGFMT" == "qcow2" ] && ! (echo "$IMGOPTS" | grep "compat=" > /dev/null); then
  85         IMGOPTS=$(_optstr_add "$IMGOPTS" "compat=1.1")
  86     fi
  87 }
  88
  89 _use_sample_img()
  90 {
  91     SAMPLE_IMG_FILE="${1%\.bz2}"
  92     TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
  93     bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
  94     if [ $? -ne 0 ]
  95     then
  96         echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
  97         exit 1
  98     fi
  99 }
 100
 101 _make_test_img()
 102 {
 103     # extra qemu-img options can be added by tests
 104     # at least one argument (the image size) needs to be added
 105     local extra_img_options=""
 106     local image_size=$*
 107     local optstr=""
 108     local img_name=""
 109     local use_backing=0
 110     local backing_file=""
 111
 112     if [ -n "$TEST_IMG_FILE" ]; then
 113         img_name=$TEST_IMG_FILE
 114     else
 115         img_name=$TEST_IMG
 116     fi
 117
 118     if [ -n "$IMGOPTS" ]; then
 119         optstr=$(_optstr_add "$optstr" "$IMGOPTS")
 120     fi
 121
 122     if [ "$1" = "-b" ]; then
 123         use_backing=1
 124         backing_file=$2
 125         image_size=$3
 126     fi
 127     if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then
 128         optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE")
 129     fi
 130
 131     if [ -n "$optstr" ]; then
 132         extra_img_options="-o $optstr $extra_img_options"
 133     fi
 134
 135     # XXX(hch): have global image options?
 136     (
 137      if [ $use_backing = 1 ]; then
 138         $QEMU_IMG create -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1
 139      else
 140         $QEMU_IMG create -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1
 141      fi
 142     ) | _filter_img_create
 143
 144     # Start an NBD server on the image file, which is what we'll be talking to
 145     if [ $IMGPROTO = "nbd" ]; then
 146         eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE &"
 147         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
 148     fi
 149 }
 150
 151 _rm_test_img()
 152 {
 153     local img=$1
 154     if [ "$IMGFMT" = "vmdk" ]; then
 155         # Remove all the extents for vmdk
 156         "$QEMU_IMG" info "$img" 2>/dev/null | grep 'filename:' | cut -f 2 -d: \
 157             | xargs -I {} rm -f "{}"
 158     fi
 159     rm -f "$img"
 160 }
 161
 162 _cleanup_test_img()
 163 {
 164     case "$IMGPROTO" in
 165
 166         nbd)
 167             if [ -f "${TEST_DIR}/qemu-nbd.pid" ]; then
 168                 local QEMU_NBD_PID
 169                 read QEMU_NBD_PID < "${TEST_DIR}/qemu-nbd.pid"
 170                 kill ${QEMU_NBD_PID}
 171                 rm -f "${TEST_DIR}/qemu-nbd.pid"
 172             fi
 173             rm -f "$TEST_IMG_FILE"
 174             ;;
 175         file)
 176             _rm_test_img "$TEST_DIR/t.$IMGFMT"
 177             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
 178             _rm_test_img "$TEST_DIR/t.$IMGFMT.base"
 179             if [ -n "$SAMPLE_IMG_FILE" ]
 180             then
 181                 rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
 182             fi
 183             ;;
 184
 185         rbd)
 186             rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null
 187             ;;
 188
 189         archipelago)
 190             vlmc remove "at.$IMGFMT" > /dev/null
 191             ;;
 192
 193         sheepdog)
 194             collie vdi delete "$TEST_DIR/t.$IMGFMT"
 195             ;;
 196
 197     esac
 198 }
 199
 200 _check_test_img()
 201 {
 202     $QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1 | _filter_testdir | \
 203         sed -e '/allocated.*fragmented.*compressed clusters/d' \
 204             -e 's/qemu-img: This image format does not support checks/No errors were found on the image./' \
 205             -e '/Image end offset: [0-9]\+/d'
 206 }
 207
 208 _img_info()
 209 {
 210     if [[ "$1" == "--format-specific" ]]; then
 211         local format_specific=1
 212         shift
 213     else
 214         local format_specific=0
 215     fi
 216
 217     discard=0
 218     regex_json_spec_start='^ *"format-specific": \{'
 219     $QEMU_IMG info "$@" "$TEST_IMG" 2>&1 | \
 220         sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
 221             -e "s#$TEST_DIR#TEST_DIR#g" \
 222             -e "s#$IMGFMT#IMGFMT#g" \
 223             -e "/^disk size:/ D" \
 224             -e "/actual-size/ D" | \
 225         while IFS='' read line; do
 226             if [[ $format_specific == 1 ]]; then
 227                 discard=0
 228             elif [[ $line == "Format specific information:" ]]; then
 229                 discard=1
 230             elif [[ $line =~ $regex_json_spec_start ]]; then
 231                 discard=2
 232                 regex_json_spec_end="^${line%%[^ ]*}\\},? *$"
 233             fi
 234             if [[ $discard == 0 ]]; then
 235                 echo "$line"
 236             elif [[ $discard == 1 && ! $line ]]; then
 237                 echo
 238                 discard=0
 239             elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
 240                 discard=0
 241             fi
 242         done
 243 }
 244
 245 _get_pids_by_name()
 246 {
 247     if [ $# -ne 1 ]
 248     then
 249         echo "Usage: _get_pids_by_name process-name" 1>&2
 250         exit 1
 251     fi
 252
 253     # Algorithm ... all ps(1) variants have a time of the form MM:SS or
 254     # HH:MM:SS before the psargs field, use this as the search anchor.
 255     #
 256     # Matches with $1 (process-name) occur if the first psarg is $1
 257     # or ends in /$1 ... the matching uses sed's regular expressions,
 258     # so passing a regex into $1 will work.
 259
 260     ps $PS_ALL_FLAGS \
 261     | sed -n \
 262         -e 's/$/ /' \
 263         -e 's/[         ][         ]*/ /g' \
 264         -e 's/^ //' \
 265         -e 's/^[^ ]* //' \
 266         -e "/[0-9]:[0-9][0-9]  *[^ ]*\/$1 /s/ .*//p" \
 267         -e "/[0-9]:[0-9][0-9]  *$1 /s/ .*//p"
 268 }
 269
 270 # fqdn for localhost
 271 #
 272 _get_fqdn()
 273 {
 274     host=`hostname`
 275     $NSLOOKUP_PROG $host | $AWK_PROG '{ if ($1 == "Name:") print $2 }'
 276 }
 277
 278 # check if run as root
 279 #
 280 _need_to_be_root()
 281 {
 282     id=`id | $SED_PROG -e 's/(.*//' -e 's/.*=//'`
 283     if [ "$id" -ne 0 ]
 284     then
 285         echo "Arrgh ... you need to be root (not uid=$id) to run this test"
 286         exit 1
 287     fi
 288 }
 289
 290 # bail out, setting up .notrun file
 291 #
 292 _notrun()
 293 {
 294     echo "$*" >"$OUTPUT_DIR/$seq.notrun"
 295     echo "$seq not run: $*"
 296     status=0
 297     exit
 298 }
 299
 300 # just plain bail out
 301 #
 302 _fail()
 303 {
 304     echo "$*" | tee -a "$OUTPUT_DIR/$seq.full"
 305     echo "(see $seq.full for details)"
 306     status=1
 307     exit 1
 308 }
 309
 310 # tests whether $IMGFMT is one of the supported image formats for a test
 311 #
 312 _supported_fmt()
 313 {
 314     # "generic" is suitable for most image formats. For some formats it doesn't
 315     # work, however (most notably read-only formats), so they can opt out by
 316     # setting IMGFMT_GENERIC to false.
 317     for f; do
 318         if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then
 319             return
 320         fi
 321     done
 322
 323     _notrun "not suitable for this image format: $IMGFMT"
 324 }
 325
 326 # tests whether $IMGPROTO is one of the supported image protocols for a test
 327 #
 328 _supported_proto()
 329 {
 330     for f; do
 331         if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then
 332             return
 333         fi
 334     done
 335
 336     _notrun "not suitable for this image protocol: $IMGPROTO"
 337 }
 338
 339 # tests whether the host OS is one of the supported OSes for a test
 340 #
 341 _supported_os()
 342 {
 343     for h
 344     do
 345         if [ "$h" = "$HOSTOS" ]
 346         then
 347             return
 348         fi
 349     done
 350
 351     _notrun "not suitable for this OS: $HOSTOS"
 352 }
 353
 354 _supported_cache_modes()
 355 {
 356     for mode; do
 357         if [ "$mode" = "$CACHEMODE" ]; then
 358             return
 359         fi
 360     done
 361     _notrun "not suitable for cache mode: $CACHEMODE"
 362 }
 363
 364 _default_cache_mode()
 365 {
 366     if $CACHEMODE_IS_DEFAULT; then
 367         CACHEMODE="$1"
 368         QEMU_IO="$QEMU_IO --cache $1"
 369         return
 370     fi
 371 }
 372
 373 _unsupported_imgopts()
 374 {
 375     for bad_opt
 376     do
 377         if echo "$IMGOPTS" | grep -q 2>/dev/null "$bad_opt"
 378         then
 379             _notrun "not suitable for image option: $bad_opt"
 380         fi
 381     done
 382 }
 383
 384 # this test requires that a specified command (executable) exists
 385 #
 386 _require_command()
 387 {
 388     if [ "$1" = "QEMU" ]; then
 389         c=$QEMU_PROG
 390     elif [ "$1" = "QEMU_IMG" ]; then
 391         c=$QEMU_IMG_PROG
 392     elif [ "$1" = "QEMU_IO" ]; then
 393         c=$QEMU_IO_PROG
 394     elif [ "$1" = "QEMU_NBD" ]; then
 395         c=$QEMU_NBD_PROG
 396     else
 397         eval c=\$$1
 398     fi
 399     [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
 400 }
 401
 402 _full_imgfmt_details()
 403 {
 404     if [ -n "$IMGOPTS" ]; then
 405         echo "$IMGFMT ($IMGOPTS)"
 406     else
 407         echo "$IMGFMT"
 408     fi
 409 }
 410
 411 _full_imgproto_details()
 412 {
 413     echo "$IMGPROTO"
 414 }
 415
 416 _full_platform_details()
 417 {
 418     os=`uname -s`
 419     host=`hostname -s`
 420     kernel=`uname -r`
 421     platform=`uname -m`
 422     echo "$os/$platform $host $kernel"
 423 }
 424
 425 _link_out_file()
 426 {
 427    if [ -z "$1" ]; then
 428       echo Error must pass \$seq.
 429       exit
 430    fi
 431    rm -f $1
 432    if [ "`uname`" == "IRIX64" ] || [ "`uname`" == "IRIX" ]; then
 433       ln -s $1.irix $1
 434    elif [ "`uname`" == "Linux" ]; then
 435       ln -s $1.linux $1
 436    else
 437       echo Error test $seq does not run on the operating system: `uname`
 438       exit
 439    fi
 440 }
 441
 442 _die()
 443 {
 444         echo $@
 445         exit 1
 446 }
 447
 448 # make sure this script returns success
 449 true