lustre/tests/replay-dual.sh

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