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:-`dirname $0`/..}
  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 # Skip these tests
  20 # bug number:
  21 ALWAYS_EXCEPT="$REPLAY_SINGLE_EXCEPT"
  22
  23 #                                                  63 min  7 min  AT AT AT AT"
  24 [ "$SLOW" = "no" ] && EXCEPT_SLOW="1 2 3 4 6 12 16 44a     44b    65 66 67 68"
  25
  26 build_test_filter
  27
  28 cleanup_and_setup_lustre
  29
  30 mkdir -p $DIR
  31
  32 rm -rf $DIR/[df][0-9]*
  33
  34 test_0a() {     # was test_0
  35     replay_barrier mds
  36     fail mds
  37 }
  38 run_test 0a "empty replay"
  39
  40 test_0b() {
  41     # this test attempts to trigger a race in the precreation code,
  42     # and must run before any other objects are created on the filesystem
  43     fail ost1
  44     createmany -o $DIR/$tfile 20 || return 1
  45     unlinkmany $DIR/$tfile 20 || return 2
  46 }
  47 run_test 0b "ensure object created after recover exists. (3284)"
  48
  49 test_1() {
  50     replay_barrier mds
  51     mcreate $DIR/$tfile
  52     fail mds
  53     $CHECKSTAT -t file $DIR/$tfile || return 1
  54     rm $DIR/$tfile
  55 }
  56 run_test 1 "simple create"
  57
  58 test_2a() {
  59     replay_barrier mds
  60     touch $DIR/$tfile
  61     fail mds
  62     $CHECKSTAT -t file $DIR/$tfile || return 1
  63     rm $DIR/$tfile
  64 }
  65 run_test 2a "touch"
  66
  67 test_2b() {
  68     mcreate $DIR/$tfile
  69     replay_barrier mds
  70     touch $DIR/$tfile
  71     fail mds
  72     $CHECKSTAT -t file $DIR/$tfile || return 1
  73     rm $DIR/$tfile
  74 }
  75 run_test 2b "touch"
  76
  77 test_3a() {
  78     replay_barrier mds
  79     mcreate $DIR/$tfile
  80     o_directory $DIR/$tfile
  81     fail mds
  82     $CHECKSTAT -t file $DIR/$tfile || return 2
  83     rm $DIR/$tfile
  84 }
  85 run_test 3a "replay failed open(O_DIRECTORY)"
  86
  87 test_3b() {
  88     replay_barrier mds
  89 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
  90     do_facet mds "lctl set_param fail_loc=0x80000114"
  91     touch $DIR/$tfile
  92     do_facet mds "lctl set_param fail_loc=0"
  93     fail mds
  94     $CHECKSTAT -t file $DIR/$tfile && return 2
  95     return 0
  96 }
  97 run_test 3b "replay failed open -ENOMEM"
  98
  99 test_3c() {
 100     replay_barrier mds
 101 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 102     do_facet mds "lctl set_param fail_loc=0x80000128"
 103     touch $DIR/$tfile
 104     do_facet mds "lctl set_param fail_loc=0"
 105     fail mds
 106
 107     $CHECKSTAT -t file $DIR/$tfile && return 2
 108     return 0
 109 }
 110 run_test 3c "replay failed open -ENOMEM"
 111
 112 test_4a() {     # was test_4
 113     replay_barrier mds
 114     for i in `seq 10`; do
 115         echo "tag-$i" > $DIR/$tfile-$i
 116     done
 117     fail mds
 118     for i in `seq 10`; do
 119       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 120     done
 121 }
 122 run_test 4a "|x| 10 open(O_CREAT)s"
 123
 124 test_4b() {
 125     replay_barrier mds
 126     rm -rf $DIR/$tfile-*
 127     fail mds
 128     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 129 }
 130 run_test 4b "|x| rm 10 files"
 131
 132 # The idea is to get past the first block of precreated files on both
 133 # osts, and then replay.
 134 test_5() {
 135     replay_barrier mds
 136     for i in `seq 220`; do
 137         echo "tag-$i" > $DIR/$tfile-$i
 138     done
 139     fail mds
 140     for i in `seq 220`; do
 141       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
 142     done
 143     rm -rf $DIR/$tfile-*
 144     sleep 3
 145     # waiting for commitment of removal
 146 }
 147 run_test 5 "|x| 220 open(O_CREAT)"
 148
 149
 150 test_6a() {     # was test_6a
 151     replay_barrier mds
 152     mcreate $DIR/$tdir/$tfile
 153     fail mds
 154     $CHECKSTAT -t dir $DIR/$tdir || return 1
 155     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 156     sleep 2
 157     # waiting for log process thread
 158 }
 159 run_test 6a "mkdir + contained create"
 160
 161 test_6b() {
 162     replay_barrier mds
 163     rm -rf $DIR/$tdir
 164     fail mds
 165     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 166 }
 167 run_test 6b "|X| rmdir"
 168
 169 test_7() {
 170     replay_barrier mds
 171     mcreate $DIR/$tdir/$tfile
 172     fail mds
 173     $CHECKSTAT -t dir $DIR/$tdir || return 1
 174     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 175     rm -fr $DIR/$tdir
 176 }
 177 run_test 7 "mkdir |X| contained create"
 178
 179 test_8() {
 180     replay_barrier mds
 181     multiop_bg_pause $DIR/$tfile mo_c || return 4
 182     MULTIPID=$!
 183     fail mds
 184     ls $DIR/$tfile
 185     $CHECKSTAT -t file $DIR/$tfile || return 1
 186     kill -USR1 $MULTIPID || return 2
 187     wait $MULTIPID || return 3
 188     rm $DIR/$tfile
 189 }
 190 run_test 8 "creat open |X| close"
 191
 192 test_9() {
 193     replay_barrier mds
 194     mcreate $DIR/$tfile
 195     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 196     fail mds
 197     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 198
 199     echo " old_inum == $old_inum, new_inum == $new_inum"
 200     if [ $old_inum -eq $new_inum  ] ;
 201     then
 202         echo " old_inum and new_inum match"
 203     else
 204         echo "!!!! old_inum and new_inum NOT match"
 205         return 1
 206     fi
 207     rm $DIR/$tfile
 208 }
 209 run_test 9  "|X| create (same inum/gen)"
 210
 211 test_10() {
 212     mcreate $DIR/$tfile
 213     replay_barrier mds
 214     mv $DIR/$tfile $DIR/$tfile-2
 215     rm -f $DIR/$tfile
 216     fail mds
 217     $CHECKSTAT $DIR/$tfile && return 1
 218     $CHECKSTAT $DIR/$tfile-2 ||return 2
 219     rm $DIR/$tfile-2
 220     return 0
 221 }
 222 run_test 10 "create |X| rename unlink"
 223
 224 test_11() {
 225     mcreate $DIR/$tfile
 226     echo "old" > $DIR/$tfile
 227     mv $DIR/$tfile $DIR/$tfile-2
 228     replay_barrier mds
 229     echo "new" > $DIR/$tfile
 230     grep new $DIR/$tfile
 231     grep old $DIR/$tfile-2
 232     fail mds
 233     grep new $DIR/$tfile || return 1
 234     grep old $DIR/$tfile-2 || return 2
 235 }
 236 run_test 11 "create open write rename |X| create-old-name read"
 237
 238 test_12() {
 239     mcreate $DIR/$tfile
 240     multiop_bg_pause $DIR/$tfile o_tSc || return 3
 241     pid=$!
 242     rm -f $DIR/$tfile
 243     replay_barrier mds
 244     kill -USR1 $pid
 245     wait $pid || return 1
 246
 247     fail mds
 248     [ -e $DIR/$tfile ] && return 2
 249     return 0
 250 }
 251 run_test 12 "open, unlink |X| close"
 252
 253
 254 # 1777 - replay open after committed chmod that would make
 255 #        a regular open a failure
 256 test_13() {
 257     mcreate $DIR/$tfile
 258     multiop_bg_pause $DIR/$tfile O_wc || return 3
 259     pid=$!
 260     chmod 0 $DIR/$tfile
 261     $CHECKSTAT -p 0 $DIR/$tfile
 262     replay_barrier mds
 263     fail mds
 264     kill -USR1 $pid
 265     wait $pid || return 1
 266
 267     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
 268     return 0
 269 }
 270 run_test 13 "open chmod 0 |x| write close"
 271
 272 test_14() {
 273     multiop_bg_pause $DIR/$tfile O_tSc || return 4
 274     pid=$!
 275     rm -f $DIR/$tfile
 276     replay_barrier mds
 277     kill -USR1 $pid || return 1
 278     wait $pid || return 2
 279
 280     fail mds
 281     [ -e $DIR/$tfile ] && return 3
 282     return 0
 283 }
 284 run_test 14 "open(O_CREAT), unlink |X| close"
 285
 286 test_15() {
 287     multiop_bg_pause $DIR/$tfile O_tSc || return 5
 288     pid=$!
 289     rm -f $DIR/$tfile
 290     replay_barrier mds
 291     touch $DIR/g11 || return 1
 292     kill -USR1 $pid
 293     wait $pid || return 2
 294
 295     fail mds
 296     [ -e $DIR/$tfile ] && return 3
 297     touch $DIR/h11 || return 4
 298     return 0
 299 }
 300 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 301
 302
 303 test_16() {
 304     replay_barrier mds
 305     mcreate $DIR/$tfile
 306     munlink $DIR/$tfile
 307     mcreate $DIR/$tfile-2
 308     fail mds
 309     [ -e $DIR/$tfile ] && return 1
 310     [ -e $DIR/$tfile-2 ] || return 2
 311     munlink $DIR/$tfile-2 || return 3
 312 }
 313 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 314
 315 test_17() {
 316     replay_barrier mds
 317     multiop_bg_pause $DIR/$tfile O_c || return 4
 318     pid=$!
 319     fail mds
 320     kill -USR1 $pid || return 1
 321     wait $pid || return 2
 322     $CHECKSTAT -t file $DIR/$tfile || return 3
 323     rm $DIR/$tfile
 324 }
 325 run_test 17 "|X| open(O_CREAT), |replay| close"
 326
 327 test_18() {
 328     replay_barrier mds
 329     multiop_bg_pause $DIR/$tfile O_tSc || return 8
 330     pid=$!
 331     rm -f $DIR/$tfile
 332     touch $DIR/$tfile-2 || return 1
 333     echo "pid: $pid will close"
 334     kill -USR1 $pid
 335     wait $pid || return 2
 336
 337     fail mds
 338     [ -e $DIR/$tfile ] && return 3
 339     [ -e $DIR/$tfile-2 ] || return 4
 340     # this touch frequently fails
 341     touch $DIR/$tfile-3 || return 5
 342     munlink $DIR/$tfile-2 || return 6
 343     munlink $DIR/$tfile-3 || return 7
 344     return 0
 345 }
 346 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
 347
 348 # bug 1855 (a simpler form of test_11 above)
 349 test_19() {
 350     replay_barrier mds
 351     mcreate $DIR/$tfile
 352     echo "old" > $DIR/$tfile
 353     mv $DIR/$tfile $DIR/$tfile-2
 354     grep old $DIR/$tfile-2
 355     fail mds
 356     grep old $DIR/$tfile-2 || return 2
 357 }
 358 run_test 19 "|X| mcreate, open, write, rename "
 359
 360 test_20a() {    # was test_20
 361     replay_barrier mds
 362     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 363     pid=$!
 364     rm -f $DIR/$tfile
 365
 366     fail mds
 367     kill -USR1 $pid
 368     wait $pid || return 1
 369     [ -e $DIR/$tfile ] && return 2
 370     return 0
 371 }
 372 run_test 20a "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 373
 374 test_20b() { # bug 10480
 375     BEFOREUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 376
 377     dd if=/dev/zero of=$DIR/$tfile bs=4k count=10000 &
 378     pid=$!
 379     while [ ! -e $DIR/$tfile ] ; do
 380         sleep 0.060s                           # give dd a chance to start
 381     done
 382
 383     lfs getstripe $DIR/$tfile || return 1
 384     rm -f $DIR/$tfile || return 2       # make it an orphan
 385     mds_evict_client
 386     df -P $DIR || df -P $DIR || true    # reconnect
 387
 388     fail mds                            # start orphan recovery
 389     df -P $DIR || df -P $DIR || true    # reconnect
 390     wait_mds_recovery_done || error "MDS recovery not done"
 391
 392     AFTERUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 393     log "before $BEFOREUSED, after $AFTERUSED"
 394     [ $AFTERUSED -gt $((BEFOREUSED + 20)) ] && \
 395         error "after $AFTERUSED > before $BEFOREUSED" && return 5
 396     return 0
 397 }
 398 run_test 20b "write, unlink, eviction, replay, (test mds_cleanup_orphans)"
 399
 400 test_20c() { # bug 10480
 401     multiop $DIR/$tfile Ow_c &
 402     pid=$!
 403     # give multiop a chance to open
 404     sleep 1
 405
 406     ls -la $DIR/$tfile
 407
 408     mds_evict_client
 409
 410     df -P $DIR || df -P $DIR || true    # reconnect
 411
 412     kill -USR1 $pid
 413     test -s $DIR/$tfile || error "File was truncated"
 414
 415     return 0
 416 }
 417 run_test 20c "check that client eviction does not affect file content"
 418
 419 test_21() {
 420     replay_barrier mds
 421     multiop_bg_pause $DIR/$tfile O_tSc || return 5
 422     pid=$!
 423     rm -f $DIR/$tfile
 424     touch $DIR/g11 || return 1
 425
 426     fail mds
 427     kill -USR1 $pid
 428     wait $pid || return 2
 429     [ -e $DIR/$tfile ] && return 3
 430     touch $DIR/h11 || return 4
 431     return 0
 432 }
 433 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 434
 435 test_22() {
 436     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 437     pid=$!
 438
 439     replay_barrier mds
 440     rm -f $DIR/$tfile
 441
 442     fail mds
 443     kill -USR1 $pid
 444     wait $pid || return 1
 445     [ -e $DIR/$tfile ] && return 2
 446     return 0
 447 }
 448 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
 449
 450 test_23() {
 451     multiop_bg_pause $DIR/$tfile O_tSc || return 5
 452     pid=$!
 453
 454     replay_barrier mds
 455     rm -f $DIR/$tfile
 456     touch $DIR/g11 || return 1
 457
 458     fail mds
 459     kill -USR1 $pid
 460     wait $pid || return 2
 461     [ -e $DIR/$tfile ] && return 3
 462     touch $DIR/h11 || return 4
 463     return 0
 464 }
 465 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 466
 467 test_24() {
 468     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 469     pid=$!
 470
 471     replay_barrier mds
 472     fail mds
 473     rm -f $DIR/$tfile
 474     kill -USR1 $pid
 475     wait $pid || return 1
 476     [ -e $DIR/$tfile ] && return 2
 477     return 0
 478 }
 479 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 480
 481 test_25() {
 482     multiop_bg_pause $DIR/$tfile O_tSc || return 3
 483     pid=$!
 484     rm -f $DIR/$tfile
 485
 486     replay_barrier mds
 487     fail mds
 488     kill -USR1 $pid
 489     wait $pid || return 1
 490     [ -e $DIR/$tfile ] && return 2
 491     return 0
 492 }
 493 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 494
 495 test_26() {
 496     replay_barrier mds
 497     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 498     pid1=$!
 499     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 500     pid2=$!
 501     rm -f $DIR/$tfile-1
 502     rm -f $DIR/$tfile-2
 503     kill -USR1 $pid2
 504     wait $pid2 || return 1
 505
 506     fail mds
 507     kill -USR1 $pid1
 508     wait $pid1 || return 2
 509     [ -e $DIR/$tfile-1 ] && return 3
 510     [ -e $DIR/$tfile-2 ] && return 4
 511     return 0
 512 }
 513 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 514
 515 test_27() {
 516     replay_barrier mds
 517     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 518     pid1=$!
 519     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 520     pid2=$!
 521     rm -f $DIR/$tfile-1
 522     rm -f $DIR/$tfile-2
 523
 524     fail mds
 525     kill -USR1 $pid1
 526     wait $pid1 || return 1
 527     kill -USR1 $pid2
 528     wait $pid2 || return 2
 529     [ -e $DIR/$tfile-1 ] && return 3
 530     [ -e $DIR/$tfile-2 ] && return 4
 531     return 0
 532 }
 533 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 534
 535 test_28() {
 536     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 537     pid1=$!
 538     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 539     pid2=$!
 540     replay_barrier mds
 541     rm -f $DIR/$tfile-1
 542     rm -f $DIR/$tfile-2
 543     kill -USR1 $pid2
 544     wait $pid2 || return 1
 545
 546     fail mds
 547     kill -USR1 $pid1
 548     wait $pid1 || return 2
 549     [ -e $DIR/$tfile-1 ] && return 3
 550     [ -e $DIR/$tfile-2 ] && return 4
 551     return 0
 552 }
 553 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 554
 555 test_29() {
 556     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 557     pid1=$!
 558     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 559     pid2=$!
 560     replay_barrier mds
 561     rm -f $DIR/$tfile-1
 562     rm -f $DIR/$tfile-2
 563
 564     fail mds
 565     kill -USR1 $pid1
 566     wait $pid1 || return 1
 567     kill -USR1 $pid2
 568     wait $pid2 || return 2
 569     [ -e $DIR/$tfile-1 ] && return 3
 570     [ -e $DIR/$tfile-2 ] && return 4
 571     return 0
 572 }
 573 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 574
 575 test_30() {
 576     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 577     pid1=$!
 578     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 579     pid2=$!
 580     rm -f $DIR/$tfile-1
 581     rm -f $DIR/$tfile-2
 582
 583     replay_barrier mds
 584     fail mds
 585     kill -USR1 $pid1
 586     wait $pid1 || return 1
 587     kill -USR1 $pid2
 588     wait $pid2 || return 2
 589     [ -e $DIR/$tfile-1 ] && return 3
 590     [ -e $DIR/$tfile-2 ] && return 4
 591     return 0
 592 }
 593 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 594
 595 test_31() {
 596     multiop_bg_pause $DIR/$tfile-1 O_tSc || return 5
 597     pid1=$!
 598     multiop_bg_pause $DIR/$tfile-2 O_tSc || return 6
 599     pid2=$!
 600     rm -f $DIR/$tfile-1
 601
 602     replay_barrier mds
 603     rm -f $DIR/$tfile-2
 604     fail mds
 605     kill -USR1 $pid1
 606     wait $pid1 || return 1
 607     kill -USR1 $pid2
 608     wait $pid2 || return 2
 609     [ -e $DIR/$tfile-1 ] && return 3
 610     [ -e $DIR/$tfile-2 ] && return 4
 611     return 0
 612 }
 613 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 614
 615 # tests for bug 2104; completion without crashing is success.  The close is
 616 # stale, but we always return 0 for close, so the app never sees it.
 617 test_32() {
 618     multiop_bg_pause $DIR/$tfile O_c || return 2
 619     pid1=$!
 620     multiop_bg_pause $DIR/$tfile O_c || return 3
 621     pid2=$!
 622     mds_evict_client
 623     df $MOUNT || sleep 1 && df $MOUNT || return 1
 624     kill -USR1 $pid1
 625     kill -USR1 $pid2
 626     sleep 1
 627     return 0
 628 }
 629 run_test 32 "close() notices client eviction; close() after client eviction"
 630
 631 # Abort recovery before client complete
 632 test_33a() {    # was test_33
 633     replay_barrier mds
 634     createmany -o $DIR/$tfile-%d 100
 635     fail_abort mds
 636     # this file should be gone, because the replay was aborted
 637     $CHECKSTAT -t file $DIR/$tfile-* && return 3
 638     unlinkmany $DIR/$tfile-%d 0 100
 639     return 0
 640 }
 641 run_test 33a "abort recovery before client does replay"
 642
 643 test_34() {
 644     multiop_bg_pause $DIR/$tfile O_c || return 2
 645     pid=$!
 646     rm -f $DIR/$tfile
 647
 648     replay_barrier mds
 649     fail_abort mds
 650     kill -USR1 $pid
 651     [ -e $DIR/$tfile ] && return 1
 652     sync
 653     return 0
 654 }
 655 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 656
 657 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 658 test_35() {
 659     touch $DIR/$tfile
 660
 661 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 662     do_facet mds "lctl set_param fail_loc=0x80000119"
 663     rm -f $DIR/$tfile &
 664     sleep 1
 665     sync
 666     sleep 1
 667     # give a chance to remove from MDS
 668     fail_abort mds
 669     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
 670 }
 671 run_test 35 "test recovery from llog for unlink op"
 672
 673 # b=2432 resent cancel after replay uses wrong cookie,
 674 # so don't resend cancels
 675 test_36() {
 676     replay_barrier mds
 677     touch $DIR/$tfile
 678     checkstat $DIR/$tfile
 679     facet_failover mds
 680     cancel_lru_locks mdc
 681     if dmesg | grep "unknown lock cookie"; then
 682         echo "cancel after replay failed"
 683         return 1
 684     fi
 685 }
 686 run_test 36 "don't resend cancel"
 687
 688 # b=2368
 689 # directory orphans can't be unlinked from PENDING directory
 690 test_37() {
 691     rmdir $DIR/$tfile 2>/dev/null
 692     multiop_bg_pause $DIR/$tfile dD_c || return 2
 693     pid=$!
 694     rmdir $DIR/$tfile
 695
 696     replay_barrier mds
 697     # clear the dmesg buffer so we only see errors from this recovery
 698     dmesg -c >/dev/null
 699     fail_abort mds
 700     kill -USR1 $pid
 701     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
 702     sync
 703     return 0
 704 }
 705 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 706
 707 test_38() {
 708     createmany -o $DIR/$tfile-%d 800
 709     unlinkmany $DIR/$tfile-%d 0 400
 710     replay_barrier mds
 711     fail mds
 712     unlinkmany $DIR/$tfile-%d 400 400
 713     sleep 2
 714     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 715 }
 716 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 717
 718 test_39() { # bug 4176
 719     createmany -o $DIR/$tfile-%d 800
 720     replay_barrier mds
 721     unlinkmany $DIR/$tfile-%d 0 400
 722     fail mds
 723     unlinkmany $DIR/$tfile-%d 400 400
 724     sleep 2
 725     ls -1f $DIR/$tfile-*
 726     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 727 }
 728 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 729
 730 count_ost_writes() {
 731     lctl get_param -n osc.*.stats | awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
 732 }
 733
 734 #b=2477,2532
 735 test_40(){
 736     $LCTL mark multiop $MOUNT/$tfile OS_c
 737     multiop $MOUNT/$tfile OS_c  &
 738     PID=$!
 739     writeme -s $MOUNT/${tfile}-2 &
 740     WRITE_PID=$!
 741     sleep 1
 742     facet_failover mds
 743 #define OBD_FAIL_MDS_CONNECT_NET         0x117
 744     do_facet mds "lctl set_param fail_loc=0x80000117"
 745     kill -USR1 $PID
 746     stat1=`count_ost_writes`
 747     sleep $TIMEOUT
 748     stat2=`count_ost_writes`
 749     echo "$stat1, $stat2"
 750     if [ $stat1 -lt $stat2 ]; then
 751        echo "writes continuing during recovery"
 752        RC=0
 753     else
 754        echo "writes not continuing during recovery, bug 2477"
 755        RC=4
 756     fi
 757     echo "waiting for writeme $WRITE_PID"
 758     kill $WRITE_PID
 759     wait $WRITE_PID
 760
 761     echo "waiting for multiop $PID"
 762     wait $PID || return 2
 763     do_facet client munlink $MOUNT/$tfile  || return 3
 764     do_facet client munlink $MOUNT/${tfile}-2  || return 3
 765     return $RC
 766 }
 767 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 768
 769
 770 #b=2814
 771 # make sure that a read to one osc doesn't try to double-unlock its page just
 772 # because another osc is invalid.  trigger_group_io used to mistakenly return
 773 # an error if any oscs were invalid even after having successfully put rpcs
 774 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 775 # the page, guarnateeing that the unlock from the RPC completion would
 776 # assert on trying to unlock the unlocked page.
 777 test_41() {
 778     [ $OSTCOUNT -lt 2 ] && \
 779         skip "skipping test 41: we don't have a second OST to test with" && \
 780         return
 781
 782     local f=$MOUNT/$tfile
 783     # make sure the start of the file is ost1
 784     lfs setstripe $f -s $((128 * 1024)) -i 0
 785     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
 786     cancel_lru_locks osc
 787     # fail ost2 and read from ost1
 788     local osc2dev=`lctl get_param -n devices | grep ${ost2_svc}-osc- | awk '{print $1}'`
 789     [ "$osc2dev" ] || return 4
 790     $LCTL --device $osc2dev deactivate || return 1
 791     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
 792     $LCTL --device $osc2dev activate || return 2
 793     return 0
 794 }
 795 run_test 41 "read from a valid osc while other oscs are invalid"
 796
 797 # test MDS recovery after ost failure
 798 test_42() {
 799     blocks=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 800     createmany -o $DIR/$tfile-%d 800
 801     replay_barrier ost1
 802     unlinkmany $DIR/$tfile-%d 0 400
 803     debugsave
 804     lctl set_param debug=-1
 805     facet_failover ost1
 806
 807     # osc is evicted, fs is smaller (but only with failout OSTs (bug 7287)
 808     #blocks_after=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 809     #[ $blocks_after -lt $blocks ] || return 1
 810     echo wait for MDS to timeout and recover
 811     sleep $((TIMEOUT * 2))
 812     debugrestore
 813     unlinkmany $DIR/$tfile-%d 400 400
 814     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
 815 }
 816 run_test 42 "recovery after ost failure"
 817
 818 # timeout in MDS/OST recovery RPC will LBUG MDS
 819 test_43() { # bug 2530
 820     replay_barrier mds
 821
 822     # OBD_FAIL_OST_CREATE_NET 0x204
 823     do_facet ost1 "lctl set_param fail_loc=0x80000204"
 824     fail mds
 825     sleep 10
 826     do_facet ost1 "lctl set_param fail_loc=0"
 827
 828     return 0
 829 }
 830 run_test 43 "mds osc import failure during recovery; don't LBUG"
 831
 832 test_44a() {    # was test_44
 833     local at_max_saved=0
 834
 835     mdcdev=`lctl get_param -n devices | awk '/-mdc-/ {print $1}'`
 836     [ "$mdcdev" ] || exit 2
 837
 838     # adaptive timeouts slow this way down
 839     if at_is_valid && at_is_enabled; then
 840         at_max_saved=$(at_max_get mds)
 841         at_max_set 40 mds
 842     fi
 843
 844     for i in `seq 1 10`; do
 845         echo "$i of 10 ($(date +%s))"
 846         do_facet mds "lctl get_param -n mdt.MDS.mds.timeouts | grep service"
 847         #define OBD_FAIL_TGT_CONN_RACE     0x701
 848         do_facet mds "lctl set_param fail_loc=0x80000701"
 849         $LCTL --device $mdcdev recover
 850         df $MOUNT
 851     done
 852
 853     do_facet mds "lctl set_param fail_loc=0"
 854     [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved mds
 855     return 0
 856 }
 857 run_test 44a "race in target handle connect"
 858
 859 test_44b() {
 860     mdcdev=`lctl get_param -n devices | awk '/-mdc-/ {print $1}'`
 861     [ "$mdcdev" ] || exit 2
 862     for i in `seq 1 10`; do
 863         echo "$i of 10 ($(date +%s))"
 864         do_facet mds "lctl get_param -n mdt.MDS.mds.timeouts | grep service"
 865         #define OBD_FAIL_TGT_DELAY_RECONNECT 0x704
 866         do_facet mds "lctl set_param fail_loc=0x80000704"
 867         $LCTL --device $mdcdev recover
 868         df $MOUNT
 869     done
 870     do_facet mds "lctl set_param fail_loc=0"
 871     return 0
 872 }
 873 run_test 44b "race in target handle connect"
 874
 875 # Handle failed close
 876 test_45() {
 877     mdcdev=`lctl get_param -n devices | awk '/-mdc-/ {print $1}'`
 878     [ "$mdcdev" ] || exit 2
 879     $LCTL --device $mdcdev recover
 880
 881     multiop_bg_pause $DIR/$tfile O_c || return 1
 882     pid=$!
 883
 884     # This will cause the CLOSE to fail before even
 885     # allocating a reply buffer
 886     $LCTL --device $mdcdev deactivate || return 4
 887
 888     # try the close
 889     kill -USR1 $pid
 890     wait $pid || return 1
 891
 892     $LCTL --device $mdcdev activate || return 5
 893     sleep 1
 894
 895     $CHECKSTAT -t file $DIR/$tfile || return 2
 896     return 0
 897 }
 898 run_test 45 "Handle failed close"
 899
 900 test_46() {
 901     dmesg -c >/dev/null
 902     drop_reply "touch $DIR/$tfile"
 903     fail mds
 904     # ironically, the previous test, 45, will cause a real forced close,
 905     # so just look for one for this test
 906     dmesg | grep -i "force closing client file handle for $tfile" && return 1
 907     return 0
 908 }
 909 run_test 46 "Don't leak file handle after open resend (3325)"
 910
 911 test_47() { # bug 2824
 912     # create some files to make sure precreate has been done on all
 913     # OSTs. (just in case this test is run independently)
 914     createmany -o $DIR/$tfile 20  || return 1
 915
 916     # OBD_FAIL_OST_CREATE_NET 0x204
 917     fail ost1
 918     do_facet ost1 "lctl set_param fail_loc=0x80000204"
 919     df $MOUNT || return 2
 920
 921     # let the MDS discover the OST failure, attempt to recover, fail
 922     # and recover again.
 923     sleep $((3 * TIMEOUT))
 924
 925     # Without 2824, this createmany would hang
 926     createmany -o $DIR/$tfile 20 || return 3
 927     unlinkmany $DIR/$tfile 20 || return 4
 928
 929     do_facet ost1 "lctl set_param fail_loc=0"
 930     return 0
 931 }
 932 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
 933
 934 test_48() {
 935     replay_barrier mds
 936     createmany -o $DIR/$tfile 20  || return 1
 937     # OBD_FAIL_OST_EROFS 0x216
 938     fail mds
 939     do_facet ost1 "lctl set_param fail_loc=0x80000216"
 940     df $MOUNT || return 2
 941
 942     createmany -o $DIR/$tfile 20 20 || return 2
 943     unlinkmany $DIR/$tfile 40 || return 3
 944
 945     do_facet ost1 "lctl set_param fail_loc=0"
 946     return 0
 947 }
 948 run_test 48 "MDS->OSC failure during precreate cleanup (2824)"
 949
 950 test_50() {
 951     local oscdev=`do_facet mds lctl get_param -n devices | grep ${ost1_svc}-osc | awk '{print $1}' | head -1`
 952     [ "$oscdev" ] || return 1
 953     do_facet mds $LCTL --device $oscdev recover || return 2
 954     do_facet mds $LCTL --device $oscdev recover || return 3
 955     # give the mds_lov_sync threads a chance to run
 956     sleep 5
 957 }
 958 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
 959
 960 # b3764 timed out lock replay
 961 test_52() {
 962     touch $DIR/$tfile
 963     cancel_lru_locks mdc
 964
 965     multiop $DIR/$tfile s || return 1
 966     replay_barrier mds
 967 #define OBD_FAIL_LDLM_REPLY              0x30c
 968     do_facet mds "lctl set_param fail_loc=0x8000030c"
 969     fail mds || return 2
 970     do_facet mds "lctl set_param fail_loc=0x0"
 971
 972     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
 973 }
 974 run_test 52 "time out lock replay (3764)"
 975
 976 # bug 3462 - simultaneous MDC requests
 977 test_53a() {
 978     mkdir -p $DIR/${tdir}-1
 979     mkdir -p $DIR/${tdir}-2
 980     multiop $DIR/${tdir}-1/f O_c &
 981     close_pid=$!
 982     # give multiop a chance to open
 983     sleep 1
 984
 985     #define OBD_FAIL_MDS_CLOSE_NET 0x115
 986     do_facet mds "lctl set_param fail_loc=0x80000115"
 987     kill -USR1 $close_pid
 988     cancel_lru_locks MDC # force the close
 989     do_facet mds "lctl set_param fail_loc=0"
 990     mcreate $DIR/${tdir}-2/f || return 1
 991
 992     # close should still be here
 993     [ -d /proc/$close_pid ] || return 2
 994     replay_barrier_nodf mds
 995     fail mds
 996     wait $close_pid || return 3
 997
 998     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
 999     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1000     rm -rf $DIR/${tdir}-*
1001 }
1002 run_test 53a "|X| close request while two MDC requests in flight"
1003
1004 test_53b() {
1005     mkdir -p $DIR/$tdir-1
1006     mkdir -p $DIR/$tdir-2
1007     multiop $DIR/$tdir-1/f O_c &
1008     close_pid=$!
1009
1010     #define OBD_FAIL_MDS_REINT_NET 0x107
1011     do_facet mds "lctl set_param fail_loc=0x80000107"
1012     mcreate $DIR/${tdir}-2/f &
1013     open_pid=$!
1014     sleep 1
1015
1016     do_facet mds "lctl set_param fail_loc=0"
1017     kill -USR1 $close_pid
1018     cancel_lru_locks MDC # force the close
1019     wait $close_pid || return 1
1020     # open should still be here
1021     [ -d /proc/$open_pid ] || return 2
1022
1023     replay_barrier_nodf mds
1024     fail mds
1025     wait $open_pid || return 3
1026
1027     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1028     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1029     rm -rf $DIR/${tdir}-*
1030 }
1031 run_test 53b "|X| open request while two MDC requests in flight"
1032
1033 test_53c() {
1034     mkdir -p $DIR/${tdir}-1
1035     mkdir -p $DIR/${tdir}-2
1036     multiop $DIR/${tdir}-1/f O_c &
1037     close_pid=$!
1038
1039     do_facet mds "lctl set_param fail_loc=0x80000107"
1040     mcreate $DIR/${tdir}-2/f &
1041     open_pid=$!
1042     sleep 1
1043
1044     do_facet mds "lctl set_param fail_loc=0x80000115"
1045     kill -USR1 $close_pid
1046     cancel_lru_locks MDC  # force the close
1047
1048     replay_barrier_nodf mds
1049     fail_nodf mds
1050     wait $open_pid || return 1
1051     sleep 2
1052     # close should be gone
1053     [ -d /proc/$close_pid ] && return 2
1054     do_facet mds "lctl set_param fail_loc=0"
1055
1056     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1057     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1058     rm -rf $DIR/${tdir}-*
1059 }
1060 run_test 53c "|X| open request and close request while two MDC requests in flight"
1061
1062 test_53d() {
1063     mkdir -p $DIR/${tdir}-1
1064     mkdir -p $DIR/${tdir}-2
1065     multiop $DIR/${tdir}-1/f O_c &
1066     close_pid=$!
1067     # give multiop a chance to open
1068     sleep 1
1069
1070     # define OBD_FAIL_MDS_CLOSE_NET_REP 0X138
1071     do_facet mds "lctl set_param fail_loc=0x8000013b"
1072     kill -USR1 $close_pid
1073     cancel_lru_locks MDC  # force the close
1074     do_facet mds "lctl set_param fail_loc=0"
1075     mcreate $DIR/${tdir}-2/f || return 1
1076
1077     # close should still be here
1078     [ -d /proc/$close_pid ] || return 2
1079     replay_barrier_nodf mds
1080     fail mds
1081     wait $close_pid || return 3
1082
1083     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1084     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1085     rm -rf $DIR/${tdir}-*
1086 }
1087 run_test 53d "|X| close reply while two MDC requests in flight"
1088
1089 test_53e() {
1090     mkdir -p $DIR/$tdir-1
1091     mkdir -p $DIR/$tdir-2
1092     multiop $DIR/$tdir-1/f O_c &
1093     close_pid=$!
1094
1095     #define OBD_FAIL_MDS_REINT_NET_REP       0x119
1096     do_facet mds "lctl set_param fail_loc=0x80000119"
1097     mcreate $DIR/${tdir}-2/f &
1098     open_pid=$!
1099     sleep 1
1100
1101     do_facet mds "lctl set_param fail_loc=0"
1102     kill -USR1 $close_pid
1103     cancel_lru_locks MDC  # force the close
1104     wait $close_pid || return 1
1105     # open should still be here
1106     [ -d /proc/$open_pid ] || return 2
1107
1108     replay_barrier_nodf mds
1109     fail mds
1110     wait $open_pid || return 3
1111
1112     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1113     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1114     rm -rf $DIR/${tdir}-*
1115 }
1116 run_test 53e "|X| open reply while two MDC requests in flight"
1117
1118 test_53f() {
1119         mkdir -p $DIR/${tdir}-1
1120         mkdir -p $DIR/${tdir}-2
1121         multiop $DIR/${tdir}-1/f O_c &
1122         close_pid=$!
1123
1124         do_facet mds "lctl set_param fail_loc=0x80000119"
1125         mcreate $DIR/${tdir}-2/f &
1126         open_pid=$!
1127         sleep 1
1128
1129         do_facet mds "lctl set_param fail_loc=0x8000013b"
1130         kill -USR1 $close_pid
1131         cancel_lru_locks MDC
1132
1133         replay_barrier_nodf mds
1134         fail_nodf mds
1135         wait $open_pid || return 1
1136         sleep 2
1137         #close should be gone
1138         [ -d /proc/$close_pid ] && return 2
1139         do_facet mds "lctl set_param fail_loc=0"
1140
1141         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1142         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1143         rm -rf $DIR/${tdir}-*
1144 }
1145 run_test 53f "|X| open reply and close reply while two MDC requests in flight"
1146
1147 test_53g() {
1148         mkdir -p $DIR/${tdir}-1
1149         mkdir -p $DIR/${tdir}-2
1150         multiop $DIR/${tdir}-1/f O_c &
1151         close_pid=$!
1152
1153         do_facet mds "lctl set_param fail_loc=0x80000119"
1154         mcreate $DIR/${tdir}-2/f &
1155         open_pid=$!
1156         sleep 1
1157
1158         do_facet mds "lctl set_param fail_loc=0x80000115"
1159         kill -USR1 $close_pid
1160         cancel_lru_locks MDC # force the close
1161
1162         do_facet mds "lctl set_param fail_loc=0"
1163         replay_barrier_nodf mds
1164         fail_nodf mds
1165         wait $open_pid || return 1
1166         sleep 2
1167         # close should be gone
1168         [ -d /proc/$close_pid ] && return 2
1169
1170         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1171         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1172         rm -rf $DIR/${tdir}-*
1173 }
1174 run_test 53g "|X| drop open reply and close request while close and open are both in flight"
1175
1176 test_53h() {
1177     mkdir -p $DIR/${tdir}-1
1178     mkdir -p $DIR/${tdir}-2
1179     multiop $DIR/${tdir}-1/f O_c &
1180     close_pid=$!
1181
1182     do_facet mds "lctl set_param fail_loc=0x80000107"
1183     mcreate $DIR/${tdir}-2/f &
1184     open_pid=$!
1185     sleep 1
1186
1187     do_facet mds "lctl set_param fail_loc=0x8000013b"
1188     kill -USR1 $close_pid
1189     cancel_lru_locks MDC  # force the close
1190     sleep 1
1191
1192     replay_barrier_nodf mds
1193     fail_nodf mds
1194     wait $open_pid || return 1
1195     sleep 2
1196     # close should be gone
1197     [ -d /proc/$close_pid ] && return 2
1198     do_facet mds "lctl set_param fail_loc=0"
1199
1200     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1201     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1202     rm -rf $DIR/${tdir}-*
1203 }
1204 run_test 53h "|X| open request and close reply while two MDC requests in flight"
1205
1206 #b3761 ASSERTION(hash != 0) failed
1207 test_55() {
1208 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1209     do_facet mds "lctl set_param fail_loc=0x8000012b"
1210     touch $DIR/$tfile &
1211     # give touch a chance to run
1212     sleep 5
1213     do_facet mds "lctl set_param fail_loc=0x0"
1214     rm $DIR/$tfile
1215     return 0
1216 }
1217 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1218
1219 #b3440 ASSERTION(rec->ur_fid2->id) failed
1220 test_56() {
1221     ln -s foo $DIR/$tfile
1222     replay_barrier mds
1223     #drop_reply "cat $DIR/$tfile"
1224     fail mds
1225     sleep 10
1226 }
1227 run_test 56 "don't replay a symlink open request (3440)"
1228
1229 #recovery one mds-ost setattr from llog
1230 test_57() {
1231 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1232     do_facet mds "lctl set_param fail_loc=0x8000012c"
1233     touch $DIR/$tfile
1234     replay_barrier mds
1235     fail mds
1236     sleep 1
1237     $CHECKSTAT -t file $DIR/$tfile || return 1
1238     do_facet mds "lctl set_param fail_loc=0x0"
1239     rm $DIR/$tfile
1240 }
1241 run_test 57 "test recovery from llog for setattr op"
1242
1243 #recovery many mds-ost setattr from llog
1244 test_58() {
1245 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1246     do_facet mds "lctl set_param fail_loc=0x8000012c"
1247     createmany -o $DIR/$tdir/$tfile-%d 2500
1248     replay_barrier mds
1249     fail mds
1250     sleep 2
1251     $CHECKSTAT -t file $DIR/$tdir/$tfile-* >/dev/null || return 1
1252     do_facet mds "lctl set_param fail_loc=0x0"
1253     unlinkmany $DIR/$tdir/$tfile-%d 2500
1254     rmdir $DIR/$tdir
1255 }
1256 run_test 58 "test recovery from llog for setattr op (test llog_gen_rec)"
1257
1258 # log_commit_thread vs filter_destroy race used to lead to import use after free
1259 # bug 11658
1260 test_59() {
1261     createmany -o $DIR/$tdir/$tfile-%d 200
1262     sync
1263     unlinkmany $DIR/$tdir/$tfile-%d 200
1264 #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1265     do_facet ost1 "lctl set_param fail_loc=0x507"
1266     fail ost1
1267     fail mds
1268     do_facet ost1 "lctl set_param fail_loc=0x0"
1269     sleep 20
1270     rmdir $DIR/$tdir
1271 }
1272 run_test 59 "test log_commit_thread vs filter_destroy race"
1273
1274 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1275 # bug 12086: should no oops and No ctxt error for this test
1276 test_60() {
1277     createmany -o $DIR/$tdir/$tfile-%d 200
1278     replay_barrier mds
1279     unlinkmany $DIR/$tdir/$tfile-%d 0 100
1280     fail mds
1281     unlinkmany $DIR/$tdir/$tfile-%d 100 100
1282     local no_ctxt=`dmesg | grep "No ctxt"`
1283     [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery"
1284 }
1285 run_test 60 "test llog post recovery init vs llog unlink"
1286
1287 #test race  llog recovery thread vs llog cleanup
1288 test_61a() {
1289     createmany -o $DIR/$tdir/$tfile-%d 800
1290     replay_barrier ost1
1291 #   OBD_FAIL_OST_LLOG_RECOVERY_TIMEOUT 0x221
1292     unlinkmany $DIR/$tdir/$tfile-%d 800
1293     do_facet ost "lctl set_param fail_loc=0x80000221"
1294     facet_failover ost1
1295     sleep 10
1296     fail ost1
1297     sleep 30
1298     do_facet ost "lctl set_param fail_loc=0x0"
1299     $CHECKSTAT -t file $DIR/$tdir/$tfile-* && return 1
1300     rmdir $DIR/$tdir
1301 }
1302 run_test 61a "test race llog recovery vs llog cleanup"
1303
1304 #test race  mds llog sync vs llog cleanup
1305 test_61b() {
1306 #   OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT 0x13a
1307     do_facet mds "lctl set_param fail_loc=0x8000013a"
1308     facet_failover mds
1309     sleep 10
1310     fail mds
1311     do_facet client dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 || return 1
1312 }
1313 run_test 61b "test race mds llog sync vs llog cleanup"
1314
1315 #test race  cancel cookie cb vs llog cleanup
1316 test_61c() {
1317 #   OBD_FAIL_OST_CANCEL_COOKIE_TIMEOUT 0x222
1318     touch $DIR/$tfile
1319     do_facet ost "lctl set_param fail_loc=0x80000222"
1320     rm $DIR/$tfile
1321     sleep 10
1322     fail ost1
1323 }
1324 run_test 61c "test race mds llog sync vs llog cleanup"
1325
1326 test_62() { # Bug 15756 - don't mis-drop resent replay
1327     replay_barrier mds
1328     createmany -o $DIR/$tdir/$tfile- 25
1329 #define OBD_FAIL_TGT_REPLAY_DROP         0x707
1330     do_facet mds "lctl set_param fail_loc=0x80000707"
1331     facet_failover mds
1332     df $MOUNT || return 1
1333     do_facet mds "lctl set_param fail_loc=0"
1334     unlinkmany $DIR/$tdir/$tfile- 25 || return 2
1335     return 0
1336 }
1337 run_test 62 "don't mis-drop resent replay"
1338
1339 #Adaptive Timeouts (bug 3055)
1340 AT_MAX_SET=0
1341
1342 at_start()
1343 {
1344     if ! at_is_valid; then
1345         skip "AT env is invalid"
1346         return 1
1347     fi
1348
1349     if ! at_is_enabled; then
1350         echo "AT is disabled, enable it by force temporarily"
1351         at_max_set 600 mds ost client
1352         AT_MAX_SET=1
1353     fi
1354
1355     if [ -z "$ATOLDBASE" ]; then
1356         local at_history=$(do_facet mds "find /sys/ -name at_history")
1357         [ -z "$at_history" ] && skip "missing /sys/.../at_history " && return 1
1358         ATOLDBASE=$(do_facet mds "cat $at_history")
1359         # speed up the timebase so we can check decreasing AT
1360         do_facet mds "echo 8 >> $at_history"
1361         do_facet ost1 "echo 8 >> $at_history"
1362     fi
1363 }
1364
1365 test_65a() #bug 3055
1366 {
1367     at_start || return 0
1368     $LCTL dk > /dev/null
1369     debugsave
1370     lctl set_param debug="+other"
1371     # slow down a request
1372     do_facet mds lctl set_param fail_val=30000
1373 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1374     do_facet mds lctl set_param fail_loc=0x8000050a
1375     createmany -o $DIR/$tfile 10 > /dev/null
1376     unlinkmany $DIR/$tfile 10 > /dev/null
1377     # check for log message
1378     $LCTL dk | grep "Early reply #" || error "No early reply"
1379     # client should show 30s estimates
1380     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1381     sleep 9
1382     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1383 }
1384 run_test 65a "AT: verify early replies"
1385
1386 test_65b() #bug 3055
1387 {
1388     at_start || return 0
1389     # turn on D_ADAPTTO
1390     debugsave
1391     lctl set_param debug="+other"
1392     $LCTL dk > /dev/null
1393     # slow down bulk i/o
1394     do_facet ost1 lctl set_param fail_val=30
1395 #define OBD_FAIL_OST_BRW_PAUSE_PACK      0x224
1396     do_facet ost1 lctl set_param fail_loc=0x224
1397
1398     rm -f $DIR/$tfile
1399     lfs setstripe $DIR/$tfile --index=0 --count=1
1400     # force some real bulk transfer
1401     multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
1402
1403     do_facet ost1 lctl set_param fail_loc=0
1404     # check for log message
1405     $LCTL dk | grep "Early reply #" || error "No early reply"
1406     debugrestore
1407     # client should show 30s estimates
1408     lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts | grep portal
1409 }
1410 run_test 65b "AT: verify early replies on packed reply / bulk"
1411
1412 test_66a() #bug 3055
1413 {
1414     at_start || return 0
1415     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1416     # adjust 5s at a time so no early reply is sent (within deadline)
1417     do_facet mds "lctl set_param fail_val=5000"
1418 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1419     do_facet mds "lctl set_param fail_loc=0x8000050a"
1420     createmany -o $DIR/$tfile 20 > /dev/null
1421     unlinkmany $DIR/$tfile 20 > /dev/null
1422     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1423     do_facet mds "lctl set_param fail_val=10000"
1424     do_facet mds "lctl set_param fail_loc=0x8000050a"
1425     createmany -o $DIR/$tfile 20 > /dev/null
1426     unlinkmany $DIR/$tfile 20 > /dev/null
1427     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1428     do_facet mds "lctl set_param fail_loc=0"
1429     sleep 9
1430     createmany -o $DIR/$tfile 20 > /dev/null
1431     unlinkmany $DIR/$tfile 20 > /dev/null
1432     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal | grep "portal 12"
1433     CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $5}')
1434     WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $7}')
1435     echo "Current MDT timeout $CUR, worst $WORST"
1436     [ $CUR -lt $WORST ] || error "Current $CUR should be less than worst $WORST"
1437 }
1438 run_test 66a "AT: verify MDT service time adjusts with no early replies"
1439
1440 test_66b() #bug 3055
1441 {
1442     at_start || return 0
1443     ORIG=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $4}')
1444     lctl set_param fail_val=$(($ORIG + 5))
1445 #define OBD_FAIL_PTLRPC_PAUSE_REP      0x50c
1446     lctl set_param fail_loc=0x50c
1447     ls $DIR/$tfile > /dev/null 2>&1
1448     lctl set_param fail_loc=0
1449     CUR=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $4}')
1450     WORST=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $6}')
1451     echo "network timeout orig $ORIG, cur $CUR, worst $WORST"
1452     [ $WORST -gt $ORIG ] || error "Worst $WORST should be worse than orig $ORIG"
1453 }
1454 run_test 66b "AT: verify net latency adjusts"
1455
1456 test_67a() #bug 3055
1457 {
1458     at_start || return 0
1459     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1460     # sleeping threads may drive values above this
1461     do_facet ost1 "lctl set_param fail_val=400"
1462 #define OBD_FAIL_PTLRPC_PAUSE_REQ    0x50a
1463     do_facet ost1 "lctl set_param fail_loc=0x50a"
1464     createmany -o $DIR/$tfile 20 > /dev/null
1465     unlinkmany $DIR/$tfile 20 > /dev/null
1466     do_facet ost1 "lctl set_param fail_loc=0"
1467     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1468     ATTEMPTS=$(($CONN2 - $CONN1))
1469     echo "$ATTEMPTS osc reconnect attemps on gradual slow"
1470     [ $ATTEMPTS -gt 0 ] && error_ignore 13721 "AT should have prevented reconnect"
1471     return 0
1472 }
1473 run_test 67a "AT: verify slow request processing doesn't induce reconnects"
1474
1475 test_67b() #bug 3055
1476 {
1477     at_start || return 0
1478     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1479 #define OBD_FAIL_OST_PAUSE_CREATE        0x223
1480     do_facet ost1 "lctl set_param fail_val=20000"
1481     do_facet ost1 "lctl set_param fail_loc=0x80000223"
1482     cp /etc/profile $DIR/$tfile || error "cp failed"
1483     client_reconnect
1484     lctl get_param -n ost.OSS.ost_create.timeouts
1485     log "phase 2"
1486     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1487     ATTEMPTS=$(($CONN2 - $CONN1))
1488     echo "$ATTEMPTS osc reconnect attemps on instant slow"
1489     # do it again; should not timeout
1490     do_facet ost1 "lctl set_param fail_loc=0x80000223"
1491     cp /etc/profile $DIR/$tfile || error "cp failed"
1492     do_facet ost1 "lctl set_param fail_loc=0"
1493     client_reconnect
1494     lctl get_param -n ost.OSS.ost_create.timeouts
1495     CONN3=$(`lctl get_param -n osc.*.stats` | awk '/_connect/ {total+=$2} END {print total}')
1496     ATTEMPTS=$(($CONN3 - $CONN2))
1497     echo "$ATTEMPTS osc reconnect attemps on 2nd slow"
1498     [ $ATTEMPTS -gt 0 ] && error "AT should have prevented reconnect"
1499     return 0
1500 }
1501 run_test 67b "AT: verify instant slowdown doesn't induce reconnects"
1502
1503 test_68 () #bug 13813
1504 {
1505     at_start || return 0
1506     local ldlm_enqueue_min=$(find /sys -name ldlm_enqueue_min)
1507     [ -z "$ldlm_enqueue_min" ] && skip "missing /sys/.../ldlm_enqueue_min" && return 0
1508     local ENQ_MIN=$(cat $ldlm_enqueue_min)
1509     echo $TIMEOUT >> $ldlm_enqueue_min
1510     rm -f $DIR/${tfile}_[1-2]
1511     lfs setstripe $DIR/$tfile --index=0 --count=1
1512 #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
1513     lctl set_param fail_val=$(($TIMEOUT - 1))
1514     lctl set_param fail_loc=0x80000312
1515     cp /etc/profile $DIR/${tfile}_1 || error "1st cp failed $?"
1516     lctl set_param fail_val=$((TIMEOUT * 3 / 2))
1517     lctl set_param fail_loc=0x80000312
1518     cp /etc/profile $DIR/${tfile}_2 || error "2nd cp failed $?"
1519     lctl set_param fail_loc=0
1520     echo $ENQ_MIN >> $ldlm_enqueue_min
1521     return 0
1522 }
1523 run_test 68 "AT: verify slowing locks"
1524
1525 if [ -n "$ATOLDBASE" ]; then
1526     at_history=$(do_facet mds "find /sys/ -name at_history")
1527     do_facet mds "echo $ATOLDBASE >> $at_history" || true
1528     do_facet ost1 "echo $ATOLDBASE >> $at_history" || true
1529 fi
1530
1531 if [ $AT_MAX_SET -ne 0 ]; then
1532     echo "restore AT status to be disabled"
1533     at_max_set 0 mds ost client
1534 fi
1535
1536 # end of AT tests includes above lines
1537
1538 # start multi-client tests
1539 test_70a () {
1540         [ -z "$CLIENTS" ] && \
1541                 { skip "Need two or more clients." && return; }
1542         [ $CLIENTCOUNT -lt 2 ] && \
1543                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
1544
1545         echo "mount clients $CLIENTS ..."
1546         zconf_mount_clients $CLIENTS $DIR
1547
1548         local clients=${CLIENTS//,/ }
1549         echo "Write/read files on $DIR ; clients $CLIENTS ... "
1550         for CLIENT in $clients; do
1551                 do_node $CLIENT dd bs=1M count=10 if=/dev/zero \
1552                         of=$DIR/${tfile}_${CLIENT} 2>/dev/null || \
1553                                 error "dd failed on $CLIENT"
1554         done
1555
1556         local prev_client=$(echo $clients | sed 's/^.* \(\w\+\)$/\1/')
1557         for C in ${CLIENTS//,/ }; do
1558                 do_node $prev_client dd if=$DIR/${tfile}_${C} of=/dev/null 2>/dev/null || \
1559                         error "dd if=$DIR/${tfile}_${C} failed on $prev_client"
1560                 prev_client=$C
1561         done
1562
1563         ls $DIR
1564
1565         zconf_umount_clients $CLIENTS $DIR
1566 }
1567 run_test 70a "check multi client t-f"
1568
1569 test_70b () {
1570         [ -z "$CLIENTS" ] && \
1571                 { skip "Need two or more clients." && return; }
1572         [ $CLIENTCOUNT -lt 2 ] && \
1573                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
1574
1575         zconf_mount_clients $CLIENTS $DIR
1576
1577         local duration="-t 60"
1578         local cmd="rundbench 1 $duration "
1579         local PID=""
1580         for CLIENT in ${CLIENTS//,/ }; do
1581                 $PDSH $CLIENT "set -x; PATH=:$PATH:$LUSTRE/utils:$LUSTRE/tests/:${DBENCH_LIB} DBENCH_LIB=${DBENCH_LIB} $cmd" &
1582                 PID=$!
1583                 echo $PID >pid.$CLIENT
1584                 echo "Started load PID=`cat pid.$CLIENT`"
1585         done
1586
1587         replay_barrier mds
1588         sleep 3 # give clients a time to do operations
1589
1590         log "$TESTNAME fail mds 1"
1591         fail mds
1592
1593 # wait for client to reconnect to MDS
1594         sleep $TIMEOUT
1595
1596         for CLIENT in ${CLIENTS//,/ }; do
1597                 PID=`cat pid.$CLIENT`
1598                 wait $PID
1599                 rc=$?
1600                 echo "load on ${CLIENT} returned $rc"
1601         done
1602
1603         zconf_umount_clients $CLIENTS $DIR
1604 }
1605 run_test 70b "mds recovery; $CLIENTCOUNT clients"
1606 # end multi-client tests
1607
1608 equals_msg `basename $0`: test complete, cleaning up
1609 check_and_cleanup_lustre
1610 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG || true