lustre/tests/replay-dual.sh

   1 #!/bin/bash
   2
   3 set -e
   4
   5 PTLDEBUG=${PTLDEBUG:--1}
   6 MOUNT_2=${MOUNT_2:-"yes"}
   7
   8 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
   9 . $LUSTRE/tests/test-framework.sh
  10 init_test_env $@
  11 init_logging
  12
  13 remote_mds_nodsh && skip "remote MDS with nodsh" && exit 0
  14
  15 ALWAYS_EXCEPT="$REPLAY_DUAL_EXCEPT "
  16 # bug number for skipped test:  LU-2012 LU-8333 LU-7372
  17 ALWAYS_EXCEPT+="                14b     21b     26 "
  18 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  19
  20 [[ "$mds1_FSTYPE" == zfs ]] &&
  21 # bug number for skipped test:        LU-2230
  22         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 21b"
  23
  24 if $SHARED_KEY; then
  25 # bug number for skipped tests:  LU-9795 LU-9795
  26         ALWAYS_EXCEPT+="         0a      0b "
  27 fi
  28
  29 #                                   7  (min)"
  30 [ "$SLOW" = "no" ] && EXCEPT_SLOW="21b "
  31
  32 build_test_filter
  33 check_and_setup_lustre
  34
  35 MOUNTED=$(mounted_lustre_filesystems)
  36 if ! $(echo $MOUNTED' ' | grep -w -q $MOUNT2' '); then
  37         zconf_mount $HOSTNAME $MOUNT2
  38         MOUNTED2=yes
  39 fi
  40
  41 assert_DIR
  42 rm -rf $DIR/[df][0-9]*
  43
  44 [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  45
  46 # if there is no CLIENT1 defined, some tests can be ran on localhost
  47 CLIENT1=${CLIENT1:-$HOSTNAME}
  48 # if CLIENT2 doesn't exist then use CLIENT1 instead
  49 # All tests should use CLIENT2 with MOUNT2 only therefore it will work if
  50 # $CLIENT2 == CLIENT1
  51 # Exception is the test which need two separate nodes
  52 CLIENT2=${CLIENT2:-$CLIENT1}
  53
  54 # LU-482 Avert LVM and VM inability to flush caches in pre .33 kernels
  55 if [ $LINUX_VERSION_CODE -lt $(version_code 2.6.33) ]; then
  56         sync
  57         do_facet $SINGLEMDS "sync; sleep 10; sync; sleep 10; sync"
  58 fi
  59
  60 LU482_FAILED=$(mktemp -u $TMP/$TESTSUITE.lu482.XXXXXX)
  61 test_0a() {
  62         echo "Check file is LU482_FAILED=$LU482_FAILED"
  63         touch $MOUNT2/$tfile-A # force sync FLD/SEQ update before barrier
  64         replay_barrier $SINGLEMDS
  65 #define OBD_FAIL_PTLRPC_FINISH_REPLAY | OBD_FAIL_ONCE
  66         touch $MOUNT2/$tfile
  67         createmany -o $MOUNT1/$tfile- 50
  68         $LCTL set_param fail_loc=0x80000514
  69         facet_failover $SINGLEMDS
  70         [ -f "$LU482_FAILED" ] && skip "LU-482 failure" && return 0
  71         client_up || return 1
  72         umount -f $MOUNT2
  73         client_up || return 1
  74         zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
  75         unlinkmany $MOUNT1/$tfile- 50 || return 2
  76         rm $MOUNT2/$tfile || return 3
  77         rm $MOUNT2/$tfile-A || return 4
  78 }
  79 run_test 0a "expired recovery with lost client"
  80
  81 if [ -f "$LU482_FAILED" ]; then
  82         log "Found check file $LU482_FAILED, aborting test script"
  83         rm -vf "$LU482_FAILED"
  84         complete $SECONDS
  85         do_nodes $CLIENTS umount -f $MOUNT2 || true
  86         do_nodes $CLIENTS umount -f $MOUNT || true
  87         # copied from stopall, but avoid the MDS recovery
  88     for num in `seq $OSTCOUNT`; do
  89         stop ost$num -f
  90         rm -f $TMP/ost${num}active
  91     done
  92     if ! combined_mgs_mds ; then
  93         stop mgs
  94     fi
  95
  96         exit_status
  97 fi
  98
  99 test_0b() {
 100     replay_barrier $SINGLEMDS
 101     touch $MOUNT2/$tfile
 102     touch $MOUNT1/$tfile-2
 103     umount $MOUNT2
 104     facet_failover $SINGLEMDS
 105     umount -f $MOUNT1
 106     zconf_mount `hostname` $MOUNT1 || error "mount1 fais"
 107     zconf_mount `hostname` $MOUNT2 || error "mount2 fais"
 108     # it is uncertain if file-2 exists or not, remove it if it does
 109     checkstat $MOUNT1/$tfile-2 && rm $MOUNT1/$tfile-2
 110     checkstat $MOUNT2/$tfile && return 2
 111     return 0
 112 }
 113 run_test 0b "lost client during waiting for next transno"
 114
 115 test_1() {
 116     touch $MOUNT1/a
 117     replay_barrier $SINGLEMDS
 118     touch $MOUNT2/b
 119
 120     fail $SINGLEMDS
 121     checkstat $MOUNT2/a || return 1
 122     checkstat $MOUNT1/b || return 2
 123     rm $MOUNT2/a $MOUNT1/b
 124     checkstat $MOUNT1/a && return 3
 125     checkstat $MOUNT2/b && return 4
 126     return 0
 127 }
 128
 129 run_test 1 "|X| simple create"
 130
 131
 132 test_2() {
 133     replay_barrier $SINGLEMDS
 134     mkdir $MOUNT1/adir
 135
 136     fail $SINGLEMDS
 137     checkstat $MOUNT2/adir || return 1
 138     rmdir $MOUNT2/adir
 139     checkstat $MOUNT2/adir && return 2
 140     return 0
 141 }
 142 run_test 2 "|X| mkdir adir"
 143
 144 test_3() {
 145     replay_barrier $SINGLEMDS
 146     mkdir $MOUNT1/adir
 147     mkdir $MOUNT2/adir/bdir
 148
 149     fail $SINGLEMDS
 150     checkstat $MOUNT2/adir      || return 1
 151     checkstat $MOUNT1/adir/bdir || return 2
 152     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 153     checkstat $MOUNT1/adir      && return 3
 154     checkstat $MOUNT2/adir/bdir && return 4
 155     return 0
 156 }
 157 run_test 3 "|X| mkdir adir, mkdir adir/bdir "
 158
 159 test_4() {
 160     mkdir $MOUNT1/adir
 161     replay_barrier $SINGLEMDS
 162     mkdir $MOUNT1/adir  && return 1
 163     mkdir $MOUNT2/adir/bdir
 164
 165     fail $SINGLEMDS
 166     checkstat $MOUNT2/adir      || return 2
 167     checkstat $MOUNT1/adir/bdir || return 3
 168
 169     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 170     checkstat $MOUNT1/adir      && return 4
 171     checkstat $MOUNT2/adir/bdir && return 5
 172     return 0
 173 }
 174 run_test 4 "|X| mkdir adir (-EEXIST), mkdir adir/bdir "
 175
 176
 177 test_5() {
 178     # multiclient version of replay_single.sh/test_8
 179     mcreate $MOUNT1/a
 180     multiop_bg_pause $MOUNT2/a o_tSc || return  1
 181     pid=$!
 182     rm -f $MOUNT1/a
 183     replay_barrier $SINGLEMDS
 184     kill -USR1 $pid
 185     wait $pid || return 1
 186
 187     fail $SINGLEMDS
 188     [ -e $MOUNT2/a ] && return 2
 189     return 0
 190 }
 191 run_test 5 "open, unlink |X| close"
 192
 193
 194 test_6() {
 195     mcreate $MOUNT1/a
 196     multiop_bg_pause $MOUNT2/a o_c || return 1
 197     pid1=$!
 198     multiop_bg_pause $MOUNT1/a o_c || return 1
 199     pid2=$!
 200     rm -f $MOUNT1/a
 201     replay_barrier $SINGLEMDS
 202     kill -USR1 $pid1
 203     wait $pid1 || return 1
 204
 205     fail $SINGLEMDS
 206     kill -USR1 $pid2
 207     wait $pid2 || return 1
 208     [ -e $MOUNT2/a ] && return 2
 209     return 0
 210 }
 211 run_test 6 "open1, open2, unlink |X| close1 [fail $SINGLEMDS] close2"
 212
 213 test_8() {
 214     replay_barrier $SINGLEMDS
 215     drop_reint_reply "mcreate $MOUNT1/$tfile"    || return 1
 216     fail $SINGLEMDS
 217     checkstat $MOUNT2/$tfile || return 2
 218     rm $MOUNT1/$tfile || return 3
 219
 220     return 0
 221 }
 222 run_test 8 "replay of resent request"
 223
 224 test_9() {
 225     replay_barrier $SINGLEMDS
 226     mcreate $MOUNT1/$tfile-1
 227     mcreate $MOUNT2/$tfile-2
 228     # drop first reint reply
 229     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
 230     fail $SINGLEMDS
 231     do_facet $SINGLEMDS lctl set_param fail_loc=0
 232
 233     rm $MOUNT1/$tfile-[1,2] || return 1
 234
 235     return 0
 236 }
 237 run_test 9 "resending a replayed create"
 238
 239 test_10() {
 240     mcreate $MOUNT1/$tfile-1
 241     replay_barrier $SINGLEMDS
 242     munlink $MOUNT1/$tfile-1
 243     mcreate $MOUNT2/$tfile-2
 244     # drop first reint reply
 245     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000119
 246     fail $SINGLEMDS
 247     do_facet $SINGLEMDS lctl set_param fail_loc=0
 248
 249     checkstat $MOUNT1/$tfile-1 && return 1
 250     checkstat $MOUNT1/$tfile-2 || return 2
 251     rm $MOUNT1/$tfile-2
 252
 253     return 0
 254 }
 255 run_test 10 "resending a replayed unlink"
 256
 257 test_11() {
 258         replay_barrier $SINGLEMDS
 259         mcreate $DIR1/$tfile-1
 260         mcreate $DIR2/$tfile-2
 261         mcreate $DIR1/$tfile-3
 262         mcreate $DIR2/$tfile-4
 263         mcreate $DIR1/$tfile-5
 264         # drop all reint replies for a while
 265         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x0119
 266         # note that with this fail_loc set, facet_failover df will fail
 267         facet_failover $SINGLEMDS
 268
 269         local clients=${CLIENTS:-$HOSTNAME}
 270         wait_clients_import_state "$clients" $SINGLEMDS FULL
 271
 272         do_facet $SINGLEMDS $LCTL set_param fail_loc=0
 273
 274         rm $DIR1/$tfile-[1-5] || return 1
 275
 276         return 0
 277 }
 278 run_test 11 "both clients timeout during replay"
 279
 280 test_12() {
 281     replay_barrier $SINGLEMDS
 282
 283     multiop_bg_pause $DIR/$tfile mo_c || return 1
 284     MULTIPID=$!
 285
 286 #define OBD_FAIL_LDLM_ENQUEUE_NET                       0x302
 287     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000302
 288     facet_failover $SINGLEMDS
 289     do_facet $SINGLEMDS lctl set_param fail_loc=0
 290     clients_up || return 1
 291
 292     ls $DIR/$tfile
 293     kill -USR1 $MULTIPID || return 3
 294     wait $MULTIPID || return 4
 295     $CHECKSTAT -t file $DIR/$tfile || return 2
 296     rm $DIR/$tfile
 297
 298     return 0
 299 }
 300 run_test 12 "open resend timeout"
 301
 302 test_13() {
 303     multiop_bg_pause $DIR/$tfile mo_c || return 1
 304     MULTIPID=$!
 305
 306     replay_barrier $SINGLEMDS
 307
 308     kill -USR1 $MULTIPID || return 3
 309     wait $MULTIPID || return 4
 310
 311     # drop close
 312     do_facet $SINGLEMDS lctl set_param fail_loc=0x80000115
 313     facet_failover $SINGLEMDS
 314     do_facet $SINGLEMDS lctl set_param fail_loc=0
 315     clients_up || return 1
 316
 317     ls $DIR/$tfile
 318     $CHECKSTAT -t file $DIR/$tfile || return 2
 319     rm $DIR/$tfile
 320
 321     return 0
 322 }
 323 run_test 13 "close resend timeout"
 324
 325 # test 14a removed after 18143 because it shouldn't fail anymore and do the same
 326 # as test_15a
 327
 328 test_14b() {
 329         wait_mds_ost_sync
 330         wait_delete_completed
 331
 332         local beforeused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
 333
 334         mkdir -p $MOUNT1/$tdir
 335         $LFS setstripe -i 0 $MOUNT1/$tdir
 336         replay_barrier $SINGLEMDS
 337         createmany -o $MOUNT1/$tdir/$tfile- 5
 338
 339         $LFS setstripe -i 0 $MOUNT2/$tfile-2
 340         dd if=/dev/zero of=$MOUNT2/$tfile-2 bs=1M count=5
 341         createmany -o $MOUNT1/$tdir/$tfile-3- 5
 342         umount $MOUNT2
 343
 344         fail $SINGLEMDS
 345         wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
 346
 347         # first set of files should have been replayed
 348         unlinkmany $MOUNT1/$tdir/$tfile- 5 || error "first unlinks failed"
 349         unlinkmany $MOUNT1/$tdir/$tfile-3- 5 || error "second unlinks failed"
 350
 351         zconf_mount $HOSTNAME $MOUNT2 || error "mount $MOUNT2 failed"
 352         [ -f $MOUNT2/$tfile-2 ] && error "$MOUNT2/$tfile-2 exists!"
 353
 354         wait_mds_ost_sync || error "wait_mds_ost_sync failed"
 355         wait_delete_completed || error "wait_delete_complete failed"
 356
 357         local afterused=$(df -P $DIR | tail -1 | awk '{ print $3 }')
 358         log "before $beforeused, after $afterused"
 359         # leave some margin for some files/dirs to be modified (OI, llog, etc)
 360         [ $afterused -le $((beforeused + $(fs_log_size))) ] ||
 361                 error "after $afterused > before $beforeused"
 362 }
 363 run_test 14b "delete ost orphans if gap occured in objids due to VBR"
 364
 365 test_15a() { # was test_15
 366     replay_barrier $SINGLEMDS
 367     createmany -o $MOUNT1/$tfile- 25
 368     createmany -o $MOUNT2/$tfile-2- 1
 369     umount $MOUNT2
 370
 371     fail $SINGLEMDS
 372
 373     unlinkmany $MOUNT1/$tfile- 25 || return 2
 374     [ -e $MOUNT1/$tfile-2-0 ] && error "$tfile-2-0 exists"
 375
 376     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 377     return 0
 378 }
 379 run_test 15a "timeout waiting for lost client during replay, 1 client completes"
 380
 381 test_15c() {
 382     replay_barrier $SINGLEMDS
 383     for ((i = 0; i < 2000; i++)); do
 384         echo "data" > "$MOUNT2/${tfile}-$i" || error "create ${tfile}-$i failed"
 385     done
 386     umount $MOUNT2
 387
 388     fail $SINGLEMDS
 389
 390     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 391     return 0
 392 }
 393 run_test 15c "remove multiple OST orphans"
 394
 395 test_16() {
 396     replay_barrier $SINGLEMDS
 397     createmany -o $MOUNT1/$tfile- 25
 398     createmany -o $MOUNT2/$tfile-2- 1
 399     umount $MOUNT2
 400
 401     facet_failover $SINGLEMDS
 402     sleep $TIMEOUT
 403     fail $SINGLEMDS
 404
 405     unlinkmany $MOUNT1/$tfile- 25 || return 2
 406
 407     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 408     return 0
 409
 410 }
 411 run_test 16 "fail MDS during recovery (3571)"
 412
 413 test_17() {
 414     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 415
 416     createmany -o $MOUNT1/$tfile- 25
 417     createmany -o $MOUNT2/$tfile-2- 1
 418
 419     # Make sure the disconnect is lost
 420     replay_barrier ost1
 421     umount $MOUNT2
 422
 423     facet_failover ost1
 424     sleep $TIMEOUT
 425     fail ost1
 426
 427     unlinkmany $MOUNT1/$tfile- 25 || return 2
 428
 429     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 430     return 0
 431
 432 }
 433 run_test 17 "fail OST during recovery (3571)"
 434
 435 # cleanup with blocked enqueue fails until timer elapses (MDS busy), wait for it
 436 export NOW=0
 437
 438 test_18() { # bug 3822 - evicting client with enqueued lock
 439         #set -vx
 440         local DLMTRACE=$(do_facet $SINGLEMDS lctl get_param debug)
 441         do_facet $SINGLEMDS lctl set_param debug=+dlmtrace
 442         mkdir -p $MOUNT1/$tdir || error "mkdir $MOUNT1/$tdir failed"
 443         touch $MOUNT1/$tdir/${tfile}0 || error "touch file failed"
 444         statmany -s $MOUNT1/$tdir/$tfile 1 500 &
 445         OPENPID=$!
 446         NOW=$SECONDS
 447         #define OBD_FAIL_LDLM_ENQUEUE_BLOCKED    0x30b
 448         do_facet $SINGLEMDS lctl set_param fail_loc=0x8000030b  # hold enqueue
 449         sleep 1
 450         #define OBD_FAIL_LDLM_BL_CALLBACK_NET                   0x305
 451         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=0
 452         do_facet client lctl set_param fail_loc=0x80000305  # drop cb, evict
 453         cancel_lru_locks mdc
 454         usleep 500 # wait to ensure first client is one that will be evicted
 455         openfile -f O_RDONLY $MOUNT2/$tdir/$tfile
 456         wait $OPENPID
 457         do_facet client lctl set_param ldlm.namespaces.*.early_lock_cancel=1
 458         do_facet $SINGLEMDS lctl debug_kernel |
 459                 grep "not entering recovery" && error "client not evicted"
 460         do_facet client "lctl set_param fail_loc=0"
 461         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 462 }
 463 run_test 18 "ldlm_handle_enqueue succeeds on evicted export (3822)"
 464
 465 test_19() { # Bug 10991 - resend of open request does not fail assertion.
 466     replay_barrier $SINGLEMDS
 467     drop_mdt_ldlm_reply "createmany -o $DIR/$tfile 1" || return 1
 468     fail $SINGLEMDS
 469     checkstat $DIR2/${tfile}0 || return 2
 470     rm $DIR/${tfile}0 || return 3
 471
 472     return 0
 473 }
 474 run_test 19 "resend of open request"
 475
 476 test_20() { #16389
 477         local before=$SECONDS
 478         replay_barrier $SINGLEMDS
 479         touch $DIR1/$tfile.a
 480         touch $DIR2/$tfile.b
 481         umount $DIR2
 482         fail $SINGLEMDS
 483         rm $DIR1/$tfile.a
 484         zconf_mount $HOSTNAME $DIR2 || error "mount $DIR2 fail"
 485         local tier1=$((SECONDS - before))
 486
 487         before=$SECONDS
 488         replay_barrier $SINGLEMDS
 489         touch $DIR1/$tfile.a
 490         touch $DIR2/$tfile.b
 491         umount $DIR2
 492         fail $SINGLEMDS
 493         rm $DIR1/$tfile.a
 494         zconf_mount $HOSTNAME $DIR2 || error "mount $DIR2 fail"
 495         local tier2=$((SECONDS - before))
 496
 497         # timeout is more than 1.5x original timeout
 498         ((tier2 < tier1 * 6 / 4)) ||
 499                 error "recovery time $tier2 >= 1.5x original time $tier1"
 500 }
 501 run_test 20 "recovery time is not increasing"
 502
 503 # commit on sharing tests
 504 test_21a() {
 505     local param_file=$TMP/$tfile-params
 506
 507         save_lustre_params $SINGLEMDS "mdt.*.commit_on_sharing" > $param_file
 508     do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=1
 509     touch  $MOUNT1/$tfile-1
 510     mv  $MOUNT2/$tfile-1 $MOUNT2/$tfile-2
 511     mv  $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
 512     replay_barrier_nosync $SINGLEMDS
 513     umount $MOUNT2
 514
 515     facet_failover $SINGLEMDS
 516
 517     # all renames are replayed
 518     unlink  $MOUNT1/$tfile-3 || return 2
 519
 520     zconf_mount `hostname` $MOUNT2 || error "mount $MOUNT2 fail"
 521
 522     do_facet $SINGLEMDS lctl set_param mdt.*.commit_on_sharing=0
 523     rm -rf $MOUNT1/$tfile-*
 524     restore_lustre_params < $param_file
 525     rm -f $param_file
 526     return 0
 527 }
 528 run_test 21a "commit on sharing"
 529
 530 test_21b_sub () {
 531         local mds=$1
 532         do_node $CLIENT1 rm -f $MOUNT1/$tfile-*
 533
 534         do_facet $mds sync
 535         do_node $CLIENT1 touch $MOUNT1/$tfile-1
 536         do_node $CLIENT2 mv $MOUNT1/$tfile-1 $MOUNT1/$tfile-2
 537         do_node $CLIENT1 mv $MOUNT1/$tfile-2 $MOUNT1/$tfile-3
 538
 539         replay_barrier_nosync $mds
 540         shutdown_client $CLIENT2 $MOUNT1
 541
 542         facet_failover $mds
 543
 544         # were renames replayed?
 545         local rc=0
 546         echo UNLINK $MOUNT1/$tfile-3
 547         do_node $CLIENT1 unlink  $MOUNT1/$tfile-3 ||
 548                 { echo "unlink $tfile-3 fail!" && rc=1; }
 549
 550         boot_node $CLIENT2
 551         zconf_mount_clients $CLIENT2 $MOUNT1 ||
 552                 error "mount $CLIENT2 $MOUNT1 fail"
 553
 554         return $rc
 555 }
 556
 557 test_21b() {
 558         [ -z "$CLIENTS" ] && skip "Need two or more clients" && return
 559         [ $CLIENTCOUNT -lt 2 ] &&
 560                 { skip "Need 2+ clients, have $CLIENTCOUNT" && return; }
 561
 562         if [ "$FAILURE_MODE" = "HARD" ] && mixed_mdt_devs; then
 563                 skip "Several MDTs on one MDS with FAILURE_MODE=$FAILURE_MODE"
 564                 return 0
 565         fi
 566
 567         zconf_umount_clients $CLIENTS $MOUNT2
 568         zconf_mount_clients $CLIENTS $MOUNT1
 569
 570         local param_file=$TMP/$tfile-params
 571
 572         local mdtidx=$($LFS getstripe -m $MOUNT1)
 573         local facet=mds$((mdtidx + 1))
 574
 575         save_lustre_params $facet "mdt.*.commit_on_sharing" > $param_file
 576
 577         # COS enabled
 578         local COS=1
 579         do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
 580
 581         test_21b_sub $facet || error "Not all renames are replayed. COS=$COS"
 582
 583         # there is still a window when transactions may be written to disk
 584         # before the mds device is set R/O. To avoid such a rare test failure,
 585         # the check is repeated several times.
 586         COS=0
 587         local n_attempts=1
 588         while true; do
 589                 # COS disabled (should fail)
 590                 do_facet $facet lctl set_param mdt.*.commit_on_sharing=$COS
 591
 592                 test_21b_sub $facet || break
 593                 n_attempts=$((n_attempts + 1))
 594                 [ $n_attempts -gt 3 ] &&
 595                         error "can't check if COS works: rename replied w/o COS"
 596         done
 597         zconf_mount_clients $CLIENTS $MOUNT2
 598         restore_lustre_params < $param_file
 599         rm -f $param_file
 600         return 0
 601 }
 602 run_test 21b "commit on sharing, two clients"
 603
 604 checkstat_22() {
 605         checkstat $MOUNT1/$remote_dir || return 1
 606         checkstat $MOUNT1/$remote_dir/dir || return 2
 607         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 3
 608         checkstat $MOUNT1/$remote_dir/dir/$tfile-1 || return 4
 609         return 0
 610 }
 611
 612 create_remote_dir_files_22() {
 613         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir/dir || return 1
 614         do_node $CLIENT1 createmany -o $MOUNT1/$remote_dir/dir/$tfile- 2 ||
 615                                                             return 2
 616         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 ||
 617                                                             return 3
 618         return 0
 619 }
 620
 621 test_22a () {
 622         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 623         ([ $FAILURE_MODE == "HARD" ] &&
 624                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 625                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 626                 return 0
 627
 628         local MDTIDX=1
 629         local remote_dir=${tdir}/remote_dir
 630
 631         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 632
 633         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 634         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 635         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 636         CLIENT_PID=$!
 637
 638         fail mds$((MDTIDX + 1))
 639         wait $CLIENT_PID || error "lfs mkdir failed"
 640
 641         replay_barrier mds$MDTIDX
 642         create_remote_dir_files_22 || error "Remote creation failed $?"
 643         fail mds$MDTIDX
 644
 645         checkstat_22 || error "check stat failed $?"
 646
 647         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 648         return 0
 649 }
 650 run_test 22a "c1 lfs mkdir -i 1 dir1, M1 drop reply & fail, c2 mkdir dir1/dir"
 651
 652 test_22b () {
 653         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 654         local MDTIDX=1
 655         local remote_dir=$tdir/remote_dir
 656
 657         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 658         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 659
 660         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 661         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 662         CLIENT_PID=$!
 663
 664         fail mds${MDTIDX},mds$((MDTIDX + 1))
 665         wait $CLIENT_PID || error "lfs mkdir failed"
 666
 667         replay_barrier mds$MDTIDX
 668         create_remote_dir_files_22 || error "Remote creation failed $?"
 669         fail mds${MDTIDX}
 670
 671         checkstat_22 || error "check stat failed $?"
 672
 673         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 674         return 0
 675 }
 676 run_test 22b "c1 lfs mkdir -i 1 d1, M1 drop reply & fail M0/M1, c2 mkdir d1/dir"
 677
 678 test_22c () {
 679         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 680         ([ $FAILURE_MODE == "HARD" ] &&
 681                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 682                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 683                 return 0
 684         local MDTIDX=1
 685         local remote_dir=${tdir}/remote_dir
 686
 687         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 688
 689         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
 690         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
 691         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 692         CLIENT_PID=$!
 693         do_facet mds$MDTIDX lctl set_param fail_loc=0
 694
 695         fail mds$MDTIDX
 696         wait $CLIENT_PID || error "lfs mkdir failed"
 697
 698         replay_barrier mds$MDTIDX
 699         create_remote_dir_files_22 || error "Remote creation failed $?"
 700         fail mds$MDTIDX
 701
 702         checkstat_22 || error "check stat failed $?"
 703
 704         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 705         return 0
 706 }
 707 run_test 22c "c1 lfs mkdir -i 1 d1, M1 drop update & fail M1, c2 mkdir d1/dir"
 708
 709 test_22d () {
 710         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 711         local MDTIDX=1
 712         local remote_dir=${tdir}/remote_dir
 713
 714         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 715
 716         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
 717         do_facet mds$MDTIDX lctl set_param fail_loc=0x1701
 718         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir &
 719         CLIENT_PID=$!
 720         do_facet mds$MDTIDX lctl set_param fail_loc=0
 721
 722         fail mds${MDTIDX},mds$((MDTIDX + 1))
 723         wait $CLIENT_PID || error "lfs mkdir failed"
 724
 725         replay_barrier mds$MDTIDX
 726         create_remote_dir_files_22 || error "Remote creation failed $?"
 727         fail mds$MDTIDX
 728
 729         checkstat_22 || error "check stat failed $?"
 730
 731         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 732         return 0
 733 }
 734 run_test 22d "c1 lfs mkdir -i 1 d1, M1 drop update & fail M0/M1,c2 mkdir d1/dir"
 735
 736 checkstat_23() {
 737         checkstat $MOUNT1/$remote_dir || return 1
 738         checkstat $MOUNT1/$remote_dir/$tfile-1 || return 2
 739         return 0
 740 }
 741
 742 create_remote_dir_files_23() {
 743         do_node $CLIENT2 mkdir ${MOUNT2}/$remote_dir || return 1
 744         do_node $CLIENT2 createmany -o $MOUNT2/$remote_dir/$tfile- 2 || return 2
 745         return 0
 746 }
 747
 748 test_23a () {
 749         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 750         ([ $FAILURE_MODE == "HARD" ] &&
 751                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 752                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 753                 return 0
 754         local MDTIDX=1
 755         local remote_dir=$tdir/remote_dir
 756
 757         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 758         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 759                         error "lfs mkdir failed"
 760         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 761         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 762         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 763         local CLIENT_PID=$!
 764         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
 765
 766         fail mds$((MDTIDX + 1))
 767         wait $CLIENT_PID || error "rmdir remote dir failed"
 768
 769         replay_barrier mds${MDTIDX}
 770         create_remote_dir_files_23 || error "Remote creation failed $?"
 771         fail mds${MDTIDX}
 772
 773         checkstat_23 || error "check stat failed $?"
 774
 775         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 776         return 0
 777 }
 778 run_test 23a "c1 rmdir d1, M1 drop reply and fail, client2 mkdir d1"
 779
 780 test_23b () {
 781         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 782         local MDTIDX=1
 783         local remote_dir=$tdir/remote_dir
 784
 785         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 786         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 787                         error "lfs mkdir failed"
 788
 789         # OBD_FAIL_MDS_REINT_NET_REP       0x119
 790         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0x119
 791         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 792         local CLIENT_PID=$!
 793         do_facet mds$((MDTIDX + 1)) lctl set_param fail_loc=0
 794
 795         fail mds${MDTIDX},mds$((MDTIDX + 1))
 796         wait $CLIENT_PID || error "rmdir remote dir failed"
 797
 798         replay_barrier mds${MDTIDX}
 799         create_remote_dir_files_23 || error "Remote creation failed $?"
 800         fail mds${MDTIDX}
 801
 802         checkstat_23 || error "check stat failed $?"
 803
 804         rm -rf $MOUNT1/$tdir || error "rmdir remote_dir failed"
 805         return 0
 806 }
 807 run_test 23b "c1 rmdir d1, M1 drop reply and fail M0/M1, c2 mkdir d1"
 808
 809 test_23c () {
 810         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 811
 812         ([ $FAILURE_MODE == "HARD" ] &&
 813                 [ "$(facet_host mds1)" == "$(facet_host mds2)" ]) &&
 814                 skip "MDTs needs to be on diff hosts for HARD fail mode" &&
 815                 return 0
 816         local MDTIDX=1
 817         local remote_dir=$tdir/remote_dir
 818
 819         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 820         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 821                         error "lfs mkdir failed"
 822
 823         # OBD_FAIL_OUT_UPDATE_NET_REP    0x1701
 824         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
 825         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 826         CLIENT_PID=$!
 827         do_facet mds${MDTIDX} lctl set_param fail_loc=0
 828
 829         fail mds${MDTIDX}
 830         wait $CLIENT_PID || error "rmdir remote dir failed"
 831
 832         replay_barrier mds${MDTIDX}
 833         create_remote_dir_files_23 || error "Remote creation failed $?"
 834         fail mds${MDTIDX}
 835
 836         checkstat_23 || error "check stat failed $?"
 837
 838         rm -rf $MOUNT1/$tdir || return 6
 839         return 0
 840 }
 841 run_test 23c "c1 rmdir d1, M0 drop update reply and fail M0, c2 mkdir d1"
 842
 843 test_23d () {
 844         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
 845         local MDTIDX=1
 846         local remote_dir=$tdir/remote_dir
 847
 848         do_node $CLIENT1 mkdir -p $MOUNT1/${tdir}
 849         do_node $CLIENT1 $LFS mkdir -i $MDTIDX $MOUNT1/$remote_dir ||
 850                         error "lfs mkdir failed"
 851
 852         # OBD_FAIL_UPDATE_OBJ_NET    0x1701
 853         do_facet mds${MDTIDX} lctl set_param fail_loc=0x1701
 854         do_node $CLIENT1 rmdir $MOUNT1/$remote_dir &
 855         CLIENT_PID=$!
 856         do_facet mds${MDTIDX} lctl set_param fail_loc=0
 857
 858         fail mds${MDTIDX},mds$((MDTIDX + 1))
 859         wait $CLIENT_PID || error "rmdir remote dir failed"
 860
 861         replay_barrier mds${MDTIDX}
 862         create_remote_dir_files_23 || error "Remote creation failed $?"
 863         fail mds${MDTIDX}
 864
 865         checkstat_23 || error "check stat failed $?"
 866
 867         rm -rf $MOUNT1/$tdir || return 6
 868         return 0
 869 }
 870 run_test 23d "c1 rmdir d1, M0 drop update reply and fail M0/M1, c2 mkdir d1"
 871
 872 test_24 () {
 873         [[ "$MDS1_VERSION" -gt $(version_code 2.5.2) ]] ||
 874                 skip "Need MDS version newer than 2.5.2"
 875
 876         touch $MOUNT/$tfile
 877         stat $MOUNT/$tfile >&/dev/null
 878 # OBD_FAIL_MDS_REINT_NET_REP
 879         do_facet $SINGLEMDS $LCTL set_param fail_loc=0x119
 880         $TRUNCATE $MOUNT/$tfile 100 &
 881         PID=$!
 882         sleep 1
 883         do_facet $SINGLEMDS lctl set_param fail_loc=0
 884         # sync to release rep-ack lock quickly
 885         do_nodes $(comma_list $(mdts_nodes)) \
 886             "lctl set_param -n osd*.*MDT*.force_sync 1"
 887         rm $MOUNT2/$tfile
 888         wait
 889 }
 890 run_test 24 "reconstruct on non-existing object"
 891
 892 # end commit on sharing tests
 893
 894 test_25() {
 895         cancel_lru_locks osc
 896
 897         $LFS setstripe -i 0 -c 1 $DIR/$tfile
 898
 899         # get lock for the 1st client
 900         dd if=/dev/zero of=$DIR/$tfile count=1 >/dev/null ||
 901                 error "failed to write data"
 902
 903         # get waiting locks for the 2nd client
 904         drop_ldlm_cancel "multiop $DIR2/$tfile Ow512" &
 905         sleep 1
 906
 907         # failover, replay and resend replayed waiting locks
 908         if [ "$OST1_VERSION" -ge $(version_code 2.6.90) ]; then
 909                 #define OBD_FAIL_LDLM_SRV_CP_AST      0x325
 910                 do_facet ost1 lctl set_param fail_loc=0x80000325
 911         else
 912                 #define OBD_FAIL_OST_LDLM_REPLY_NET     0x213
 913                 do_facet ost1 lctl set_param fail_loc=0x80000213
 914         fi
 915
 916         fail ost1
 917
 918         # multiop does not finish because CP AST is skipped;
 919         # it is ok to kill it in the test, because CP AST is already re-sent
 920         # and it does not hung forever in real life
 921         killall multiop
 922         wait
 923 }
 924 run_test 25 "replay|resend"
 925
 926 cleanup_26() {
 927         trap 0
 928         kill -9 $tar_26_pid
 929         kill -9 $dbench_26_pid
 930         killall -9 dbench
 931 }
 932
 933 test_26() {
 934         local clients=${CLIENTS:-$HOSTNAME}
 935
 936         zconf_mount_clients $clients $MOUNT
 937
 938         local duration=600
 939         [ "$SLOW" = "no" ] && duration=200
 940         # set duration to 900 because it takes some time to boot node
 941         [ "$FAILURE_MODE" = HARD ] && duration=900
 942
 943         local start_ts=$SECONDS
 944         local rc=0
 945
 946         trap cleanup_26 EXIT
 947         (
 948                 local tar_dir=$DIR/$tdir/run_tar
 949                 while true; do
 950                         test_mkdir -p -c$MDSCOUNT $tar_dir || break
 951                         if [ $MDSCOUNT -ge 2 ]; then
 952                                 $LFS setdirstripe -D -c$MDSCOUNT $tar_dir ||
 953                                         error "set default dirstripe failed"
 954                         fi
 955                         cd $tar_dir || break
 956                         tar cf - /etc | tar xf - || error "tar failed"
 957                         cd $DIR/$tdir || break
 958                         rm -rf $tar_dir || break
 959                 done
 960         )&
 961         tar_26_pid=$!
 962         echo "Started tar $tar_26_pid"
 963
 964         (
 965                 local dbench_dir=$DIR2/$tdir/run_dbench
 966                 while true; do
 967                         test_mkdir -p -c$MDSCOUNT $dbench_dir || break
 968                         if [ $MDSCOUNT -ge 2 ]; then
 969                                 $LFS setdirstripe -D -c$MDSCOUNT $dbench_dir ||
 970                                         error "set default dirstripe failed"
 971                         fi
 972                         cd $dbench_dir || break
 973                         rundbench 1 -D $dbench_dir -t 100 &>/dev/null || break
 974                         cd $DIR/$tdir || break
 975                         rm -rf $dbench_dir || break
 976                 done
 977         )&
 978         dbench_26_pid=$!
 979         echo "Started dbench $dbench_26_pid"
 980
 981         local num_failovers=0
 982         local fail_index=1
 983         while [ $((SECONDS - start_ts)) -lt $duration ]; do
 984                 kill -0 $tar_26_pid || error "tar $tar_26_pid missing"
 985                 kill -0 $dbench_26_pid || error "dbench $dbench_26_pid missing"
 986                 sleep 2
 987                 replay_barrier mds$fail_index
 988                 sleep 2 # give clients a time to do operations
 989                 # Increment the number of failovers
 990                 num_failovers=$((num_failovers + 1))
 991                 log "$TESTNAME fail mds$fail_index $num_failovers times"
 992                 fail mds$fail_index
 993                 if [ $fail_index -ge $MDSCOUNT ]; then
 994                         fail_index=1
 995                 else
 996                         fail_index=$((fail_index + 1))
 997                 fi
 998         done
 999         # stop the client loads
1000         kill -0 $tar_26_pid || error "tar $tar_26_pid stopped"
1001         kill -0 $dbench_26_pid || error "dbench $dbench_26_pid stopped"
1002         cleanup_26 || true
1003 }
1004 run_test 26 "dbench and tar with mds failover"
1005
1006 test_28() {
1007         $LFS setstripe -i 0 -c 1 $DIR2/$tfile
1008         dd if=/dev/zero of=$DIR2/$tfile bs=4096 count=1
1009
1010         #define OBD_FAIL_LDLM_SRV_BL_AST         0x324
1011         do_facet ost1 $LCTL set_param fail_loc=0x80000324
1012
1013         dd if=/dev/zero of=$DIR/$tfile bs=4096 count=1 &
1014         local pid=$!
1015         sleep 2
1016
1017         #define OBD_FAIL_LDLM_GRANT_CHECK        0x32a
1018         do_facet ost1 $LCTL set_param fail_loc=0x32a
1019
1020         fail ost1
1021
1022         sleep 2
1023         cancel_lru_locks OST0000-osc
1024         wait $pid || error "dd failed"
1025 }
1026 run_test 28 "lock replay should be ordered: waiting after granted"
1027
1028 test_29() {
1029         local dir0=$DIR/$tdir/d0
1030         local dir1=$DIR/$tdir/d1
1031
1032         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1033         [ $CLIENTCOUNT -lt 2 ] && skip "needs >= 2 clients" && return 0
1034         [ "$CLIENT1" == "$CLIENT2" ] &&
1035                 skip "clients must be on different nodes" && return 0
1036
1037         mkdir -p $DIR/$tdir
1038         $LFS mkdir -i0 $dir0
1039         $LFS mkdir -i1 $dir1
1040         sync
1041
1042         replay_barrier mds2
1043         # create a remote dir, drop reply
1044         #define OBD_FAIL_PTLRPC_ROUND_XID 0x530
1045         $LCTL set_param fail_loc=0x530 fail_val=36
1046         #define OBD_FAIL_MDS_REINT_MULTI_NET_REP 0x15a
1047         do_facet mds2 $LCTL set_param fail_loc=0x8000015a
1048         echo make remote dir d0 for $dir0
1049         $LFS mkdir -i1 -c1 $dir0/d3 &
1050         sleep 1
1051
1052         echo make local dir d1 for $dir1
1053         do_node $CLIENT2 $LCTL set_param fail_loc=0x530 fail_val=36
1054         do_node $CLIENT2 mkdir $dir1/d4
1055
1056         fail mds2
1057 }
1058 run_test 29 "replay vs update with the same xid"
1059
1060 complete $SECONDS
1061 SLEEP=$((SECONDS - $NOW))
1062 [ $SLEEP -lt $TIMEOUT ] && sleep $SLEEP
1063 [ "$MOUNTED2" = yes ] && zconf_umount $HOSTNAME $MOUNT2 || true
1064 check_and_cleanup_lustre
1065 exit_status