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