lustre/tests/replay-dual.sh

   1 #!/bin/bash
   2 # -*- mode: Bash; tab-width: 4; indent-tabs-mode: t; -*-
   3 # vim:shiftwidth=4:softtabstop=4:tabstop=4:
   4
   5 set -e
   6
   7 # bug number:  10124
   8 ALWAYS_EXCEPT="15c   $REPLAY_DUAL_EXCEPT"
   9
  10 SAVE_PWD=$PWD
  11 PTLDEBUG=${PTLDEBUG:--1}
  12 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  13 SETUP=${SETUP:-""}
  14 CLEANUP=${CLEANUP:-""}
  15 MOUNT_2=${MOUNT_2:-"yes"}
  16 . $LUSTRE/tests/test-framework.sh
  17
  18 init_test_env $@
  19 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  20 init_logging
  21
  22 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
  23
  24 [ "$SLOW" = "no" ] && EXCEPT_SLOW="21b"
  25
  26 build_test_filter
  27
  28 check_and_setup_lustre
  29 MOUNTED=$(mounted_lustre_filesystems)
  30 if ! $(echo $MOUNTED' ' | grep -w -q $MOUNT2' '); then
  31     zconf_mount $HOSTNAME $MOUNT2
  32     MOUNTED2=yes
  33 fi
  34
  35 assert_DIR
  36 rm -rf $DIR/[df][0-9]*
  37
  38 [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  39
  40 # LU-482 Avert LVM and VM inability to flush caches in pre .33 kernels
  41 if [ $LINUX_VERSION_CODE -lt $(version_code 2.6.33) ]; then
  42         sync
  43         do_facet $SINGLEMDS "sync; sleep 10; sync; sleep 10; sync"
  44 fi
  45
  46 LU482_FAILED=$(mktemp -u $TMP/$TESTSUITE.lu482.XXXXXX)
  47 test_0a() {
  48         echo "Check file is LU482_FAILED=$LU482_FAILED"
  49         touch $MOUNT2/$tfile-A # force sync FLD/SEQ update before barrier
  50         replay_barrier $SINGLEMDS
  51 #define OBD_FAIL_PTLRPC_FINISH_REPLAY | OBD_FAIL_ONCE
  52         touch $MOUNT2/$tfile
  53         createmany -o $MOUNT1/$tfile- 50
  54         $LCTL set_param fail_loc=0x80000514
  55         facet_failover $SINGLEMDS
  56         [ -f "$LU482_FAILED" ] && skip "LU-482 failure" && return 0
  57         client_up || return 1
  58         umount -f $MOUNT2
  59         client_up || return 1
  60         zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
  61         unlinkmany $MOUNT1/$tfile- 50 || return 2
  62         rm $MOUNT2/$tfile || return 3
  63         rm $MOUNT2/$tfile-A || return 4
  64 }
  65 run_test 0a "expired recovery with lost client"
  66
  67 if [ -f "$LU482_FAILED" ]; then
  68         log "Found check file $LU482_FAILED, aborting test script"
  69         rm -vf "$LU482_FAILED"
  70         complete $(basename $0) $SECONDS
  71         [ "$MOUNTED2" = yes ] && zconf_umount $HOSTNAME $MOUNT2 || true
  72         check_and_cleanup_lustre
  73         exit_status
  74 fi
  75
  76 test_0b() {
  77     replay_barrier $SINGLEMDS
  78     touch $MOUNT2/$tfile
  79     touch $MOUNT1/$tfile-2
  80     umount $MOUNT2
  81     facet_failover $SINGLEMDS
  82     umount -f $MOUNT1
  83     zconf_mount `hostname` $MOUNT1 || error "mount1 fais"
  84     zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
  85     checkstat $MOUNT1/$tfile-2 && return 1
  86     checkstat $MOUNT2/$tfile && return 2
  87     return 0
  88 }
  89 run_test 0b "lost client during waiting for next transno"
  90
  91 test_1() {
  92     touch $MOUNT1/a
  93     replay_barrier $SINGLEMDS
  94     touch $MOUNT2/b
  95
  96     fail $SINGLEMDS
  97     checkstat $MOUNT2/a || return 1
  98     checkstat $MOUNT1/b || return 2
  99     rm $MOUNT2/a $MOUNT1/b
 100     checkstat $MOUNT1/a && return 3
 101     checkstat $MOUNT2/b && return 4
 102     return 0
 103 }
 104
 105 run_test 1 "|X| simple create"
 106
 107
 108 test_2() {
 109     replay_barrier $SINGLEMDS
 110     mkdir $MOUNT1/adir
 111
 112     fail $SINGLEMDS
 113     checkstat $MOUNT2/adir || return 1
 114     rmdir $MOUNT2/adir
 115     checkstat $MOUNT2/adir && return 2
 116     return 0
 117 }
 118 run_test 2 "|X| mkdir adir"
 119
 120 test_3() {
 121     replay_barrier $SINGLEMDS
 122     mkdir $MOUNT1/adir
 123     mkdir $MOUNT2/adir/bdir
 124
 125     fail $SINGLEMDS
 126     checkstat $MOUNT2/adir      || return 1
 127     checkstat $MOUNT1/adir/bdir || return 2
 128     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 129     checkstat $MOUNT1/adir      && return 3
 130     checkstat $MOUNT2/adir/bdir && return 4
 131     return 0
 132 }
 133 run_test 3 "|X| mkdir adir, mkdir adir/bdir "
 134
 135 test_4() {
 136     mkdir $MOUNT1/adir
 137     replay_barrier $SINGLEMDS
 138     mkdir $MOUNT1/adir  && return 1
 139     mkdir $MOUNT2/adir/bdir
 140
 141     fail $SINGLEMDS
 142     checkstat $MOUNT2/adir      || return 2
 143     checkstat $MOUNT1/adir/bdir || return 3
 144
 145     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 146     checkstat $MOUNT1/adir      && return 4
 147     checkstat $MOUNT2/adir/bdir && return 5
 148     return 0
 149 }
 150 run_test 4 "|X| mkdir adir (-EEXIST), mkdir adir/bdir "
 151
 152
 153 test_5() {
 154     # multiclient version of replay_single.sh/test_8
 155     mcreate $MOUNT1/a
 156     multiop_bg_pause $MOUNT2/a o_tSc || return  1
 157     pid=$!
 158     rm -f $MOUNT1/a
 159     replay_barrier $SINGLEMDS
 160     kill -USR1 $pid
 161     wait $pid || return 1
 162
 163     fail $SINGLEMDS
 164     [ -e $MOUNT2/a ] && return 2
 165     return 0
 166 }
 167 run_test 5 "open, unlink |X| close"
 168
 169
 170 test_6() {
 171     mcreate $MOUNT1/a
 172     multiop_bg_pause $MOUNT2/a o_c || return 1
 173     pid1=$!
 174     multiop_bg_pause $MOUNT1/a o_c || return 1
 175     pid2=$!
 176     rm -f $MOUNT1/a
 177     replay_barrier $SINGLEMDS
 178     kill -USR1 $pid1
 179     wait $pid1 || return 1
 180
 181     fail $SINGLEMDS
 182     kill -USR1 $pid2
 183     wait $pid2 || return 1
 184     [ -e $MOUNT2/a ] && return 2
 185     return 0
 186 }
 187 run_test 6 "open1, open2, unlink |X| close1 [fail $SINGLEMDS] close2"
 188
 189 test_8() {
 190     replay_barrier $SINGLEMDS
 191     drop_reint_reply "mcreate $MOUNT1/$tfile"    || return 1
 192     fail $SINGLEMDS
 193     checkstat $MOUNT2/$tfile || return 2
 194     rm $MOUNT1/$tfile || return 3
 195
 196     return 0
 197 }
 198 run_test 8 "replay of resent request"
 199
 200 test_9() {
 201     replay_barrier $SINGLEMDS
 202     mcreate $MOUNT1/$tfile-1
 203     mcreate $MOUNT2/$tfile-2
 204     # drop first reint reply
 205     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
 206     fail $SINGLEMDS
 207     do_facet $SINGLEMDS lctl set_param fail_loc=0
 208
 209     rm $MOUNT1/$tfile-[1,2] || return 1
 210
 211     return 0
 212 }
 213 run_test 9 "resending a replayed create"
 214
 215 test_10() {
 216     mcreate $MOUNT1/$tfile-1
 217     replay_barrier $SINGLEMDS
 218     munlink $MOUNT1/$tfile-1
 219     mcreate $MOUNT2/$tfile-2
 220     # drop first reint reply
 221     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
 222     fail $SINGLEMDS
 223     do_facet $SINGLEMDS lctl set_param fail_loc=0
 224
 225     checkstat $MOUNT1/$tfile-1 && return 1
 226     checkstat $MOUNT1/$tfile-2 || return 2
 227     rm $MOUNT1/$tfile-2
 228
 229     return 0
 230 }
 231 run_test 10 "resending a replayed unlink"
 232
 233 test_11() {
 234     replay_barrier $SINGLEMDS
 235     mcreate $MOUNT1/$tfile-1
 236     mcreate $MOUNT2/$tfile-2
 237     mcreate $MOUNT1/$tfile-3
 238     mcreate $MOUNT2/$tfile-4
 239     mcreate $MOUNT1/$tfile-5
 240     # drop all reint replies for a while
 241     do_facet $SINGLEMDS lctl set_param fail_loc=0x0119
 242     # note that with this fail_loc set, facet_failover df will fail
 243     facet_failover $SINGLEMDS
 244     #sleep for while, let both clients reconnect and timeout
 245     sleep $((TIMEOUT * 2))
 246     do_facet $SINGLEMDS lctl set_param fail_loc=0
 247
 248     rm $MOUNT1/$tfile-[1-5] || return 1
 249
 250     return 0
 251 }
 252 run_test 11 "both clients timeout during replay"
 253
 254 test_12() {
 255     replay_barrier $SINGLEMDS
 256
 257     multiop_bg_pause $DIR/$tfile mo_c || return 1
 258     MULTIPID=$!
 259
 260 #define OBD_FAIL_LDLM_ENQUEUE            0x302
 261     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000302
 262     facet_failover $SINGLEMDS
 263     do_facet $SINGLEMDS lctl set_param fail_loc=0
 264     clients_up || return 1
 265
 266     ls $DIR/$tfile
 267     kill -USR1 $MULTIPID || return 3
 268     wait $MULTIPID || return 4
 269     $CHECKSTAT -t file $DIR/$tfile || return 2
 270     rm $DIR/$tfile
 271
 272     return 0
 273 }
 274 run_test 12 "open resend timeout"
 275
 276 test_13() {
 277     multiop_bg_pause $DIR/$tfile mo_c || return 1
 278     MULTIPID=$!
 279
 280     replay_barrier $SINGLEMDS
 281
 282     kill -USR1 $MULTIPID || return 3
 283     wait $MULTIPID || return 4
 284
 285     # drop close
 286     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000115
 287     facet_failover $SINGLEMDS
 288     do_facet $SINGLEMDS lctl set_param fail_loc=0
 289     clients_up || return 1
 290
 291     ls $DIR/$tfile
 292     $CHECKSTAT -t file $DIR/$tfile || return 2
 293     rm $DIR/$tfile
 294
 295     return 0
 296 }
 297 run_test 13 "close resend timeout"
 298
 299 # test 14a removed after 18143 because it shouldn't fail anymore and do the same
 300 # as test_15a
 301
 302 test_14b() {
 303     wait_mds_ost_sync
 304     wait_destroy_complete
 305     BEFOREUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 306     mkdir -p $MOUNT1/$tdir
 307     $SETSTRIPE -i 0 $MOUNT1/$tdir
 308     replay_barrier $SINGLEMDS
 309     createmany -o $MOUNT1/$tdir/$tfile- 5
 310
 311     $SETSTRIPE -i 0 $MOUNT2/f14b-3
 312     echo "data" > $MOUNT2/f14b-3
 313     createmany -o $MOUNT1/$tdir/$tfile-3- 5
 314     umount $MOUNT2
 315
 316     fail $SINGLEMDS
 317     wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
 318
 319     # first 25 files should have been replayed
 320     unlinkmany $MOUNT1/$tdir/$tfile- 5 || return 2
 321     unlinkmany $MOUNT1/$tdir/$tfile-3- 5 || return 3
 322
 323     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 324
 325     wait_mds_ost_sync || return 4
 326     wait_destroy_complete || return 5
 327
 328     AFTERUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 329     log "before $BEFOREUSED, after $AFTERUSED"
 330     [ $AFTERUSED -ne $BEFOREUSED ] && \
 331         error "after $AFTERUSED > before $BEFOREUSED" && return 4
 332     return 0
 333 }
 334 run_test 14b "delete ost orphans if gap occured in objids due to VBR"
 335
 336 test_15a() { # was test_15
 337     replay_barrier $SINGLEMDS
 338     createmany -o $MOUNT1/$tfile- 25
 339     createmany -o $MOUNT2/$tfile-2- 1
 340     umount $MOUNT2
 341
 342     fail $SINGLEMDS
 343
 344     unlinkmany $MOUNT1/$tfile- 25 || return 2
 345     [ -e $MOUNT1/$tfile-2-0 ] && error "$tfile-2-0 exists"
 346
 347     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 348     return 0
 349 }
 350 run_test 15a "timeout waiting for lost client during replay, 1 client completes"
 351
 352 test_15c() {
 353     replay_barrier $SINGLEMDS
 354     for ((i = 0; i < 2000; i++)); do
 355         echo "data" > "$MOUNT2/${tfile}-$i" || error "create ${tfile}-$i failed"
 356     done
 357     umount $MOUNT2
 358
 359     fail $SINGLEMDS
 360
 361     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 362     return 0
 363 }
 364 run_test 15c "remove multiple OST orphans"
 365
 366 test_16() {
 367     replay_barrier $SINGLEMDS
 368     createmany -o $MOUNT1/$tfile- 25
 369     createmany -o $MOUNT2/$tfile-2- 1
 370     umount $MOUNT2
 371
 372     facet_failover $SINGLEMDS
 373     sleep $TIMEOUT
 374     fail $SINGLEMDS
 375
 376     unlinkmany $MOUNT1/$tfile- 25 || return 2
 377
 378     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 379     return 0
 380
 381 }
 382 run_test 16 "fail MDS during recovery (3571)"
 383
 384 test_17() {
 385     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 386
 387     createmany -o $MOUNT1/$tfile- 25
 388     createmany -o $MOUNT2/$tfile-2- 1
 389
 390     # Make sure the disconnect is lost
 391     replay_barrier ost1
 392     umount $MOUNT2
 393
 394     facet_failover ost1
 395     sleep $TIMEOUT
 396     fail ost1
 397
 398     unlinkmany $MOUNT1/$tfile- 25 || return 2
 399
 400     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 401     return 0
 402
 403 }
 404 run_test 17 "fail OST during recovery (3571)"
 405
 406 # cleanup with blocked enqueue fails until timer elapses (MDS busy), wait for it
 407 export NOW=0
 408
 409 test_18() { # bug 3822 - evicting client with enqueued lock
 410     #set -vx
 411     mkdir -p $MOUNT1/$tdir
 412     touch $MOUNT1/$tdir/f0
 413 #define OBD_FAIL_LDLM_ENQUEUE_BLOCKED    0x30b
 414     statmany -s $MOUNT1/$tdir/f 1 500 &
 415     OPENPID=$!
 416     NOW=`date +%s`
 417     do_facet $SINGLEMDS lctl set_param fail_loc=0x8000030b  # hold enqueue
 418     sleep 1
 419 #define OBD_FAIL_LDLM_BL_CALLBACK        0x305
 420     do_facet client lctl set_param fail_loc=0x80000305  # drop cb, evict
 421     cancel_lru_locks mdc
 422     usleep 500 # wait to ensure first client is one that will be evicted
 423     openfile -f O_RDONLY $MOUNT2/$tdir/f0
 424     wait $OPENPID
 425     dmesg | grep "entering recovery in server" && \
 426         error "client not evicted" || true
 427     do_facet client "lctl set_param fail_loc=0"
 428     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 429 }
 430 run_test 18 "ldlm_handle_enqueue succeeds on evicted export (3822)"
 431
 432 test_19() { # Bug 10991 - resend of open request does not fail assertion.
 433     replay_barrier $SINGLEMDS
 434     drop_ldlm_reply "createmany -o $DIR/$tfile 1" || return 1
 435     fail $SINGLEMDS
 436     checkstat $DIR2/${tfile}0 || return 2
 437     rm $DIR/${tfile}0 || return 3
 438
 439     return 0
 440 }
 441 run_test 19 "resend of open request"
 442
 443 test_20() { #16389
 444     BEFORE=`date +%s`
 445     replay_barrier $SINGLEMDS
 446     touch $MOUNT1/a
 447     touch $MOUNT2/b
 448     umount $MOUNT2
 449     fail $SINGLEMDS
 450     rm $MOUNT1/a
 451     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 452     TIER1=$((`date +%s` - BEFORE))
 453     BEFORE=`date +%s`
 454     replay_barrier $SINGLEMDS
 455     touch $MOUNT1/a
 456     touch $MOUNT2/b
 457     umount $MOUNT2
 458     fail $SINGLEMDS
 459     rm $MOUNT1/a
 460     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 461     TIER2=$((`date +%s` - BEFORE))
 462     [ $TIER2 -ge $((TIER1 * 2)) ] && \
 463         error "recovery time is growing $TIER2 > $TIER1"
 464     return 0
 465 }
 466 run_test 20 "recovery time is not increasing"
 467
 468 # commit on sharing tests
 469 test_21a() {
 470     local param_file=$TMP/$tfile-params
 471
 472     save_lustre_params $(facet_active_host $SINGLEMDS) "mdt.*.commit_on_sharing" > $param_file
 473     do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=1
 474     touch  $MOUNT1/$tfile-1
 475     mv  $MOUNT2/$tfile-1 $MOUNT2/$tfile-2
 476     mv  $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
 477     replay_barrier_nosync $SINGLEMDS
 478     umount $MOUNT2
 479
 480     facet_failover $SINGLEMDS
 481
 482     # all renames are replayed
 483     unlink  $MOUNT1/$tfile-3 || return 2
 484
 485     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 486
 487     do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=0
 488     rm -rf $MOUNT1/$tfile-*
 489     restore_lustre_params < $param_file
 490     rm -f $param_file
 491     return 0
 492 }
 493 run_test 21a "commit on sharing"
 494
 495 test_21b_sub () {
 496     local mds=$1
 497     do_node $CLIENT1 rm -f $MOUNT1/$tfile-*
 498
 499     do_facet $mds sync
 500     do_node $CLIENT1 touch  $MOUNT1/$tfile-1
 501     do_node $CLIENT2 mv  $MOUNT1/$tfile-1 $MOUNT1/$tfile-2
 502     do_node $CLIENT1 mv  $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
 503
 504     replay_barrier_nosync $mds
 505     shutdown_client $CLIENT2 $MOUNT1
 506
 507     facet_failover $mds
 508
 509     # were renames replayed?
 510     local rc=0
 511     echo UNLINK $MOUNT1/$tfile-3
 512     do_node $CLIENT1 unlink  $MOUNT1/$tfile-3 || \
 513         { echo "unlink $tfile-3 fail!" && rc=1; }
 514
 515     boot_node $CLIENT2
 516     zconf_mount_clients $CLIENT2 $MOUNT1 || error "mount $CLIENT2 $MOUNT1 fail"
 517
 518     return $rc
 519 }
 520
 521 test_21b() {
 522     [ -z "$CLIENTS" ] && skip "Need two or more clients." && return
 523     [ $CLIENTCOUNT -lt 2 ] && \
 524         { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
 525
 526     if [ "$FAILURE_MODE" = "HARD" ] &&  mixed_mdt_devs; then
 527         skip "Several mdt services on one mds node are used with FAILURE_MODE=$FAILURE_MODE. "
 528         return 0
 529     fi
 530
 531
 532     zconf_umount_clients $CLIENTS $MOUNT2
 533     zconf_mount_clients $CLIENTS $MOUNT1
 534
 535     local param_file=$TMP/$tfile-params
 536
 537     local num=$(get_mds_dir $MOUNT1)
 538
 539     save_lustre_params $(facet_active_host mds$num) "mdt.*.commit_on_sharing" > $param_file
 540
 541     # COS enabled
 542     local COS=1
 543     do_facet mds$num lctl set_param mdt.*.commit_on_sharing=$COS
 544
 545     test_21b_sub mds$num || error "Not all renames are replayed. COS=$COS"
 546
 547     # COS disabled (should fail)
 548     COS=0
 549     do_facet mds$num lctl set_param mdt.*.commit_on_sharing=$COS
 550
 551     # there is still a window when transactions may be written to disk before
 552     # the mds device is set R/O. To avoid such a rare test failure, the check
 553     # is repeated several times.
 554     local n_attempts=1
 555     while true; do
 556     test_21b_sub mds$num || break;
 557     let n_attempts=n_attempts+1
 558     [ $n_attempts -gt 3 ] &&
 559         error "The test cannot check whether COS works or not: all renames are replied w/o COS"
 560     done
 561     restore_lustre_params < $param_file
 562     rm -f $param_file
 563     return 0
 564 }
 565 run_test 21b "commit on sharing, two clients"
 566
 567 # end commit on sharing tests
 568
 569 complete $(basename $0) $SECONDS
 570 SLEEP=$((`date +%s` - $NOW))
 571 [ $SLEEP -lt $TIMEOUT ] && sleep $SLEEP
 572 [ "$MOUNTED2" = yes ] && zconf_umount $HOSTNAME $MOUNT2 || true
 573 check_and_cleanup_lustre
 574 exit_status