lustre/tests/replay-single.sh

   1 #!/bin/bash
   2
   3 set -e
   4 #set -v
   5
   6 #
   7 # This test needs to be run on the client
   8 #
   9 SAVE_PWD=$PWD
  10 LUSTRE=${LUSTRE:-$(cd $(dirname $0)/..; echo $PWD)}
  11 SETUP=${SETUP:-}
  12 CLEANUP=${CLEANUP:-}
  13 . $LUSTRE/tests/test-framework.sh
  14 init_test_env $@
  15 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  16 CHECK_GRANT=${CHECK_GRANT:-"yes"}
  17 GRANT_CHECK_LIST=${GRANT_CHECK_LIST:-""}
  18
  19 remote_mds_nodsh && log "SKIP: remote MDS with nodsh" && exit 0
  20
  21 # Skip these tests
  22 # bug number:  17466 15962
  23 ALWAYS_EXCEPT="61d   33b $REPLAY_SINGLE_EXCEPT"
  24
  25 if [ "$FAILURE_MODE" = "HARD" ] && mixed_ost_devs; then
  26     CONFIG_EXCEPTIONS="0b 42 47 61a 61c"
  27     echo -n "Several ost services on one ost node are used with FAILURE_MODE=$FAILURE_MODE. "
  28     echo "Except the tests: $CONFIG_EXCEPTIONS"
  29     ALWAYS_EXCEPT="$ALWAYS_EXCEPT $CONFIG_EXCEPTIONS"
  30 fi
  31
  32 #                                                  63 min  7 min  AT AT AT AT"
  33 [ "$SLOW" = "no" ] && EXCEPT_SLOW="1 2 3 4 6 12 16 44a      44b    65 66 67 68"
  34
  35 build_test_filter
  36
  37 check_and_setup_lustre
  38
  39 mkdir -p $DIR
  40
  41 assert_DIR
  42 rm -rf $DIR/[df][0-9]*
  43
  44 test_0a() {     # was test_0
  45     sleep 10
  46     mkdir $DIR/$tfile
  47     replay_barrier $SINGLEMDS
  48     fail $SINGLEMDS
  49     rmdir $DIR/$tfile
  50 }
  51 run_test 0a "empty replay"
  52
  53 test_0b() {
  54     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
  55
  56     # this test attempts to trigger a race in the precreation code,
  57     # and must run before any other objects are created on the filesystem
  58     fail ost1
  59     createmany -o $DIR/$tfile 20 || return 1
  60     unlinkmany $DIR/$tfile 20 || return 2
  61 }
  62 run_test 0b "ensure object created after recover exists. (3284)"
  63
  64 seq_set_width()
  65 {
  66     local mds=$1
  67     local width=$2
  68     lctl set_param -n seq.cli-srv-$mds-mdc-*.width=$width
  69 }
  70
  71 seq_get_width()
  72 {
  73     local mds=$1
  74     lctl get_param -n seq.cli-srv-$mds-mdc-*.width
  75 }
  76
  77 # This test should pass for single-mds and multi-mds configs.
  78 # But for different configurations it tests different things.
  79 #
  80 # single-mds
  81 # ----------
  82 # (1) fld_create replay should happen;
  83 #
  84 # (2) fld_create replay should not return -EEXISTS, if it does
  85 # this means sequence manager recovery code is buggy and allocated
  86 # same sequence two times after recovery.
  87 #
  88 # multi-mds
  89 # ---------
  90 # (1) fld_create replay may not happen, because its home MDS is
  91 # MDS2 which is not involved to revovery;
  92 #
  93 # (2) as fld_create does not happen on MDS1, it does not make any
  94 # problem.
  95 test_0c() {
  96     local label=`mdsdevlabel 1`
  97     [ -z "$label" ] && echo "No label for mds1" && return 1
  98
  99     replay_barrier $SINGLEMDS
 100     local sw=`seq_get_width $label`
 101
 102     # make seq manager switch to next sequence each
 103     # time as new fid is needed.
 104     seq_set_width $label 1
 105
 106     # make sure that fld has created at least one new
 107     # entry on server
 108     touch $DIR/$tfile || return 2
 109     seq_set_width $label $sw
 110
 111     # fail $SINGLEMDS and start recovery, replay RPCs, etc.
 112     fail $SINGLEMDS
 113
 114     # wait for recovery finish
 115     sleep 10
 116     df $MOUNT
 117
 118     # flush fld cache and dentry cache to make it lookup
 119     # created entry instead of revalidating existent one
 120     umount $MOUNT
 121     zconf_mount `hostname` $MOUNT
 122
 123     # issue lookup which should call fld lookup which
 124     # should fail if client did not replay fld create
 125     # correctly and server has no fld entry
 126     touch $DIR/$tfile || return 3
 127     rm $DIR/$tfile || return 4
 128 }
 129 run_test 0c "fld create"
 130
 131 test_1() {
 132     replay_barrier $SINGLEMDS
 133     mcreate $DIR/$tfile
 134     fail $SINGLEMDS
 135     $CHECKSTAT -t file $DIR/$tfile || return 1
 136     rm $DIR/$tfile
 137 }
 138 run_test 1 "simple create"
 139
 140 test_2a() {
 141     replay_barrier $SINGLEMDS
 142     touch $DIR/$tfile
 143     fail $SINGLEMDS
 144     $CHECKSTAT -t file $DIR/$tfile || return 1
 145     rm $DIR/$tfile
 146 }
 147 run_test 2a "touch"
 148
 149 test_2b() {
 150     mcreate $DIR/$tfile
 151     replay_barrier $SINGLEMDS
 152     touch $DIR/$tfile
 153     fail $SINGLEMDS
 154     $CHECKSTAT -t file $DIR/$tfile || return 1
 155     rm $DIR/$tfile
 156 }
 157 run_test 2b "touch"
 158
 159 test_3a() {
 160     local file=$DIR/$tfile
 161     replay_barrier $SINGLEMDS
 162     mcreate $file
 163     openfile -f O_DIRECTORY $file
 164     fail $SINGLEMDS
 165     $CHECKSTAT -t file $file || return 2
 166     rm $file
 167 }
 168 run_test 3a "replay failed open(O_DIRECTORY)"
 169
 170 test_3b() {
 171     replay_barrier $SINGLEMDS
 172 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 173     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000114"
 174     touch $DIR/$tfile
 175     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 176     fail $SINGLEMDS
 177     $CHECKSTAT -t file $DIR/$tfile && return 2
 178     return 0
 179 }
 180 run_test 3b "replay failed open -ENOMEM"
 181
 182 test_3c() {
 183     replay_barrier $SINGLEMDS
 184 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 185     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000128"
 186     touch $DIR/$tfile
 187     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 188     fail $SINGLEMDS
 189
 190     $CHECKSTAT -t file $DIR/$tfile && return 2
 191     return 0
 192 }
 193 run_test 3c "replay failed open -ENOMEM"
 194
 195 test_4a() {     # was test_4
 196     replay_barrier $SINGLEMDS
 197     for i in `seq 10`; do
 198         echo "tag-$i" > $DIR/$tfile-$i
 199     done
 200     fail $SINGLEMDS
 201     for i in `seq 10`; do
 202       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 203     done
 204 }
 205 run_test 4a "|x| 10 open(O_CREAT)s"
 206
 207 test_4b() {
 208     replay_barrier $SINGLEMDS
 209     rm -rf $DIR/$tfile-*
 210     fail $SINGLEMDS
 211     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 212 }
 213 run_test 4b "|x| rm 10 files"
 214
 215 # The idea is to get past the first block of precreated files on both
 216 # osts, and then replay.
 217 test_5() {
 218     replay_barrier $SINGLEMDS
 219     for i in `seq 220`; do
 220         echo "tag-$i" > $DIR/$tfile-$i
 221     done
 222     fail $SINGLEMDS
 223     for i in `seq 220`; do
 224       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 225     done
 226     rm -rf $DIR/$tfile-*
 227     sleep 3
 228     # waiting for commitment of removal
 229 }
 230 run_test 5 "|x| 220 open(O_CREAT)"
 231
 232
 233 test_6a() {     # was test_6
 234     mkdir -p $DIR/$tdir
 235     replay_barrier $SINGLEMDS
 236     mcreate $DIR/$tdir/$tfile
 237     fail $SINGLEMDS
 238     $CHECKSTAT -t dir $DIR/$tdir || return 1
 239     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 240     sleep 2
 241     # waiting for log process thread
 242 }
 243 run_test 6a "mkdir + contained create"
 244
 245 test_6b() {
 246     mkdir -p $DIR/$tdir
 247     replay_barrier $SINGLEMDS
 248     rm -rf $DIR/$tdir
 249     fail $SINGLEMDS
 250     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 251 }
 252 run_test 6b "|X| rmdir"
 253
 254 test_7() {
 255     mkdir -p $DIR/$tdir
 256     replay_barrier $SINGLEMDS
 257     mcreate $DIR/$tdir/$tfile
 258     fail $SINGLEMDS
 259     $CHECKSTAT -t dir $DIR/$tdir || return 1
 260     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 261     rm -fr $DIR/$tdir
 262 }
 263 run_test 7 "mkdir |X| contained create"
 264
 265 test_8() {
 266     # make sure no side-effect from previous test.
 267     rm -f $DIR/$tfile
 268     replay_barrier $SINGLEMDS
 269     multiop_bg_pause $DIR/$tfile mo_c || return 4
 270     MULTIPID=$!
 271     fail $SINGLEMDS
 272     ls $DIR/$tfile
 273     $CHECKSTAT -t file $DIR/$tfile || return 1
 274     kill -USR1 $MULTIPID || return 2
 275     wait $MULTIPID || return 3
 276     rm $DIR/$tfile
 277 }
 278 run_test 8 "creat open |X| close"
 279
 280 test_9() {
 281     replay_barrier $SINGLEMDS
 282     mcreate $DIR/$tfile
 283     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 284     fail $SINGLEMDS
 285     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 286
 287     echo " old_inum == $old_inum, new_inum == $new_inum"
 288     if [ $old_inum -eq $new_inum  ] ;
 289     then
 290         echo " old_inum and new_inum match"
 291     else
 292         echo "!!!! old_inum and new_inum NOT match"
 293         return 1
 294     fi
 295     rm $DIR/$tfile
 296 }
 297 run_test 9  "|X| create (same inum/gen)"
 298
 299 test_10() {
 300     mcreate $DIR/$tfile
 301     replay_barrier $SINGLEMDS
 302     mv $DIR/$tfile $DIR/$tfile-2
 303     rm -f $DIR/$tfile
 304     fail $SINGLEMDS
 305     $CHECKSTAT $DIR/$tfile && return 1
 306     $CHECKSTAT $DIR/$tfile-2 ||return 2
 307     rm $DIR/$tfile-2
 308     return 0
 309 }
 310 run_test 10 "create |X| rename unlink"
 311
 312 test_11() {
 313     mcreate $DIR/$tfile
 314     echo "old" > $DIR/$tfile
 315     mv $DIR/$tfile $DIR/$tfile-2
 316     replay_barrier $SINGLEMDS
 317     echo "new" > $DIR/$tfile
 318     grep new $DIR/$tfile
 319     grep old $DIR/$tfile-2
 320     fail $SINGLEMDS
 321     grep new $DIR/$tfile || return 1
 322     grep old $DIR/$tfile-2 || return 2
 323 }
 324 run_test 11 "create open write rename |X| create-old-name read"
 325
 326 test_12() {
 327     mcreate $DIR/$tfile
 328     multiop_bg_pause $DIR/$tfile o_tSc || return 3
 329     pid=$!
 330     rm -f $DIR/$tfile
 331     replay_barrier $SINGLEMDS
 332     kill -USR1 $pid
 333     wait $pid || return 1
 334
 335     fail $SINGLEMDS
 336     [ -e $DIR/$tfile ] && return 2
 337     return 0
 338 }
 339 run_test 12 "open, unlink |X| close"
 340
 341
 342 # 1777 - replay open after committed chmod that would make
 343 #        a regular open a failure
 344 test_13() {
 345     mcreate $DIR/$tfile
 346     multiop_bg_pause $DIR/$tfile O_wc || return 3
 347     pid=$!
 348     chmod 0 $DIR/$tfile
 349     $CHECKSTAT -p 0 $DIR/$tfile
 350     replay_barrier $SINGLEMDS
 351     fail $SINGLEMDS
 352     kill -USR1 $pid
 353     wait $pid || return 1
 354
 355     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
 356     return 0
 357 }
 358 run_test 13 "open chmod 0 |x| write close"
 359
 360 test_14() {
 361     multiop_bg_pause $DIR/$tfile O_tSc || return 4
 362     pid=$!
 363     rm -f $DIR/$tfile
 364     replay_barrier $SINGLEMDS
 365     kill -USR1 $pid || return 1
 366     wait $pid || return 2
 367
 368     fail $SINGLEMDS
 369     [ -e $DIR/$tfile ] && return 3
 370     return 0
 371 }
 372 run_test 14 "open(O_CREAT), unlink |X| close"
 373
 374 test_15() {
 375     multiop_bg_pause $DIR/$tfile O_tSc || return 5
 376     pid=$!
 377     rm -f $DIR/$tfile
 378     replay_barrier $SINGLEMDS
 379     touch $DIR/g11 || return 1
 380     kill -USR1 $pid
 381     wait $pid || return 2
 382
 383     fail $SINGLEMDS
 384     [ -e $DIR/$tfile ] && return 3
 385     touch $DIR/h11 || return 4
 386     return 0
 387 }
 388 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 389
 390
 391 test_16() {
 392     replay_barrier $SINGLEMDS
 393     mcreate $DIR/$tfile
 394     munlink $DIR/$tfile
 395     mcreate $DIR/$tfile-2
 396     fail $SINGLEMDS
 397     [ -e $DIR/$tfile ] && return 1
 398     [ -e $DIR/$tfile-2 ] || return 2
 399     munlink $DIR/$tfile-2 || return 3
 400 }
 401 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 402
 403 test_17() {
 404     replay_barrier $SINGLEMDS
 405     multiop_bg_pause $DIR/$tfile O_c || return 4
 406     pid=$!
 407     fail $SINGLEMDS
 408     kill -USR1 $pid || return 1
 409     wait $pid || return 2
 410     $CHECKSTAT -t file $DIR/$tfile || return 3
 411     rm $DIR/$tfile
 412 }
 413 run_test 17 "|X| open(O_CREAT), |replay| close"
 414
 415 test_18() {
 416     replay_barrier $SINGLEMDS
 417     multiop_bg_pause $DIR/$tfile O_tSc || return 8
 418     pid=$!
 419     rm -f $DIR/$tfile
 420     touch $DIR/$tfile-2 || return 1
 421     echo "pid: $pid will close"
 422     kill -USR1 $pid
 423     wait $pid || return 2
 424
 425     fail $SINGLEMDS
 426     [ -e $DIR/$tfile ] && return 3
 427     [ -e $DIR/$tfile-2 ] || return 4
 428     # this touch frequently fails
 429     touch $DIR/$tfile-3 || return 5
 430     munlink $DIR/$tfile-2 || return 6
 431     munlink $DIR/$tfile-3 || return 7
 432     return 0
 433 }
 434 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
 435
 436 # bug 1855 (a simpler form of test_11 above)
 437 test_19() {
 438     replay_barrier $SINGLEMDS
 439     mcreate $DIR/$tfile
 440     echo "old" > $DIR/$tfile
 441     mv $DIR/$tfile $DIR/$tfile-2
 442     grep old $DIR/$tfile-2
 443     fail $SINGLEMDS
 444     grep old $DIR/$tfile-2 || return 2
 445 }
 446 run_test 19 "|X| mcreate, open, write, rename "
 447
 448 test_20a() {    # was test_20
 449     replay_barrier $SINGLEMDS
 450     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 451     pid=$!
 452     rm -f $DIR/$tfile
 453
 454     fail $SINGLEMDS
 455     kill -USR1 $pid
 456     wait $pid || return 1
 457     [ -e $DIR/$tfile ] && return 2
 458     return 0
 459 }
 460 run_test 20a "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 461
 462 test_20b() { # bug 10480
 463     BEFOREUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 464
 465     dd if=/dev/zero of=$DIR/$tfile bs=4k count=10000 &
 466     pid=$!
 467     while [ ! -e $DIR/$tfile ] ; do
 468         usleep 60                           # give dd a chance to start
 469     done
 470
 471     lfs getstripe $DIR/$tfile || return 1
 472     rm -f $DIR/$tfile || return 2       # make it an orphan
 473     mds_evict_client
 474     df -P $DIR || df -P $DIR || true    # reconnect
 475
 476     fail $SINGLEMDS                            # start orphan recovery
 477     df -P $DIR || df -P $DIR || true    # reconnect
 478     wait_recovery_complete $SINGLEMDS || error "MDS recovery not done"
 479
 480     # just because recovery is done doesn't mean we've finished
 481     # orphan cleanup. Wait for llogs to get synchronized.
 482     echo waiting for orphan cleanup...
 483     while [ true ]; do
 484             local -a sync=($(do_facet ost "$LCTL get_param obdfilter.*.mds_sync" | awk -F= ' {print $2}'))
 485             local con=1
 486             for ((i=0; i<${#sync[@]}; i++)); do
 487                     [ ${sync[$i]} -eq 0 ] && continue
 488                     # there is a not finished MDS-OST synchronization
 489                     con=0
 490                     break;
 491             done
 492             [ ${con} -eq 1 ] && break
 493             sleep 1
 494     done
 495     AFTERUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 496     log "before $BEFOREUSED, after $AFTERUSED"
 497     [ $AFTERUSED -gt $((BEFOREUSED + 20)) ] && \
 498         error "after $AFTERUSED > before $BEFOREUSED"
 499     return 0
 500 }
 501 run_test 20b "write, unlink, eviction, replay, (test mds_cleanup_orphans)"
 502
 503 test_20c() { # bug 10480
 504     multiop_bg_pause $DIR/$tfile Ow_c || return 1
 505     pid=$!
 506
 507     ls -la $DIR/$tfile
 508
 509     mds_evict_client
 510
 511     df -P $DIR || df -P $DIR || true    # reconnect
 512
 513     kill -USR1 $pid
 514     test -s $DIR/$tfile || error "File was truncated"
 515
 516     wait $pid || return 1
 517     return 0
 518 }
 519 run_test 20c "check that client eviction does not affect file content"
 520
 521 test_21() {
 522     replay_barrier $SINGLEMDS
 523     multiop_bg_pause $DIR/$tfile O_tSc || return 5
 524     pid=$!
 525     rm -f $DIR/$tfile
 526     touch $DIR/g11 || return 1
 527
 528     fail $SINGLEMDS
 529     kill -USR1 $pid
 530     wait $pid || return 2
 531     [ -e $DIR/$tfile ] && return 3
 532     touch $DIR/h11 || return 4
 533     return 0
 534 }
 535 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 536
 537 test_22() {
 538     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 539     pid=$!
 540
 541     replay_barrier $SINGLEMDS
 542     rm -f $DIR/$tfile
 543
 544     fail $SINGLEMDS
 545     kill -USR1 $pid
 546     wait $pid || return 1
 547     [ -e $DIR/$tfile ] && return 2
 548     return 0
 549 }
 550 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
 551
 552 test_23() {
 553     multiop_bg_pause $DIR/$tfile O_tSc || return 5
 554     pid=$!
 555
 556     replay_barrier $SINGLEMDS
 557     rm -f $DIR/$tfile
 558     touch $DIR/g11 || return 1
 559
 560     fail $SINGLEMDS
 561     kill -USR1 $pid
 562     wait $pid || return 2
 563     [ -e $DIR/$tfile ] && return 3
 564     touch $DIR/h11 || return 4
 565     return 0
 566 }
 567 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 568
 569 test_24() {
 570     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 571     pid=$!
 572
 573     replay_barrier $SINGLEMDS
 574     fail $SINGLEMDS
 575     rm -f $DIR/$tfile
 576     kill -USR1 $pid
 577     wait $pid || return 1
 578     [ -e $DIR/$tfile ] && return 2
 579     return 0
 580 }
 581 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 582
 583 test_25() {
 584     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 585     pid=$!
 586     rm -f $DIR/$tfile
 587
 588     replay_barrier $SINGLEMDS
 589     fail $SINGLEMDS
 590     kill -USR1 $pid
 591     wait $pid || return 1
 592     [ -e $DIR/$tfile ] && return 2
 593     return 0
 594 }
 595 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 596
 597 test_26() {
 598     replay_barrier $SINGLEMDS
 599     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 600     pid1=$!
 601     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 602     pid2=$!
 603     rm -f $DIR/$tfile-1
 604     rm -f $DIR/$tfile-2
 605     kill -USR1 $pid2
 606     wait $pid2 || return 1
 607
 608     fail $SINGLEMDS
 609     kill -USR1 $pid1
 610     wait $pid1 || return 2
 611     [ -e $DIR/$tfile-1 ] && return 3
 612     [ -e $DIR/$tfile-2 ] && return 4
 613     return 0
 614 }
 615 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 616
 617 test_27() {
 618     replay_barrier $SINGLEMDS
 619     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 620     pid1=$!
 621     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 622     pid2=$!
 623     rm -f $DIR/$tfile-1
 624     rm -f $DIR/$tfile-2
 625
 626     fail $SINGLEMDS
 627     kill -USR1 $pid1
 628     wait $pid1 || return 1
 629     kill -USR1 $pid2
 630     wait $pid2 || return 2
 631     [ -e $DIR/$tfile-1 ] && return 3
 632     [ -e $DIR/$tfile-2 ] && return 4
 633     return 0
 634 }
 635 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 636
 637 test_28() {
 638     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 639     pid1=$!
 640     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 641     pid2=$!
 642     replay_barrier $SINGLEMDS
 643     rm -f $DIR/$tfile-1
 644     rm -f $DIR/$tfile-2
 645     kill -USR1 $pid2
 646     wait $pid2 || return 1
 647
 648     fail $SINGLEMDS
 649     kill -USR1 $pid1
 650     wait $pid1 || return 2
 651     [ -e $DIR/$tfile-1 ] && return 3
 652     [ -e $DIR/$tfile-2 ] && return 4
 653     return 0
 654 }
 655 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 656
 657 test_29() {
 658     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 659     pid1=$!
 660     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 661     pid2=$!
 662     replay_barrier $SINGLEMDS
 663     rm -f $DIR/$tfile-1
 664     rm -f $DIR/$tfile-2
 665
 666     fail $SINGLEMDS
 667     kill -USR1 $pid1
 668     wait $pid1 || return 1
 669     kill -USR1 $pid2
 670     wait $pid2 || return 2
 671     [ -e $DIR/$tfile-1 ] && return 3
 672     [ -e $DIR/$tfile-2 ] && return 4
 673     return 0
 674 }
 675 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 676
 677 test_30() {
 678     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 679     pid1=$!
 680     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 681     pid2=$!
 682     rm -f $DIR/$tfile-1
 683     rm -f $DIR/$tfile-2
 684
 685     replay_barrier $SINGLEMDS
 686     fail $SINGLEMDS
 687     kill -USR1 $pid1
 688     wait $pid1 || return 1
 689     kill -USR1 $pid2
 690     wait $pid2 || return 2
 691     [ -e $DIR/$tfile-1 ] && return 3
 692     [ -e $DIR/$tfile-2 ] && return 4
 693     return 0
 694 }
 695 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 696
 697 test_31() {
 698     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 699     pid1=$!
 700     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 701     pid2=$!
 702     rm -f $DIR/$tfile-1
 703
 704     replay_barrier $SINGLEMDS
 705     rm -f $DIR/$tfile-2
 706     fail $SINGLEMDS
 707     kill -USR1 $pid1
 708     wait $pid1 || return 1
 709     kill -USR1 $pid2
 710     wait $pid2 || return 2
 711     [ -e $DIR/$tfile-1 ] && return 3
 712     [ -e $DIR/$tfile-2 ] && return 4
 713     return 0
 714 }
 715 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 716
 717 # tests for bug 2104; completion without crashing is success.  The close is
 718 # stale, but we always return 0 for close, so the app never sees it.
 719 test_32() {
 720     multiop_bg_pause $DIR/$tfile O_c || return 2
 721     pid1=$!
 722     multiop_bg_pause $DIR/$tfile O_c || return 3
 723     pid2=$!
 724     mds_evict_client
 725     df $MOUNT || sleep 1 && df $MOUNT || return 1
 726     kill -USR1 $pid1
 727     kill -USR1 $pid2
 728     wait $pid1 || return 4
 729     wait $pid2 || return 5
 730     return 0
 731 }
 732 run_test 32 "close() notices client eviction; close() after client eviction"
 733
 734 # Abort recovery before client complete
 735 test_33a() {    # was test_33
 736     replay_barrier $SINGLEMDS
 737     createmany -o $DIR/$tfile-%d 100
 738     fail_abort $SINGLEMDS
 739     # this file should be gone, because the replay was aborted
 740     $CHECKSTAT -t file $DIR/$tfile-* && return 3
 741     unlinkmany $DIR/$tfile-%d 0 100
 742     return 0
 743 }
 744 run_test 33a "abort recovery before client does replay"
 745
 746 # Stale FID sequence bug 15962
 747 test_33b() {    # was test_33a
 748     replay_barrier $SINGLEMDS
 749     createmany -o $DIR/$tfile-%d 10
 750     fail_abort $SINGLEMDS
 751     unlinkmany $DIR/$tfile-%d 0 10
 752     # recreate shouldn't fail
 753     createmany -o $DIR/$tfile-%d 10 || return 3
 754     unlinkmany $DIR/$tfile-%d 0 10
 755     return 0
 756 }
 757 run_test 33b "fid shouldn't be reused after abort recovery"
 758
 759 test_34() {
 760     multiop_bg_pause $DIR/$tfile O_c || return 2
 761     pid=$!
 762     rm -f $DIR/$tfile
 763
 764     replay_barrier $SINGLEMDS
 765     fail_abort $SINGLEMDS
 766     kill -USR1 $pid
 767     wait $pid || return 3
 768     [ -e $DIR/$tfile ] && return 1
 769     sync
 770     return 0
 771 }
 772 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 773
 774 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 775 test_35() {
 776     touch $DIR/$tfile
 777
 778 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 779     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
 780     rm -f $DIR/$tfile &
 781     sleep 1
 782     sync
 783     sleep 1
 784     # give a chance to remove from MDS
 785     fail_abort $SINGLEMDS
 786     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
 787 }
 788 run_test 35 "test recovery from llog for unlink op"
 789
 790 # b=2432 resent cancel after replay uses wrong cookie,
 791 # so don't resend cancels
 792 test_36() {
 793     replay_barrier $SINGLEMDS
 794     touch $DIR/$tfile
 795     checkstat $DIR/$tfile
 796     facet_failover $SINGLEMDS
 797     cancel_lru_locks mdc
 798     if dmesg | grep "unknown lock cookie"; then
 799         echo "cancel after replay failed"
 800         return 1
 801     fi
 802 }
 803 run_test 36 "don't resend cancel"
 804
 805 # b=2368
 806 # directory orphans can't be unlinked from PENDING directory
 807 test_37() {
 808     rmdir $DIR/$tfile 2>/dev/null
 809     multiop_bg_pause $DIR/$tfile dD_c || return 2
 810     pid=$!
 811     rmdir $DIR/$tfile
 812
 813     replay_barrier $SINGLEMDS
 814     # clear the dmesg buffer so we only see errors from this recovery
 815     dmesg -c >/dev/null
 816     fail_abort $SINGLEMDS
 817     kill -USR1 $pid
 818     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
 819     wait $pid || return 3
 820     sync
 821     return 0
 822 }
 823 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 824
 825 test_38() {
 826     createmany -o $DIR/$tfile-%d 800
 827     unlinkmany $DIR/$tfile-%d 0 400
 828     replay_barrier $SINGLEMDS
 829     fail $SINGLEMDS
 830     unlinkmany $DIR/$tfile-%d 400 400
 831     sleep 2
 832     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 833 }
 834 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 835
 836 test_39() { # bug 4176
 837     createmany -o $DIR/$tfile-%d 800
 838     replay_barrier $SINGLEMDS
 839     unlinkmany $DIR/$tfile-%d 0 400
 840     fail $SINGLEMDS
 841     unlinkmany $DIR/$tfile-%d 400 400
 842     sleep 2
 843     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 844 }
 845 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 846
 847 count_ost_writes() {
 848     lctl get_param -n osc.*.stats | awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
 849 }
 850
 851 #b=2477,2532
 852 test_40(){
 853     $LCTL mark multiop $MOUNT/$tfile OS_c
 854     multiop $MOUNT/$tfile OS_c  &
 855     PID=$!
 856     writeme -s $MOUNT/${tfile}-2 &
 857     WRITE_PID=$!
 858     sleep 1
 859     facet_failover $SINGLEMDS
 860 #define OBD_FAIL_MDS_CONNECT_NET         0x117
 861     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000117"
 862     kill -USR1 $PID
 863     stat1=`count_ost_writes`
 864     sleep $TIMEOUT
 865     stat2=`count_ost_writes`
 866     echo "$stat1, $stat2"
 867     if [ $stat1 -lt $stat2 ]; then
 868        echo "writes continuing during recovery"
 869        RC=0
 870     else
 871        echo "writes not continuing during recovery, bug 2477"
 872        RC=4
 873     fi
 874     echo "waiting for writeme $WRITE_PID"
 875     kill $WRITE_PID
 876     wait $WRITE_PID
 877
 878     echo "waiting for multiop $PID"
 879     wait $PID || return 2
 880     do_facet client munlink $MOUNT/$tfile  || return 3
 881     do_facet client munlink $MOUNT/${tfile}-2  || return 3
 882     return $RC
 883 }
 884 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 885
 886
 887 #b=2814
 888 # make sure that a read to one osc doesn't try to double-unlock its page just
 889 # because another osc is invalid.  trigger_group_io used to mistakenly return
 890 # an error if any oscs were invalid even after having successfully put rpcs
 891 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 892 # the page, guarnateeing that the unlock from the RPC completion would
 893 # assert on trying to unlock the unlocked page.
 894 test_41() {
 895     [ $OSTCOUNT -lt 2 ] && \
 896         skip "skipping test 41: we don't have a second OST to test with" && \
 897         return
 898
 899     local f=$MOUNT/$tfile
 900     # make sure the start of the file is ost1
 901     lfs setstripe $f -s $((128 * 1024)) -i 0
 902     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
 903     cancel_lru_locks osc
 904     # fail ost2 and read from ost1
 905     local osc2dev=`do_facet $SINGLEMDS "lctl get_param -n devices | grep ${ost2_svc}-osc-MDT0000" | awk '{print $1}'`
 906     [ -z "$osc2dev" ] && echo "OST: $ost2_svc" && lctl get_param -n devices && return 4
 907     do_facet $SINGLEMDS $LCTL --device $osc2dev deactivate || return 1
 908     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
 909     do_facet $SINGLEMDS $LCTL --device $osc2dev activate || return 2
 910     return 0
 911 }
 912 run_test 41 "read from a valid osc while other oscs are invalid"
 913
 914 # test MDS recovery after ost failure
 915 test_42() {
 916     blocks=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 917     createmany -o $DIR/$tfile-%d 800
 918     replay_barrier ost1
 919     unlinkmany $DIR/$tfile-%d 0 400
 920     debugsave
 921     lctl set_param debug=-1
 922     facet_failover ost1
 923
 924     # osc is evicted, fs is smaller (but only with failout OSTs (bug 7287)
 925     #blocks_after=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 926     #[ $blocks_after -lt $blocks ] || return 1
 927     echo wait for MDS to timeout and recover
 928     sleep $((TIMEOUT * 2))
 929     debugrestore
 930     unlinkmany $DIR/$tfile-%d 400 400
 931     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
 932 }
 933 run_test 42 "recovery after ost failure"
 934
 935 # timeout in MDS/OST recovery RPC will LBUG MDS
 936 test_43() { # bug 2530
 937     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 938
 939     replay_barrier $SINGLEMDS
 940
 941     # OBD_FAIL_OST_CREATE_NET 0x204
 942     do_facet ost1 "lctl set_param fail_loc=0x80000204"
 943     fail $SINGLEMDS
 944     sleep 10
 945     do_facet ost1 "lctl set_param fail_loc=0"
 946
 947     return 0
 948 }
 949 run_test 43 "mds osc import failure during recovery; don't LBUG"
 950
 951 test_44a() {    # was test_44
 952     local at_max_saved=0
 953
 954     mdcdev=`lctl get_param -n devices | awk '/MDT0000-mdc-/ {print $1}'`
 955     [ "$mdcdev" ] || exit 2
 956
 957     # adaptive timeouts slow this way down
 958     if at_is_enabled; then
 959         at_max_saved=$(at_max_get mds)
 960         at_max_set 40 mds
 961     fi
 962
 963     for i in `seq 1 10`; do
 964         echo "$i of 10 ($(date +%s))"
 965         do_facet $SINGLEMDS "lctl get_param -n mdt.*.mdt.timeouts | grep service"
 966         #define OBD_FAIL_TGT_CONN_RACE     0x701
 967         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000701"
 968         $LCTL --device $mdcdev recover
 969         df $MOUNT
 970     done
 971     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 972     [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved mds
 973     return 0
 974 }
 975 run_test 44a "race in target handle connect"
 976
 977 test_44b() {
 978     mdcdev=`lctl get_param -n devices | awk '/MDT0000-mdc-/ {print $1}'`
 979     [ "$mdcdev" ] || exit 2
 980     for i in `seq 1 10`; do
 981         echo "$i of 10 ($(date +%s))"
 982         do_facet $SINGLEMDS "lctl get_param -n mdt.*.mdt.timeouts | grep service"
 983         #define OBD_FAIL_TGT_DELAY_RECONNECT 0x704
 984         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000704"
 985         $LCTL --device $mdcdev recover
 986         df $MOUNT
 987     done
 988     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 989     return 0
 990 }
 991 run_test 44b "race in target handle connect"
 992
 993 # Handle failed close
 994 test_45() {
 995     mdcdev=`lctl get_param -n devices | awk '/MDT0000-mdc-/ {print $1}'`
 996     [ "$mdcdev" ] || exit 2
 997     $LCTL --device $mdcdev recover
 998
 999     multiop_bg_pause $DIR/$tfile O_c || return 1
1000     pid=$!
1001
1002     # This will cause the CLOSE to fail before even
1003     # allocating a reply buffer
1004     $LCTL --device $mdcdev deactivate || return 4
1005
1006     # try the close
1007     kill -USR1 $pid
1008     wait $pid || return 1
1009
1010     $LCTL --device $mdcdev activate || return 5
1011     sleep 1
1012
1013     $CHECKSTAT -t file $DIR/$tfile || return 2
1014     return 0
1015 }
1016 run_test 45 "Handle failed close"
1017
1018 test_46() {
1019     dmesg -c >/dev/null
1020     drop_reply "touch $DIR/$tfile"
1021     fail $SINGLEMDS
1022     # ironically, the previous test, 45, will cause a real forced close,
1023     # so just look for one for this test
1024     dmesg | grep -i "force closing client file handle for $tfile" && return 1
1025     return 0
1026 }
1027 run_test 46 "Don't leak file handle after open resend (3325)"
1028
1029 test_47() { # bug 2824
1030     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1031
1032     # create some files to make sure precreate has been done on all
1033     # OSTs. (just in case this test is run independently)
1034     createmany -o $DIR/$tfile 20  || return 1
1035
1036     # OBD_FAIL_OST_CREATE_NET 0x204
1037     fail ost1
1038     do_facet ost1 "lctl set_param fail_loc=0x80000204"
1039     df $MOUNT || return 2
1040
1041     # let the MDS discover the OST failure, attempt to recover, fail
1042     # and recover again.
1043     sleep $((3 * TIMEOUT))
1044
1045     # Without 2824, this createmany would hang
1046     createmany -o $DIR/$tfile 20 || return 3
1047     unlinkmany $DIR/$tfile 20 || return 4
1048
1049     do_facet ost1 "lctl set_param fail_loc=0"
1050     return 0
1051 }
1052 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
1053
1054 test_48() {
1055     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1056     [ "$OSTCOUNT" -lt "2" ] && skip "$OSTCOUNT < 2 OSTs -- skipping" && return
1057
1058     replay_barrier $SINGLEMDS
1059     createmany -o $DIR/$tfile 20  || return 1
1060     # OBD_FAIL_OST_EROFS 0x216
1061     facet_failover $SINGLEMDS
1062     do_facet ost1 "lctl set_param fail_loc=0x80000216"
1063     df $MOUNT || return 2
1064
1065     createmany -o $DIR/$tfile 20 20 || return 2
1066     unlinkmany $DIR/$tfile 40 || return 3
1067     return 0
1068 }
1069 run_test 48 "MDS->OSC failure during precreate cleanup (2824)"
1070
1071 test_50() {
1072     local oscdev=`do_facet $SINGLEMDS lctl get_param -n devices | grep ${ost1_svc}-osc-MDT0000 | awk '{print $1}'`
1073     [ "$oscdev" ] || return 1
1074     do_facet $SINGLEMDS $LCTL --device $oscdev recover || return 2
1075     do_facet $SINGLEMDS $LCTL --device $oscdev recover || return 3
1076     # give the mds_lov_sync threads a chance to run
1077     sleep 5
1078 }
1079 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
1080
1081 # b3764 timed out lock replay
1082 test_52() {
1083     touch $DIR/$tfile
1084     cancel_lru_locks mdc
1085
1086     multiop $DIR/$tfile s || return 1
1087     replay_barrier $SINGLEMDS
1088 #define OBD_FAIL_LDLM_REPLY              0x30c
1089     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000030c"
1090     fail $SINGLEMDS || return 2
1091     do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1092
1093     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
1094 }
1095 run_test 52 "time out lock replay (3764)"
1096
1097 # bug 3462 - simultaneous MDC requests
1098 test_53a() {
1099         mkdir -p $DIR/${tdir}-1
1100         mkdir -p $DIR/${tdir}-2
1101         multiop $DIR/${tdir}-1/f O_c &
1102         close_pid=$!
1103         # give multiop a change to open
1104         sleep 1
1105
1106         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1107         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1108         kill -USR1 $close_pid
1109         cancel_lru_locks mdc    # force the close
1110         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1111
1112         mcreate $DIR/${tdir}-2/f || return 1
1113
1114         # close should still be here
1115         [ -d /proc/$close_pid ] || return 2
1116
1117         replay_barrier_nodf $SINGLEMDS
1118         fail $SINGLEMDS
1119         wait $close_pid || return 3
1120
1121         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1122         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1123         rm -rf $DIR/${tdir}-*
1124 }
1125 run_test 53a "|X| close request while two MDC requests in flight"
1126
1127 test_53b() {
1128         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1129
1130         mkdir -p $DIR/${tdir}-1
1131         mkdir -p $DIR/${tdir}-2
1132         multiop $DIR/${tdir}-1/f O_c &
1133         close_pid=$!
1134
1135         #define OBD_FAIL_MDS_REINT_NET 0x107
1136         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1137         mcreate $DIR/${tdir}-2/f &
1138         open_pid=$!
1139         sleep 1
1140
1141         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1142         kill -USR1 $close_pid
1143         cancel_lru_locks mdc    # force the close
1144         wait $close_pid || return 1
1145         # open should still be here
1146         [ -d /proc/$open_pid ] || return 2
1147
1148         replay_barrier_nodf $SINGLEMDS
1149         fail $SINGLEMDS
1150         wait $open_pid || return 3
1151
1152         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1153         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1154         rm -rf $DIR/${tdir}-*
1155 }
1156 run_test 53b "|X| open request while two MDC requests in flight"
1157
1158 test_53c() {
1159         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1160
1161         mkdir -p $DIR/${tdir}-1
1162         mkdir -p $DIR/${tdir}-2
1163         multiop $DIR/${tdir}-1/f O_c &
1164         close_pid=$!
1165
1166         #define OBD_FAIL_MDS_REINT_NET 0x107
1167         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1168         mcreate $DIR/${tdir}-2/f &
1169         open_pid=$!
1170         sleep 1
1171
1172         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1173         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1174         kill -USR1 $close_pid
1175         cancel_lru_locks mdc    # force the close
1176
1177         replay_barrier_nodf $SINGLEMDS
1178         fail_nodf $SINGLEMDS
1179         wait $open_pid || return 1
1180         sleep 2
1181         # close should be gone
1182         [ -d /proc/$close_pid ] && return 2
1183         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1184
1185         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1186         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1187         rm -rf $DIR/${tdir}-*
1188 }
1189 run_test 53c "|X| open request and close request while two MDC requests in flight"
1190
1191 test_53d() {
1192         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1193
1194         mkdir -p $DIR/${tdir}-1
1195         mkdir -p $DIR/${tdir}-2
1196         multiop $DIR/${tdir}-1/f O_c &
1197         close_pid=$!
1198         # give multiop a chance to open
1199         sleep 1
1200
1201         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1202         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1203         kill -USR1 $close_pid
1204         cancel_lru_locks mdc    # force the close
1205         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1206         mcreate $DIR/${tdir}-2/f || return 1
1207
1208         # close should still be here
1209         [ -d /proc/$close_pid ] || return 2
1210         fail $SINGLEMDS
1211         wait $close_pid || return 3
1212
1213         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1214         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1215         rm -rf $DIR/${tdir}-*
1216 }
1217 run_test 53d "|X| close reply while two MDC requests in flight"
1218
1219 test_53e() {
1220         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1221
1222         mkdir -p $DIR/${tdir}-1
1223         mkdir -p $DIR/${tdir}-2
1224         multiop $DIR/${tdir}-1/f O_c &
1225         close_pid=$!
1226
1227         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1228         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1229         mcreate $DIR/${tdir}-2/f &
1230         open_pid=$!
1231         sleep 1
1232
1233         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1234         kill -USR1 $close_pid
1235         cancel_lru_locks mdc    # force the close
1236         wait $close_pid || return 1
1237         # open should still be here
1238         [ -d /proc/$open_pid ] || return 2
1239
1240         replay_barrier_nodf $SINGLEMDS
1241         fail $SINGLEMDS
1242         wait $open_pid || return 3
1243
1244         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1245         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1246         rm -rf $DIR/${tdir}-*
1247 }
1248 run_test 53e "|X| open reply while two MDC requests in flight"
1249
1250 test_53f() {
1251         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1252
1253         mkdir -p $DIR/${tdir}-1
1254         mkdir -p $DIR/${tdir}-2
1255         multiop $DIR/${tdir}-1/f O_c &
1256         close_pid=$!
1257
1258         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1259         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1260         mcreate $DIR/${tdir}-2/f &
1261         open_pid=$!
1262         sleep 1
1263
1264         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1265         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1266         kill -USR1 $close_pid
1267         cancel_lru_locks mdc    # force the close
1268
1269         replay_barrier_nodf $SINGLEMDS
1270         fail_nodf $SINGLEMDS
1271         wait $open_pid || return 1
1272         sleep 2
1273         # close should be gone
1274         [ -d /proc/$close_pid ] && return 2
1275         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1276
1277         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1278         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1279         rm -rf $DIR/${tdir}-*
1280 }
1281 run_test 53f "|X| open reply and close reply while two MDC requests in flight"
1282
1283 test_53g() {
1284         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1285
1286         mkdir -p $DIR/${tdir}-1
1287         mkdir -p $DIR/${tdir}-2
1288         multiop $DIR/${tdir}-1/f O_c &
1289         close_pid=$!
1290
1291         #define OBD_FAIL_MDS_REINT_NET_REP 0x119
1292         do_facet $SINGLEMDS "lctl set_param fail_loc=0x119"
1293         mcreate $DIR/${tdir}-2/f &
1294         open_pid=$!
1295         sleep 1
1296
1297         #define OBD_FAIL_MDS_CLOSE_NET 0x115
1298         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
1299         kill -USR1 $close_pid
1300         cancel_lru_locks mdc    # force the close
1301
1302         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1303         replay_barrier_nodf $SINGLEMDS
1304         fail_nodf $SINGLEMDS
1305         wait $open_pid || return 1
1306         sleep 2
1307         # close should be gone
1308         [ -d /proc/$close_pid ] && return 2
1309
1310         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1311         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1312         rm -rf $DIR/${tdir}-*
1313 }
1314 run_test 53g "|X| drop open reply and close request while close and open are both in flight"
1315
1316 test_53h() {
1317         rm -rf $DIR/${tdir}-1 $DIR/${tdir}-2
1318
1319         mkdir -p $DIR/${tdir}-1
1320         mkdir -p $DIR/${tdir}-2
1321         multiop $DIR/${tdir}-1/f O_c &
1322         close_pid=$!
1323
1324         #define OBD_FAIL_MDS_REINT_NET 0x107
1325         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
1326         mcreate $DIR/${tdir}-2/f &
1327         open_pid=$!
1328         sleep 1
1329
1330         #define OBD_FAIL_MDS_CLOSE_NET_REP 0x13b
1331         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013b"
1332         kill -USR1 $close_pid
1333         cancel_lru_locks mdc    # force the close
1334         sleep 1
1335
1336         replay_barrier_nodf $SINGLEMDS
1337         fail_nodf $SINGLEMDS
1338         wait $open_pid || return 1
1339         sleep 2
1340         # close should be gone
1341         [ -d /proc/$close_pid ] && return 2
1342         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1343
1344         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1345         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1346         rm -rf $DIR/${tdir}-*
1347 }
1348 run_test 53h "|X| open request and close reply while two MDC requests in flight"
1349
1350 #b_cray 54 "|X| open request and close reply while two MDC requests in flight"
1351
1352 #b3761 ASSERTION(hash != 0) failed
1353 test_55() {
1354 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1355     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012b"
1356     touch $DIR/$tfile &
1357     # give touch a chance to run
1358     sleep 5
1359     do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1360     rm $DIR/$tfile
1361     return 0
1362 }
1363 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1364
1365 #b3440 ASSERTION(rec->ur_fid2->id) failed
1366 test_56() {
1367     ln -s foo $DIR/$tfile
1368     replay_barrier $SINGLEMDS
1369     #drop_reply "cat $DIR/$tfile"
1370     fail $SINGLEMDS
1371     sleep 10
1372 }
1373 run_test 56 "don't replay a symlink open request (3440)"
1374
1375 #recovery one mds-ost setattr from llog
1376 test_57() {
1377 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1378     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012c"
1379     touch $DIR/$tfile
1380     replay_barrier $SINGLEMDS
1381     fail $SINGLEMDS
1382     sleep 1
1383     $CHECKSTAT -t file $DIR/$tfile || return 1
1384     do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1385     rm $DIR/$tfile
1386 }
1387 run_test 57 "test recovery from llog for setattr op"
1388
1389 #recovery many mds-ost setattr from llog
1390 test_58a() {
1391     mkdir -p $DIR/$tdir
1392 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1393     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012c"
1394     createmany -o $DIR/$tdir/$tfile-%d 2500
1395     replay_barrier $SINGLEMDS
1396     fail $SINGLEMDS
1397     sleep 2
1398     $CHECKSTAT -t file $DIR/$tdir/$tfile-* >/dev/null || return 1
1399     do_facet $SINGLEMDS "lctl set_param fail_loc=0x0"
1400     unlinkmany $DIR/$tdir/$tfile-%d 2500
1401     rmdir $DIR/$tdir
1402 }
1403 run_test 58a "test recovery from llog for setattr op (test llog_gen_rec)"
1404
1405 test_58b() {
1406     mount_client $MOUNT2
1407     mkdir -p $DIR/$tdir
1408     touch $DIR/$tdir/$tfile
1409     replay_barrier $SINGLEMDS
1410     setfattr -n trusted.foo -v bar $DIR/$tdir/$tfile
1411     fail $SINGLEMDS
1412     VAL=`getfattr --absolute-names --only-value -n trusted.foo $MOUNT2/$tdir/$tfile`
1413     [ x$VAL = x"bar" ] || return 1
1414     rm -f $DIR/$tdir/$tfile
1415     rmdir $DIR/$tdir
1416     zconf_umount `hostname` $MOUNT2
1417 }
1418 run_test 58b "test replay of setxattr op"
1419
1420 test_58c() { # bug 16570
1421         mount_client $MOUNT2
1422         mkdir -p $DIR/$tdir
1423         touch $DIR/$tdir/$tfile
1424         drop_request "setfattr -n trusted.foo -v bar $DIR/$tdir/$tfile" || \
1425                 return 1
1426         VAL=`getfattr --absolute-names --only-value -n trusted.foo $MOUNT2/$tdir/$tfile`
1427         [ x$VAL = x"bar" ] || return 2
1428         drop_reint_reply "setfattr -n trusted.foo1 -v bar1 $DIR/$tdir/$tfile" || \
1429                 return 3
1430         VAL=`getfattr --absolute-names --only-value -n trusted.foo1 $MOUNT2/$tdir/$tfile`
1431         [ x$VAL = x"bar1" ] || return 4
1432         rm -f $DIR/$tdir/$tfile
1433         rmdir $DIR/$tdir
1434         zconf_umount `hostname` $MOUNT2
1435 }
1436 run_test 58c "resend/reconstruct setxattr op"
1437
1438 # log_commit_thread vs filter_destroy race used to lead to import use after free
1439 # bug 11658
1440 test_59() {
1441     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1442
1443     mkdir -p $DIR/$tdir
1444     createmany -o $DIR/$tdir/$tfile-%d 200
1445     sync
1446     unlinkmany $DIR/$tdir/$tfile-%d 200
1447 #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1448     do_facet ost1 "lctl set_param fail_loc=0x507"
1449     fail ost1
1450     fail $SINGLEMDS
1451     do_facet ost1 "lctl set_param fail_loc=0x0"
1452     sleep 20
1453     rmdir $DIR/$tdir
1454 }
1455 run_test 59 "test log_commit_thread vs filter_destroy race"
1456
1457 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1458 # bug 12086: should no oops and No ctxt error for this test
1459 test_60() {
1460     mkdir -p $DIR/$tdir
1461     createmany -o $DIR/$tdir/$tfile-%d 200
1462     replay_barrier $SINGLEMDS
1463     unlinkmany $DIR/$tdir/$tfile-%d 0 100
1464     fail $SINGLEMDS
1465     unlinkmany $DIR/$tdir/$tfile-%d 100 100
1466     local no_ctxt=`dmesg | grep "No ctxt"`
1467     [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery"
1468 }
1469 run_test 60 "test llog post recovery init vs llog unlink"
1470
1471 #test race  llog recovery thread vs llog cleanup
1472 test_61a() {    # was test_61
1473     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1474
1475     mkdir -p $DIR/$tdir
1476     createmany -o $DIR/$tdir/$tfile-%d 800
1477     replay_barrier ost1
1478 #   OBD_FAIL_OST_LLOG_RECOVERY_TIMEOUT 0x221
1479     unlinkmany $DIR/$tdir/$tfile-%d 800
1480     set_nodes_failloc "$(osts_nodes)" 0x80000221
1481     facet_failover ost1
1482     sleep 10
1483     fail ost1
1484     sleep 30
1485     set_nodes_failloc "$(osts_nodes)" 0x0
1486
1487     $CHECKSTAT -t file $DIR/$tdir/$tfile-* && return 1
1488     rmdir $DIR/$tdir
1489 }
1490 run_test 61a "test race llog recovery vs llog cleanup"
1491
1492 #test race  mds llog sync vs llog cleanup
1493 test_61b() {
1494 #   OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT 0x13a
1495     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000013a"
1496     facet_failover $SINGLEMDS
1497     sleep 10
1498     fail $SINGLEMDS
1499     do_facet client dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 || return 1
1500 }
1501 run_test 61b "test race mds llog sync vs llog cleanup"
1502
1503 #test race  cancel cookie cb vs llog cleanup
1504 test_61c() {
1505     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1506
1507 #   OBD_FAIL_OST_CANCEL_COOKIE_TIMEOUT 0x222
1508     touch $DIR/$tfile
1509     set_nodes_failloc "$(osts_nodes)" 0x80000222
1510     rm $DIR/$tfile
1511     sleep 10
1512     fail ost1
1513     set_nodes_failloc "$(osts_nodes)" 0x0
1514 }
1515 run_test 61c "test race mds llog sync vs llog cleanup"
1516
1517 test_61d() { # bug 16002 # bug 17466
1518     shutdown_facet $SINGLEMDS
1519 #define OBD_FAIL_OBD_LLOG_SETUP        0x605
1520     do_facet $SINGLEMDS "lctl set_param fail_loc=0x605"
1521     start $SINGLEMDS `mdsdevname 1` $MDS_MOUNT_OPTS && error "mds start should have failed"
1522     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1523     start $SINGLEMDS `mdsdevname 1` $MDS_MOUNT_OPTS || error "cannot restart mds"
1524 }
1525 run_test 61d "error in llog_setup should cleanup the llog context correctly"
1526
1527 test_62() { # Bug 15756 - don't mis-drop resent replay
1528     mkdir -p $DIR/$tdir
1529     replay_barrier $SINGLEMDS
1530     createmany -o $DIR/$tdir/$tfile- 25
1531 #define OBD_FAIL_TGT_REPLAY_DROP         0x707
1532     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000707"
1533     facet_failover $SINGLEMDS
1534     df $MOUNT || return 1
1535     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1536     unlinkmany $DIR/$tdir/$tfile- 25 || return 2
1537     return 0
1538 }
1539 run_test 62 "don't mis-drop resent replay"
1540
1541 #Adaptive Timeouts (bug 3055)
1542 AT_MAX_SET=0
1543
1544 at_cleanup () {
1545     local var
1546     local facet
1547     local at_new
1548
1549     echo "Cleaning up AT ..."
1550     if [ -n "$ATOLDBASE" ]; then
1551         local at_history=$($LCTL get_param -n at_history)
1552         do_facet mds "lctl set_param at_history=$at_history" || true
1553         do_facet ost1 "lctl set_param at_history=$at_history" || true
1554     fi
1555
1556     if [ $AT_MAX_SET -ne 0 ]; then
1557         for facet in mds client ost; do
1558             var=AT_MAX_SAVE_${facet}
1559             echo restore AT on $facet to saved value ${!var}
1560             at_max_set ${!var} $facet
1561             at_new=$(at_max_get $facet)
1562             echo Restored AT value on $facet $at_new
1563             [ $at_new -eq ${!var} ] || \
1564             error "$facet : AT value was not restored SAVED ${!var} NEW $at_new"
1565         done
1566     fi
1567 }
1568
1569 at_start()
1570 {
1571     local at_max_new=600
1572
1573     # Save at_max original values
1574     local facet
1575     if [ $AT_MAX_SET -eq 0 ]; then
1576         # Suppose that all osts have the same at_max
1577         for facet in mds client ost; do
1578             eval AT_MAX_SAVE_${facet}=$(at_max_get $facet)
1579         done
1580     fi
1581     local at_max
1582     for facet in mds client ost; do
1583         at_max=$(at_max_get $facet)
1584         if [ $at_max -ne $at_max_new ]; then
1585             echo "AT value on $facet is $at_max, set it by force temporarily to $at_max_new"
1586             at_max_set $at_max_new $facet
1587             AT_MAX_SET=1
1588         fi
1589     done
1590
1591     if [ -z "$ATOLDBASE" ]; then
1592         ATOLDBASE=$(do_facet mds "lctl get_param -n at_history")
1593         # speed up the timebase so we can check decreasing AT
1594         do_facet mds "lctl set_param at_history=8" || true
1595         do_facet ost1 "lctl set_param at_history=8" || true
1596
1597         # sleep for a while to cool down, should be > 8s and also allow
1598         # at least one ping to be sent. simply use TIMEOUT to be safe.
1599         sleep $TIMEOUT
1600     fi
1601 }
1602
1603 test_65a() #bug 3055
1604 {
1605     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1606
1607     at_start || return 0
1608     $LCTL dk > /dev/null
1609     debugsave
1610     sysctl -w lnet.debug="+other"
1611     # Slow down a request to the current service time, this is critical
1612     # because previous tests may have caused this value to increase.
1613     REQ_DELAY=`lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts |
1614                awk '/portal 12/ {print $5}'`
1615     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1616
1617     do_facet mds lctl set_param fail_val=$((${REQ_DELAY} * 1000))
1618 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1619     do_facet mds sysctl -w lustre.fail_loc=0x8000050a
1620     createmany -o $DIR/$tfile 10 > /dev/null
1621     unlinkmany $DIR/$tfile 10 > /dev/null
1622     # check for log message
1623     $LCTL dk | grep "Early reply #" || error "No early reply"
1624     debugrestore
1625     # client should show REQ_DELAY estimates
1626     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1627     sleep 9
1628     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1629 }
1630 run_test 65a "AT: verify early replies"
1631
1632 test_65b() #bug 3055
1633 {
1634     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1635
1636     at_start || return 0
1637     # turn on D_ADAPTTO
1638     debugsave
1639     sysctl -w lnet.debug="other trace"
1640     $LCTL dk > /dev/null
1641     # Slow down a request to the current service time, this is critical
1642     # because previous tests may have caused this value to increase.
1643     REQ_DELAY=`lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts |
1644                awk '/portal 6/ {print $5}'`
1645     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1646
1647     do_facet ost1 lctl set_param fail_val=${REQ_DELAY}
1648 #define OBD_FAIL_OST_BRW_PAUSE_PACK      0x224
1649     do_facet ost1 sysctl -w lustre.fail_loc=0x224
1650
1651     rm -f $DIR/$tfile
1652     lfs setstripe $DIR/$tfile --index=0 --count=1
1653     # force some real bulk transfer
1654     multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
1655
1656     do_facet ost1 sysctl -w lustre.fail_loc=0
1657     # check for log message
1658     $LCTL dk | grep "Early reply #" || error "No early reply"
1659     debugrestore
1660     # client should show REQ_DELAY estimates
1661     lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts | grep portal
1662 }
1663 run_test 65b "AT: verify early replies on packed reply / bulk"
1664
1665 test_66a() #bug 3055
1666 {
1667     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1668
1669     at_start || return 0
1670     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1671     # adjust 5s at a time so no early reply is sent (within deadline)
1672     do_facet mds "sysctl -w lustre.fail_val=5000"
1673 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1674     do_facet mds "sysctl -w lustre.fail_loc=0x8000050a"
1675     createmany -o $DIR/$tfile 20 > /dev/null
1676     unlinkmany $DIR/$tfile 20 > /dev/null
1677     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1678     do_facet mds "sysctl -w lustre.fail_val=10000"
1679     do_facet mds "sysctl -w lustre.fail_loc=0x8000050a"
1680     createmany -o $DIR/$tfile 20 > /dev/null
1681     unlinkmany $DIR/$tfile 20 > /dev/null
1682     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1683     do_facet mds "sysctl -w lustre.fail_loc=0"
1684     sleep 9
1685     createmany -o $DIR/$tfile 20 > /dev/null
1686     unlinkmany $DIR/$tfile 20 > /dev/null
1687     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1688     CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $5}')
1689     WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $7}')
1690     echo "Current MDT timeout $CUR, worst $WORST"
1691     [ $CUR -lt $WORST ] || error "Current $CUR should be less than worst $WORST"
1692 }
1693 run_test 66a "AT: verify MDT service time adjusts with no early replies"
1694
1695 test_66b() #bug 3055
1696 {
1697     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1698
1699     at_start || return 0
1700     ORIG=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $4}')
1701     sysctl -w lustre.fail_val=$(($ORIG + 5))
1702 #define OBD_FAIL_PTLRPC_PAUSE_REP      0x50c
1703     sysctl -w lustre.fail_loc=0x50c
1704     ls $DIR/$tfile > /dev/null 2>&1
1705     sysctl -w lustre.fail_loc=0
1706     CUR=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $4}')
1707     WORST=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $6}')
1708     echo "network timeout orig $ORIG, cur $CUR, worst $WORST"
1709     [ $WORST -gt $ORIG ] || error "Worst $WORST should be worse than orig $ORIG"
1710 }
1711 run_test 66b "AT: verify net latency adjusts"
1712
1713 test_67a() #bug 3055
1714 {
1715     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1716
1717     at_start || return 0
1718     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1719     # sleeping threads may drive values above this
1720     do_facet ost1 "sysctl -w lustre.fail_val=400"
1721 #define OBD_FAIL_PTLRPC_PAUSE_REQ    0x50a
1722     do_facet ost1 "sysctl -w lustre.fail_loc=0x50a"
1723     createmany -o $DIR/$tfile 20 > /dev/null
1724     unlinkmany $DIR/$tfile 20 > /dev/null
1725     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1726     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1727     ATTEMPTS=$(($CONN2 - $CONN1))
1728     echo "$ATTEMPTS osc reconnect attempts on gradual slow"
1729     [ $ATTEMPTS -gt 0 ] && error_ignore 13721 "AT should have prevented reconnect"
1730     return 0
1731 }
1732 run_test 67a "AT: verify slow request processing doesn't induce reconnects"
1733
1734 test_67b() #bug 3055
1735 {
1736     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1737
1738     at_start || return 0
1739     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1740 #define OBD_FAIL_OST_PAUSE_CREATE        0x223
1741     do_facet ost1 "sysctl -w lustre.fail_val=20000"
1742     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000223"
1743     cp /etc/profile $DIR/$tfile || error "cp failed"
1744     client_reconnect
1745     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1746     log "phase 2"
1747     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1748     ATTEMPTS=$(($CONN2 - $CONN1))
1749     echo "$ATTEMPTS osc reconnect attempts on instant slow"
1750     # do it again; should not timeout
1751     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000223"
1752     cp /etc/profile $DIR/$tfile || error "cp failed"
1753     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1754     client_reconnect
1755     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1756     CONN3=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1757     ATTEMPTS=$(($CONN3 - $CONN2))
1758     echo "$ATTEMPTS osc reconnect attempts on 2nd slow"
1759     [ $ATTEMPTS -gt 0 ] && error "AT should have prevented reconnect"
1760     return 0
1761 }
1762 run_test 67b "AT: verify instant slowdown doesn't induce reconnects"
1763
1764 test_68 () #bug 13813
1765 {
1766     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1767
1768     at_start || return 0
1769     local ldlm_enqueue_min=$(find /sys -name ldlm_enqueue_min)
1770     [ -z "$ldlm_enqueue_min" ] && skip "missing /sys/.../ldlm_enqueue_min" && return 0
1771     local ldlm_enqueue_min_r=$(do_facet ost1 "find /sys -name ldlm_enqueue_min")
1772     [ -z "$ldlm_enqueue_min_r" ] && skip "missing /sys/.../ldlm_enqueue_min in the ost1" && return 0
1773     local ENQ_MIN=$(cat $ldlm_enqueue_min)
1774     local ENQ_MIN_R=$(do_facet ost1 "cat $ldlm_enqueue_min_r")
1775     echo $TIMEOUT >> $ldlm_enqueue_min
1776     do_facet ost1 "echo $TIMEOUT >> $ldlm_enqueue_min_r"
1777
1778     rm -rf $DIR/$tdir
1779     mkdir -p $DIR/$tdir
1780     lfs setstripe $DIR/$tdir --index=0 --count=1
1781 #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
1782     sysctl -w lustre.fail_val=$(($TIMEOUT - 1))
1783     sysctl -w lustre.fail_loc=0x80000312
1784     cp /etc/profile $DIR/$tdir/${tfile}_1 || error "1st cp failed $?"
1785     sysctl -w lustre.fail_val=$((TIMEOUT * 5 / 4))
1786     sysctl -w lustre.fail_loc=0x80000312
1787     cp /etc/profile $DIR/$tdir/${tfile}_2 || error "2nd cp failed $?"
1788     sysctl -w lustre.fail_loc=0
1789
1790     echo $ENQ_MIN >> $ldlm_enqueue_min
1791     do_facet ost1 "echo $ENQ_MIN_R >> $ldlm_enqueue_min_r"
1792     rm -rf $DIR/$tdir
1793     return 0
1794 }
1795 run_test 68 "AT: verify slowing locks"
1796
1797 at_cleanup
1798 # end of AT tests includes above lines
1799
1800
1801 # start multi-client tests
1802 test_70a () {
1803         [ -z "$CLIENTS" ] && \
1804                 { skip "Need two or more clients." && return; }
1805         [ $CLIENTCOUNT -lt 2 ] && \
1806                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
1807
1808         echo "mount clients $CLIENTS ..."
1809         zconf_mount_clients $CLIENTS $DIR
1810
1811         local clients=${CLIENTS//,/ }
1812         echo "Write/read files on $DIR ; clients $CLIENTS ... "
1813         for CLIENT in $clients; do
1814                 do_node $CLIENT dd bs=1M count=10 if=/dev/zero \
1815                         of=$DIR/${tfile}_${CLIENT} 2>/dev/null || \
1816                                 error "dd failed on $CLIENT"
1817         done
1818
1819         local prev_client=$(echo $clients | sed 's/^.* \(.\+\)$/\1/')
1820         for C in ${CLIENTS//,/ }; do
1821                 do_node $prev_client dd if=$DIR/${tfile}_${C} of=/dev/null 2>/dev/null || \
1822                         error "dd if=$DIR/${tfile}_${C} failed on $prev_client"
1823                 prev_client=$C
1824         done
1825
1826         ls $DIR
1827 }
1828 run_test 70a "check multi client t-f"
1829
1830 test_70b () {
1831         local clients=${CLIENTS:-$HOSTNAME}
1832
1833         zconf_mount_clients $clients $DIR
1834
1835         local duration=300
1836         [ "$SLOW" = "no" ] && duration=60
1837         local cmd="rundbench 1 -t $duration"
1838         local PID=""
1839         do_nodes $clients "set -x; MISSING_DBENCH_OK=$MISSING_DBENCH_OK \
1840                 PATH=:$PATH:$LUSTRE/utils:$LUSTRE/tests/:$DBENCH_LIB \
1841                 DBENCH_LIB=$DBENCH_LIB TESTSUITE=$TESTSUITE TESTNAME=$TESTNAME \
1842                 LCTL=$LCTL $cmd" &
1843         PID=$!
1844         log "Started rundbench load PID=$PID ..."
1845         ELAPSED=0
1846         NUM_FAILOVERS=0
1847         START_TS=$(date +%s)
1848         CURRENT_TS=$START_TS
1849         while [ $ELAPSED -lt $duration ]; do
1850                 sleep 1
1851                 replay_barrier $SINGLEMDS
1852                 sleep 1 # give clients a time to do operations
1853                 # Increment the number of failovers
1854                 NUM_FAILOVERS=$((NUM_FAILOVERS+1))
1855                 log "$TESTNAME fail mds1 $NUM_FAILOVERS times"
1856                 facet_failover $SINGLEMDS
1857                 CURRENT_TS=$(date +%s)
1858                 ELAPSED=$((CURRENT_TS - START_TS))
1859         done
1860         wait $PID || error "rundbench load on $CLIENTS failed!"
1861 }
1862 run_test 70b "mds recovery; $CLIENTCOUNT clients"
1863 # end multi-client tests
1864
1865 test_73a() {
1866     multiop_bg_pause $DIR/$tfile O_tSc || return 3
1867     pid=$!
1868     rm -f $DIR/$tfile
1869
1870     replay_barrier $SINGLEMDS
1871 #define OBD_FAIL_LDLM_ENQUEUE       0x302
1872     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000302"
1873     fail $SINGLEMDS
1874     kill -USR1 $pid
1875     wait $pid || return 1
1876     [ -e $DIR/$tfile ] && return 2
1877     return 0
1878 }
1879 run_test 73a "open(O_CREAT), unlink, replay, reconnect before open replay , close"
1880
1881 test_73b() {
1882     multiop_bg_pause $DIR/$tfile O_tSc || return 3
1883     pid=$!
1884     rm -f $DIR/$tfile
1885
1886     replay_barrier $SINGLEMDS
1887 #define OBD_FAIL_LDLM_REPLY       0x30c
1888     do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000030c"
1889     fail $SINGLEMDS
1890     kill -USR1 $pid
1891     wait $pid || return 1
1892     [ -e $DIR/$tfile ] && return 2
1893     return 0
1894 }
1895 run_test 73b "open(O_CREAT), unlink, replay, reconnect at open_replay reply, close"
1896
1897 test_73c() {
1898     multiop_bg_pause $DIR/$tfile O_tSc || return 3
1899     pid=$!
1900     rm -f $DIR/$tfile
1901
1902     replay_barrier $SINGLEMDS
1903 #define OBD_FAIL_TGT_LAST_REPLAY       0x710
1904     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000710"
1905     fail $SINGLEMDS
1906     kill -USR1 $pid
1907     wait $pid || return 1
1908     [ -e $DIR/$tfile ] && return 2
1909     return 0
1910 }
1911 run_test 73c "open(O_CREAT), unlink, replay, reconnect at last_replay, close"
1912
1913 # bug 18554
1914 test_74() {
1915     stop ost1
1916     zconf_umount $(hostname) $MOUNT
1917     fail $SINGLEMDS
1918     zconf_mount $(hostname) $MOUNT
1919     mount_facet ost1
1920     touch $DIR/$tfile || return 1
1921     rm $DIR/$tfile || return 2
1922     df $MOUNT || error "df failed: $?"
1923     return 0
1924 }
1925 run_test 74 "Ensure applications don't fail waiting for OST reocvery"
1926
1927 test_80a() {
1928     [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1929
1930     mkdir -p $DIR/$tdir
1931     replay_barrier mds2
1932     $CHECKSTAT -t dir $DIR/$tdir || error "$CHECKSTAT -t dir $DIR/$tdir failed"
1933     rmdir $DIR/$tdir || error "rmdir $DIR/$tdir failed"
1934     fail mds2
1935     stat $DIR/$tdir 2&>/dev/null && error "$DIR/$tdir still exist after recovery!"
1936     return 0
1937 }
1938 run_test 80a "CMD: unlink cross-node dir (fail mds with inode)"
1939
1940 test_80b() {
1941     [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1942
1943     mkdir -p $DIR/$tdir
1944     replay_barrier mds1
1945     $CHECKSTAT -t dir $DIR/$tdir || error "$CHECKSTAT -t dir $DIR/$tdir failed"
1946     rmdir $DIR/$tdir || error "rmdir $DIR/$tdir failed"
1947     fail mds1
1948     stat $DIR/$tdir 2&>/dev/null && error "$DIR/$tdir still exist after recovery!"
1949     return 0
1950 }
1951 run_test 80b "CMD: unlink cross-node dir (fail mds with name)"
1952
1953 test_81a() {
1954     [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1955
1956     mkdir -p $DIR/$tdir
1957     createmany -o $DIR/$tdir/f 3000 || error "createmany failed"
1958     sleep 10
1959     $CHECKSTAT -t dir $DIR/$tdir || error "$CHECKSTAT -t dir failed"
1960     $CHECKSTAT -t file $DIR/$tdir/f1002 || error "$CHECKSTAT -t file failed"
1961     replay_barrier mds1
1962     rm $DIR/$tdir/f1002 || error "rm $DIR/$tdir/f1002 failed"
1963     fail mds1
1964     stat $DIR/$tdir/f1002
1965 }
1966 run_test 81a "CMD: unlink cross-node file (fail mds with name)"
1967
1968 test_82a() {
1969     [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1970
1971     local dir=$DIR/d82a
1972     replay_barrier mds2
1973     mkdir $dir || error "mkdir $dir failed"
1974     log "FAILOVER mds2"
1975     fail mds2
1976     stat $DIR
1977     $CHECKSTAT -t dir $dir || error "$CHECKSTAT -t dir $dir failed"
1978 }
1979 run_test 82a "CMD: mkdir cross-node dir (fail mds with inode)"
1980
1981 test_82b() {
1982     [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1983
1984     local dir=$DIR/d82b
1985     replay_barrier mds1
1986     mkdir $dir || error "mkdir $dir failed"
1987     log "FAILOVER mds1"
1988     fail mds1
1989     stat $DIR
1990     $CHECKSTAT -t dir $dir || error "$CHECKSTAT -t dir $dir failed"
1991 }
1992 run_test 82b "CMD: mkdir cross-node dir (fail mds with name)"
1993
1994 test_84() {
1995 #define OBD_FAIL_MDS_OPEN_WAIT_CREATE  0x143
1996     do_facet mds "lctl set_param fail_loc=0x80000143"
1997     createmany -o $DIR/$tfile- 1 &
1998     PID=$!
1999     mds_evict_client
2000     wait $PID
2001     df -P $DIR || df -P $DIR || true    # reconnect
2002 }
2003 run_test 84 "stale open during export disconnect"
2004
2005 equals_msg `basename $0`: test complete, cleaning up
2006 check_and_cleanup_lustre
2007 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG && grep -q FAIL $TESTSUITELOG && exit 1 || true