tests/test-eflags.sh

   1 #!/usr/bin/env bash
   2 # nbdkit
   3 # Copyright (C) 2018-2019 Red Hat Inc.
   4 #
   5 # Redistribution and use in source and binary forms, with or without
   6 # modification, are permitted provided that the following conditions are
   7 # met:
   8 #
   9 # * Redistributions of source code must retain the above copyright
  10 # notice, this list of conditions and the following disclaimer.
  11 #
  12 # * Redistributions in binary form must reproduce the above copyright
  13 # notice, this list of conditions and the following disclaimer in the
  14 # documentation and/or other materials provided with the distribution.
  15 #
  16 # * Neither the name of Red Hat nor the names of its contributors may be
  17 # used to endorse or promote products derived from this software without
  18 # specific prior written permission.
  19 #
  20 # THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
  21 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22 # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  23 # PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
  24 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  27 # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  28 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  29 # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  30 # OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31 # SUCH DAMAGE.
  32
  33 # Test export flags.
  34 #
  35 # Run nbdkit with various can_* callbacks defined and with or without
  36 # the -r flag, and check that nbdkit constructs the export flags
  37 # controlling READ_ONLY, ROTATIONAL, SEND_TRIM, etc. as expected.
  38 #
  39 # We use the shell plugin because it gives maximum control over the
  40 # can_* callbacks (at least, max without having to write a C plugin).
  41
  42 source ./functions.sh
  43 set -e
  44
  45 requires qemu-nbd --version
  46
  47 # This test uses the ‘qemu-nbd --list’ option added in qemu 4.0.
  48 if ! qemu-nbd --help | grep -sq -- --list; then
  49     echo "$0: skipping because qemu-nbd does not support the --list option"
  50     exit 77
  51 fi
  52
  53 files="eflags.out"
  54 late_args=
  55 rm -f $files
  56 cleanup_fn rm -f $files
  57
  58 # The export flags.
  59 # See also common/protocol/protocol.h
  60 HAS_FLAGS=$((         1 <<  0 ))
  61 READ_ONLY=$((         1 <<  1 ))
  62 SEND_FLUSH=$((        1 <<  2 ))
  63 SEND_FUA=$((          1 <<  3 ))
  64 ROTATIONAL=$((        1 <<  4 ))
  65 SEND_TRIM=$((         1 <<  5 ))
  66 SEND_WRITE_ZEROES=$(( 1 <<  6 ))
  67 SEND_DF=$((           1 <<  7 ))
  68 CAN_MULTI_CONN=$((    1 <<  8 ))
  69 SEND_RESIZE=$((       1 <<  9 ))
  70 SEND_CACHE=$((        1 << 10 ))
  71 SEND_FAST_ZERO=$((    1 << 11 ))
  72
  73 do_nbdkit ()
  74 {
  75     nbdkit -v -U - "$@" sh - $late_args --run 'qemu-nbd --list -k $unixsocket' |
  76         grep -E "flags: 0x" | grep -Eoi '0x[a-f0-9]+' > eflags.out
  77     printf eflags=; cat eflags.out
  78
  79     # Convert hex flags to decimal and assign it to $eflags.
  80     eflags=$(printf "%d" $(cat eflags.out))
  81 }
  82
  83 fail ()
  84 {
  85     echo "error: $@ (actual flags were $(printf 0x%x $eflags))"
  86     exit 1
  87 }
  88
  89 #----------------------------------------------------------------------
  90 # can_write=false
  91 #
  92 # nbdkit supports DF if client requests SR.
  93
  94 do_nbdkit <<'EOF'
  95 case "$1" in
  96      get_size) echo 1M ;;
  97      *) exit 2 ;;
  98 esac
  99 EOF
 100
 101 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 102     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 103
 104 #----------------------------------------------------------------------
 105 # --no-sr
 106 # can_write=false
 107 #
 108 # When SR is disabled, so is the DF flag.
 109
 110 do_nbdkit --no-sr <<'EOF'
 111 case "$1" in
 112      get_size) echo 1M ;;
 113      *) exit 2 ;;
 114 esac
 115 EOF
 116
 117 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY )) ] ||
 118     fail "$LINENO: expected HAS_FLAGS|READ_ONLY"
 119
 120 #----------------------------------------------------------------------
 121 # -r
 122 # can_write=false
 123
 124 do_nbdkit -r <<'EOF'
 125 case "$1" in
 126      get_size) echo 1M ;;
 127      *) exit 2 ;;
 128 esac
 129 EOF
 130
 131 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 132     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 133
 134 #----------------------------------------------------------------------
 135 # can_write=true
 136 #
 137 # NBD_FLAG_SEND_WRITE_ZEROES and NBD_FLAG_SEND_FAST_ZERO are set on writable
 138 # connections even when can_zero returns false, because nbdkit reckons it
 139 # can emulate zeroing using pwrite.
 140
 141 do_nbdkit <<'EOF'
 142 case "$1" in
 143      get_size) echo 1M ;;
 144      can_write) exit 0 ;;
 145      *) exit 2 ;;
 146 esac
 147 EOF
 148
 149 [ $eflags -eq $(( HAS_FLAGS|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO )) ] ||
 150     fail "$LINENO: expected HAS_FLAGS|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO"
 151
 152 #----------------------------------------------------------------------
 153 # --filter=nozero
 154 # can_write=true
 155 #
 156 # NBD_FLAG_SEND_WRITE_ZEROES is omitted when a filter says so.
 157
 158 do_nbdkit --filter=nozero <<'EOF'
 159 case "$1" in
 160      get_size) echo 1M ;;
 161      can_write) exit 0 ;;
 162      *) exit 2 ;;
 163 esac
 164 EOF
 165
 166 [ $eflags -eq $(( HAS_FLAGS|SEND_DF )) ] ||
 167     fail "$LINENO: expected HAS_FLAGS|SEND_DF"
 168
 169 #----------------------------------------------------------------------
 170 # --no=sr
 171 # --filter=nozero
 172 # can_write=true
 173 #
 174 # Absolute minimum in flags.
 175
 176 do_nbdkit --no-sr --filter=nozero <<'EOF'
 177 case "$1" in
 178      get_size) echo 1M ;;
 179      can_write) exit 0 ;;
 180      *) exit 2 ;;
 181 esac
 182 EOF
 183
 184 [ $eflags -eq $(( HAS_FLAGS )) ] ||
 185     fail "$LINENO: expected HAS_FLAGS"
 186
 187 #----------------------------------------------------------------------
 188 # -r
 189 # can_write=true
 190 #
 191 # The -r flag overrides the plugin so this behaves as if can_write is
 192 # false.
 193
 194 do_nbdkit -r <<'EOF'
 195 case "$1" in
 196      get_size) echo 1M ;;
 197      can_write) exit 0 ;;
 198      *) exit 2 ;;
 199 esac
 200 EOF
 201
 202 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 203     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 204
 205 #----------------------------------------------------------------------
 206 # can_write=false
 207 # can_trim=true
 208 # can_zero=true
 209 #
 210 # If writing is not possible then trim and zero are always disabled.
 211
 212 do_nbdkit <<'EOF'
 213 case "$1" in
 214      get_size) echo 1M ;;
 215      can_write) exit 3 ;;
 216      can_trim) exit 0 ;;
 217      can_zero) exit 0 ;;
 218      *) exit 2 ;;
 219 esac
 220 EOF
 221
 222 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 223     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 224
 225 #----------------------------------------------------------------------
 226 # -r
 227 # can_write=false
 228 # can_trim=true
 229 # can_zero=true
 230 #
 231 # This is a formality, but check it's the same as above.
 232
 233 do_nbdkit -r <<'EOF'
 234 case "$1" in
 235      get_size) echo 1M ;;
 236      can_write) exit 3 ;;
 237      can_trim) exit 0 ;;
 238      can_zero) exit 0 ;;
 239      *) exit 2 ;;
 240 esac
 241 EOF
 242
 243 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 244     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 245
 246 #----------------------------------------------------------------------
 247 # can_write=true
 248 # can_trim=true
 249
 250 do_nbdkit <<'EOF'
 251 case "$1" in
 252      get_size) echo 1M ;;
 253      can_write) exit 0 ;;
 254      can_trim) exit 0 ;;
 255      *) exit 2 ;;
 256 esac
 257 EOF
 258
 259 [ $eflags -eq $(( HAS_FLAGS|SEND_TRIM|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO )) ] ||
 260     fail "$LINENO: expected HAS_FLAGS|SEND_TRIM|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO"
 261
 262 #----------------------------------------------------------------------
 263 # can_write=true
 264 # is_rotational=true
 265
 266 do_nbdkit <<'EOF'
 267 case "$1" in
 268      get_size) echo 1M ;;
 269      can_write) exit 0 ;;
 270      is_rotational) exit 0 ;;
 271      *) exit 2 ;;
 272 esac
 273 EOF
 274
 275 [ $eflags -eq $(( HAS_FLAGS|ROTATIONAL|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO )) ] ||
 276     fail "$LINENO: expected HAS_FLAGS|ROTATIONAL|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO"
 277
 278 #----------------------------------------------------------------------
 279 # -r
 280 # can_write=true
 281 # is_rotational=true
 282
 283 do_nbdkit -r <<'EOF'
 284 case "$1" in
 285      get_size) echo 1M ;;
 286      can_write) exit 0 ;;
 287      is_rotational) exit 0 ;;
 288      *) exit 2 ;;
 289 esac
 290 EOF
 291
 292 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|ROTATIONAL|SEND_DF )) ] ||
 293     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|ROTATIONAL|SEND_DF"
 294
 295 #----------------------------------------------------------------------
 296 # can_write=true
 297 # can_fua=native
 298
 299 do_nbdkit <<'EOF'
 300 case "$1" in
 301      get_size) echo 1M ;;
 302      can_write) exit 0 ;;
 303      can_fua) echo "native" ;;
 304      *) exit 2 ;;
 305 esac
 306 EOF
 307
 308 [ $eflags -eq $(( HAS_FLAGS|SEND_FUA|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO )) ] ||
 309     fail "$LINENO: expected HAS_FLAGS|SEND_FUA|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO"
 310
 311 #----------------------------------------------------------------------
 312 # -r
 313 # can_write=true
 314 # can_fua=native
 315 #
 316 # Setting read-only should ignore can_fua.
 317
 318 do_nbdkit -r <<'EOF'
 319 case "$1" in
 320      get_size) echo 1M ;;
 321      can_write) exit 0 ;;
 322      can_fua) echo "native" ;;
 323      *) exit 2 ;;
 324 esac
 325 EOF
 326
 327 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 328     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 329
 330 #----------------------------------------------------------------------
 331 # can_write=true
 332 # can_flush=true
 333 #
 334 # When can_flush is true, nbdkit reckons it can emulate fua with flush.
 335
 336 do_nbdkit <<'EOF'
 337 case "$1" in
 338      get_size) echo 1M ;;
 339      can_write) exit 0 ;;
 340      can_flush) exit 0 ;;
 341      *) exit 2 ;;
 342 esac
 343 EOF
 344
 345 [ $eflags -eq $(( HAS_FLAGS|SEND_FLUSH|SEND_FUA|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO )) ] ||
 346     fail "$LINENO: expected HAS_FLAGS|SEND_FLUSH|SEND_FUA|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO"
 347
 348 #----------------------------------------------------------------------
 349 # can_write=true
 350 # can_flush=true
 351 # can_fua=none
 352 #
 353 # Explicit request for no fua emulation.
 354
 355 do_nbdkit <<'EOF'
 356 case "$1" in
 357      get_size) echo 1M ;;
 358      can_write) exit 0 ;;
 359      can_flush) exit 0 ;;
 360      can_fua) echo "none" ;;
 361      *) exit 2 ;;
 362 esac
 363 EOF
 364
 365 [ $eflags -eq $(( HAS_FLAGS|SEND_FLUSH|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO )) ] ||
 366     fail "$LINENO: expected HAS_FLAGS|SEND_FLUSH|SEND_WRITE_ZEROES|SEND_DF|SEND_FAST_ZERO"
 367
 368 #----------------------------------------------------------------------
 369 # -r
 370 # can_multi_conn=true
 371
 372 do_nbdkit -r <<'EOF'
 373 case "$1" in
 374      get_size) echo 1M ;;
 375      can_multi_conn) exit 0 ;;
 376      *) exit 2 ;;
 377 esac
 378 EOF
 379
 380 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF|CAN_MULTI_CONN )) ] ||
 381     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF|CAN_MULTI_CONN"
 382
 383 #----------------------------------------------------------------------
 384 # -r
 385 # --filter=noparallel serialize=connections
 386 # can_multi_conn=true
 387 #
 388 # A single-threaded server does not allow multiple connections.
 389
 390 late_args="serialize=connections" do_nbdkit -r --filter=noparallel <<'EOF'
 391 case "$1" in
 392      get_size) echo 1M ;;
 393      can_multi_conn) exit 0 ;;
 394      *) exit 2 ;;
 395 esac
 396 EOF
 397
 398 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 399     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 400
 401 #----------------------------------------------------------------------
 402 # -r
 403 # thread_model=serialize_connections
 404 # can_multi_conn=true
 405 #
 406 # A single-threaded server does not allow multiple connections.
 407
 408 do_nbdkit -r <<'EOF'
 409 case "$1" in
 410      get_size) echo 1M ;;
 411      can_multi_conn) exit 0 ;;
 412      thread_model) echo "serialize_connections" ;;
 413      *) exit 2 ;;
 414 esac
 415 EOF
 416
 417 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 418     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 419
 420 #----------------------------------------------------------------------
 421 # -r
 422 # can_cache=emulate
 423
 424 do_nbdkit -r <<'EOF'
 425 case "$1" in
 426      get_size) echo 1M ;;
 427      can_cache) echo "emulate" ;;
 428      *) exit 2 ;;
 429 esac
 430 EOF
 431
 432 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF|SEND_CACHE )) ] ||
 433     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF|SEND_CACHE"
 434
 435 #----------------------------------------------------------------------
 436 # -r
 437 # --filter=nocache cachemode=none
 438 # can_cache=emulate
 439 #
 440 # Filters override the plugin's choice of caching.
 441
 442 late_args="cachemode=none" do_nbdkit -r --filter=nocache <<'EOF'
 443 case "$1" in
 444      get_size) echo 1M ;;
 445      can_cache) echo "emulate" ;;
 446      *) exit 2 ;;
 447 esac
 448 EOF
 449
 450 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 451     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 452
 453 #----------------------------------------------------------------------
 454 # -r
 455 # can_fast_zero=true
 456 #
 457 # Fast zero support isn't advertised without regular zero support
 458
 459 do_nbdkit -r <<'EOF'
 460 case "$1" in
 461      get_size) echo 1M ;;
 462      can_fast_zero) exit 0 ;;
 463      *) exit 2 ;;
 464 esac
 465 EOF
 466
 467 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 468     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 469
 470 #----------------------------------------------------------------------
 471 # --filter=nozero
 472 # can_write=true
 473 # can_fast_zero=true
 474 #
 475 # Fast zero support isn't advertised without regular zero support
 476
 477 do_nbdkit --filter=nozero <<'EOF'
 478 case "$1" in
 479      get_size) echo 1M ;;
 480      can_write) exit 0 ;;
 481      can_fast_zero) exit 0 ;;
 482      *) exit 2 ;;
 483 esac
 484 EOF
 485
 486 [ $eflags -eq $(( HAS_FLAGS|SEND_DF )) ] ||
 487     fail "$LINENO: expected HAS_FLAGS|SEND_DF"
 488
 489 #----------------------------------------------------------------------
 490 # can_write=true
 491 # can_zero=true
 492 #
 493 # Fast zero support is omitted for a plugin that has .zero but did not opt in
 494
 495 do_nbdkit -r <<'EOF'
 496 case "$1" in
 497      get_size) echo 1M ;;
 498      can_write) exit 0 ;;
 499      can_zero) exit 0 ;;
 500      *) exit 2 ;;
 501 esac
 502 EOF
 503
 504 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 505     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 506
 507 #----------------------------------------------------------------------
 508 # can_write=true
 509 # can_zero=true
 510 # can_fast_zero=false
 511 #
 512 # Fast zero support is omitted if the plugin says so
 513
 514 do_nbdkit -r <<'EOF'
 515 case "$1" in
 516      get_size) echo 1M ;;
 517      can_write) exit 0 ;;
 518      can_zero) exit 0 ;;
 519      can_fast_zero) exit 3 ;;
 520      *) exit 2 ;;
 521 esac
 522 EOF
 523
 524 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 525     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"
 526
 527 #----------------------------------------------------------------------
 528 # can_write=true
 529 # can_zero=false
 530 # can_fast_zero=false
 531 #
 532 # Fast zero support is omitted if the plugin says so
 533
 534 do_nbdkit -r <<'EOF'
 535 case "$1" in
 536      get_size) echo 1M ;;
 537      can_write) exit 0 ;;
 538      can_fast_zero) exit 3 ;;
 539      *) exit 2 ;;
 540 esac
 541 EOF
 542
 543 [ $eflags -eq $(( HAS_FLAGS|READ_ONLY|SEND_DF )) ] ||
 544     fail "$LINENO: expected HAS_FLAGS|READ_ONLY|SEND_DF"