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 #define OBD_FAIL_MDS_REINT_NET           0x107
1072     do_facet mds "lctl set_param fail_loc=0x80000107"
1073     mcreate $DIR/${tdir}-2/f &
1074     open_pid=$!
1075     sleep 1
1076
1077 #define OBD_FAIL_MDS_CLOSE_NET           0x115
1078     do_facet mds "lctl set_param fail_loc=0x80000115"
1079     kill -USR1 $close_pid
1080     cancel_lru_locks mdc  # force the close
1081
1082     replay_barrier_nodf mds
1083     fail_nodf mds
1084     wait $open_pid || return 1
1085     sleep 2
1086     # close should be gone
1087     [ -d /proc/$close_pid ] && return 2
1088     do_facet mds "lctl set_param fail_loc=0"
1089
1090     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1091     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1092     rm -rf $DIR/${tdir}-*
1093 }
1094 run_test 53c "|X| open request and close request while two MDC requests in flight"
1095
1096 test_53d() {
1097     mkdir -p $DIR/${tdir}-1
1098     mkdir -p $DIR/${tdir}-2
1099     multiop $DIR/${tdir}-1/f O_c &
1100     close_pid=$!
1101     # give multiop a chance to open
1102     sleep 1
1103
1104 #define OBD_FAIL_MDS_CLOSE_NET_REP       0x13b
1105     do_facet mds "lctl set_param fail_loc=0x8000013b"
1106     kill -USR1 $close_pid
1107     cancel_lru_locks mdc  # force the close
1108     do_facet mds "lctl set_param fail_loc=0"
1109     mcreate $DIR/${tdir}-2/f || return 1
1110
1111     # close should still be here
1112     [ -d /proc/$close_pid ] || return 2
1113     replay_barrier_nodf mds
1114     fail mds
1115     wait $close_pid || return 3
1116
1117     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1118     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1119     rm -rf $DIR/${tdir}-*
1120 }
1121 run_test 53d "|X| close reply while two MDC requests in flight"
1122
1123 test_53e() {
1124     mkdir -p $DIR/$tdir-1
1125     mkdir -p $DIR/$tdir-2
1126     multiop $DIR/$tdir-1/f O_c &
1127     close_pid=$!
1128
1129     #define OBD_FAIL_MDS_REINT_NET_REP       0x119
1130     do_facet mds "lctl set_param fail_loc=0x80000119"
1131     mcreate $DIR/${tdir}-2/f &
1132     open_pid=$!
1133     sleep 1
1134
1135     do_facet mds "lctl set_param fail_loc=0"
1136     kill -USR1 $close_pid
1137     cancel_lru_locks mdc  # force the close
1138     wait $close_pid || return 1
1139     # open should still be here
1140     [ -d /proc/$open_pid ] || return 2
1141
1142     replay_barrier_nodf mds
1143     fail mds
1144     wait $open_pid || return 3
1145
1146     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1147     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1148     rm -rf $DIR/${tdir}-*
1149 }
1150 run_test 53e "|X| open reply while two MDC requests in flight"
1151
1152 test_53f() {
1153         mkdir -p $DIR/${tdir}-1
1154         mkdir -p $DIR/${tdir}-2
1155         multiop $DIR/${tdir}-1/f O_c &
1156         close_pid=$!
1157
1158 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
1159         do_facet mds "lctl set_param fail_loc=0x80000119"
1160         mcreate $DIR/${tdir}-2/f &
1161         open_pid=$!
1162         sleep 1
1163
1164 #define OBD_FAIL_MDS_CLOSE_NET_REP       0x13b
1165         do_facet mds "lctl set_param fail_loc=0x8000013b"
1166         kill -USR1 $close_pid
1167         cancel_lru_locks mdc
1168
1169         replay_barrier_nodf mds
1170         fail_nodf mds
1171         wait $open_pid || return 1
1172         sleep 2
1173         #close should be gone
1174         [ -d /proc/$close_pid ] && return 2
1175         do_facet mds "lctl set_param fail_loc=0"
1176
1177         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1178         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1179         rm -rf $DIR/${tdir}-*
1180 }
1181 run_test 53f "|X| open reply and close reply while two MDC requests in flight"
1182
1183 test_53g() {
1184         mkdir -p $DIR/${tdir}-1
1185         mkdir -p $DIR/${tdir}-2
1186         multiop $DIR/${tdir}-1/f O_c &
1187         close_pid=$!
1188
1189 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
1190         do_facet mds "lctl set_param fail_loc=0x80000119"
1191         mcreate $DIR/${tdir}-2/f &
1192         open_pid=$!
1193         sleep 1
1194
1195 #define OBD_FAIL_MDS_CLOSE_NET           0x115
1196         do_facet mds "lctl set_param fail_loc=0x80000115"
1197         kill -USR1 $close_pid
1198         cancel_lru_locks mdc # force the close
1199
1200         do_facet mds "lctl set_param fail_loc=0"
1201         replay_barrier_nodf mds
1202         fail_nodf mds
1203         wait $open_pid || return 1
1204         sleep 2
1205         # close should be gone
1206         [ -d /proc/$close_pid ] && return 2
1207
1208         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1209         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1210         rm -rf $DIR/${tdir}-*
1211 }
1212 run_test 53g "|X| drop open reply and close request while close and open are both in flight"
1213
1214 test_53h() {
1215     mkdir -p $DIR/${tdir}-1
1216     mkdir -p $DIR/${tdir}-2
1217     multiop $DIR/${tdir}-1/f O_c &
1218     close_pid=$!
1219
1220 #define OBD_FAIL_MDS_REINT_NET           0x107
1221     do_facet mds "lctl set_param fail_loc=0x80000107"
1222     mcreate $DIR/${tdir}-2/f &
1223     open_pid=$!
1224     sleep 1
1225
1226 #define OBD_FAIL_MDS_CLOSE_NET_REP       0x13b
1227     do_facet mds "lctl set_param fail_loc=0x8000013b"
1228     kill -USR1 $close_pid
1229     cancel_lru_locks mdc  # force the close
1230     sleep 1
1231
1232     replay_barrier_nodf mds
1233     fail_nodf mds
1234     wait $open_pid || return 1
1235     sleep 2
1236     # close should be gone
1237     [ -d /proc/$close_pid ] && return 2
1238     do_facet mds "lctl set_param fail_loc=0"
1239
1240     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1241     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1242     rm -rf $DIR/${tdir}-*
1243 }
1244 run_test 53h "|X| open request and close reply while two MDC requests in flight"
1245
1246 #b3761 ASSERTION(hash != 0) failed
1247 test_55() {
1248 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1249     do_facet mds "lctl set_param fail_loc=0x8000012b"
1250     touch $DIR/$tfile &
1251     # give touch a chance to run
1252     sleep 5
1253     do_facet mds "lctl set_param fail_loc=0x0"
1254     rm $DIR/$tfile
1255     return 0
1256 }
1257 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1258
1259 #b3440 ASSERTION(rec->ur_fid2->id) failed
1260 test_56() {
1261     ln -s foo $DIR/$tfile
1262     replay_barrier mds
1263     #drop_reply "cat $DIR/$tfile"
1264     fail mds
1265     sleep 10
1266 }
1267 run_test 56 "don't replay a symlink open request (3440)"
1268
1269 #recovery one mds-ost setattr from llog
1270 test_57() {
1271 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1272     do_facet mds "lctl set_param fail_loc=0x8000012c"
1273     touch $DIR/$tfile
1274     replay_barrier mds
1275     fail mds
1276     sleep 1
1277     $CHECKSTAT -t file $DIR/$tfile || return 1
1278     do_facet mds "lctl set_param fail_loc=0x0"
1279     rm $DIR/$tfile
1280 }
1281 run_test 57 "test recovery from llog for setattr op"
1282
1283 #recovery many mds-ost setattr from llog
1284 test_58a() {
1285     mkdir -p $DIR/$tdir
1286 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1287     do_facet mds "lctl set_param fail_loc=0x8000012c"
1288     createmany -o $DIR/$tdir/$tfile-%d 2500
1289     replay_barrier mds
1290     fail mds
1291     sleep 2
1292     $CHECKSTAT -t file $DIR/$tdir/$tfile-* >/dev/null || return 1
1293     do_facet mds "lctl set_param fail_loc=0x0"
1294     unlinkmany $DIR/$tdir/$tfile-%d 2500
1295     rmdir $DIR/$tdir
1296 }
1297 run_test 58a "test recovery from llog for setattr op (test llog_gen_rec)"
1298
1299 test_58b() {
1300     mount_client $MOUNT2
1301     mkdir -p $DIR/$tdir
1302     touch $DIR/$tdir/$tfile
1303     replay_barrier mds
1304     setfattr -n trusted.foo -v bar $DIR/$tdir/$tfile
1305     fail mds
1306     VAL=`getfattr --absolute-names --only-value -n trusted.foo $MOUNT2/$tdir/$tfile`
1307     [ x$VAL = x"bar" ] || return 1
1308     rm -f $DIR/$tdir/$tfile
1309     rmdir $DIR/$tdir
1310     zconf_umount `hostname` $MOUNT2
1311 }
1312 run_test 58b "test replay of setxattr op"
1313
1314 test_58c() { # bug 16570
1315         mount_client $MOUNT2
1316         mkdir -p $DIR/$tdir
1317         touch $DIR/$tdir/$tfile
1318         drop_request "setfattr -n trusted.foo -v bar $DIR/$tdir/$tfile" || \
1319                 return 1
1320         VAL=`getfattr --absolute-names --only-value -n trusted.foo $MOUNT2/$tdir/$tfile`
1321         [ x$VAL = x"bar" ] || return 2
1322         drop_reint_reply "setfattr -n trusted.foo1 -v bar1 $DIR/$tdir/$tfile" || \
1323                 return 3
1324         VAL=`getfattr --absolute-names --only-value -n trusted.foo1 $MOUNT2/$tdir/$tfile`
1325         [ x$VAL = x"bar1" ] || return 4
1326         rm -f $DIR/$tdir/$tfile
1327         rmdir $DIR/$tdir
1328         zconf_umount `hostname` $MOUNT2
1329 }
1330 run_test 58c "resend/reconstruct setxattr op"
1331
1332 # log_commit_thread vs filter_destroy race used to lead to import use after free
1333 # bug 11658
1334 test_59() {
1335     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1336
1337     mkdir -p $DIR/$tdir
1338     createmany -o $DIR/$tdir/$tfile-%d 200
1339     sync
1340     unlinkmany $DIR/$tdir/$tfile-%d 200
1341 #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1342     do_facet ost1 "lctl set_param fail_loc=0x507"
1343     fail ost1
1344     fail mds
1345     do_facet ost1 "lctl set_param fail_loc=0x0"
1346     sleep 20
1347     rmdir $DIR/$tdir
1348 }
1349 run_test 59 "test log_commit_thread vs filter_destroy race"
1350
1351 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1352 # bug 12086: should no oops and No ctxt error for this test
1353 test_60() {
1354     mkdir -p $DIR/$tdir
1355     createmany -o $DIR/$tdir/$tfile-%d 200
1356     replay_barrier mds
1357     unlinkmany $DIR/$tdir/$tfile-%d 0 100
1358     fail mds
1359     unlinkmany $DIR/$tdir/$tfile-%d 100 100
1360     local no_ctxt=`dmesg | grep "No ctxt"`
1361     [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery"
1362 }
1363 run_test 60 "test llog post recovery init vs llog unlink"
1364
1365 #test race  llog recovery thread vs llog cleanup
1366 test_61a() {
1367     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1368
1369     mkdir -p $DIR/$tdir
1370     createmany -o $DIR/$tdir/$tfile-%d 800
1371     replay_barrier ost1
1372 #   OBD_FAIL_OST_LLOG_RECOVERY_TIMEOUT 0x221
1373     unlinkmany $DIR/$tdir/$tfile-%d 800
1374     do_facet ost "lctl set_param fail_loc=0x80000221"
1375     facet_failover ost1
1376     sleep 10
1377     fail ost1
1378     sleep 30
1379     do_facet ost "lctl set_param fail_loc=0x0"
1380     $CHECKSTAT -t file $DIR/$tdir/$tfile-* && return 1
1381     rmdir $DIR/$tdir
1382 }
1383 run_test 61a "test race llog recovery vs llog cleanup"
1384
1385 #test race  mds llog sync vs llog cleanup
1386 test_61b() {
1387 #   OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT 0x13a
1388     do_facet mds "lctl set_param fail_loc=0x8000013a"
1389     facet_failover mds
1390     sleep 10
1391     fail mds
1392     do_facet client dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 || return 1
1393 }
1394 run_test 61b "test race mds llog sync vs llog cleanup"
1395
1396 #test race  cancel cookie cb vs llog cleanup
1397 test_61c() {
1398     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1399
1400 #   OBD_FAIL_OST_CANCEL_COOKIE_TIMEOUT 0x222
1401     touch $DIR/$tfile
1402     do_facet ost "lctl set_param fail_loc=0x80000222"
1403     rm $DIR/$tfile
1404     sleep 10
1405     fail ost1
1406 }
1407 run_test 61c "test race mds llog sync vs llog cleanup"
1408
1409 test_61d() { # bug 16002
1410 #define OBD_FAIL_OBD_LLOG_SETUP        0x605
1411     stop mds
1412     do_facet mds "lctl set_param fail_loc=0x80000605"
1413     start mds $MDSDEV $MDS_MOUNT_OPTS && error "mds start should have failed"
1414     do_facet mds "lctl set_param fail_loc=0"
1415     start mds $MDSDEV $MDS_MOUNT_OPTS || error "cannot restart mds"
1416 }
1417 run_test 61d "error in llog_setup should cleanup the llog context correctly"
1418
1419 test_62() { # Bug 15756 - don't mis-drop resent replay
1420     mkdir -p $DIR/$tdir
1421     replay_barrier mds
1422     createmany -o $DIR/$tdir/$tfile- 25
1423 #define OBD_FAIL_TGT_REPLAY_DROP         0x707
1424     do_facet mds "lctl set_param fail_loc=0x80000707"
1425     facet_failover mds
1426     df $MOUNT || return 1
1427     do_facet mds "lctl set_param fail_loc=0"
1428     unlinkmany $DIR/$tdir/$tfile- 25 || return 2
1429     return 0
1430 }
1431 run_test 62 "don't mis-drop resent replay"
1432
1433 #Adaptive Timeouts (bug 3055)
1434 AT_MAX_SET=0
1435 # Suppose that all osts have the same at_max
1436 for facet in mds client ost; do
1437     eval AT_MAX_SAVE_${facet}=$(at_max_get $facet)
1438 done
1439
1440 at_start()
1441 {
1442     local at_max_new=600
1443     if ! at_is_valid; then
1444         skip "AT env is invalid"
1445         return 1
1446     fi
1447
1448     local at_max
1449
1450     for facet in mds client ost; do
1451         at_max=$(at_max_get $facet)
1452         if [ $at_max -ne $at_max_new ]; then
1453             echo "AT value on $facet is $at_max, set it by force temporarily to $at_max_new"
1454             at_max_set $at_max_new $facet
1455             AT_MAX_SET=1
1456         fi
1457     done
1458
1459     if [ -z "$ATOLDBASE" ]; then
1460         local at_history=$(do_facet mds "find /sys/ -name at_history")
1461         [ -z "$at_history" ] && skip "missing /sys/.../at_history " && return 1
1462         ATOLDBASE=$(do_facet mds "cat $at_history")
1463         # speed up the timebase so we can check decreasing AT
1464         do_facet mds "echo 8 >> $at_history"
1465         do_facet ost1 "echo 8 >> $at_history"
1466
1467         # sleep for a while to cool down, should be > 8s and also allow
1468         # at least one ping to be sent. simply use TIMEOUT to be safe.
1469         sleep $TIMEOUT
1470     fi
1471 }
1472
1473 test_65a() #bug 3055
1474 {
1475     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1476
1477     at_start || return 0
1478     $LCTL dk > /dev/null
1479     debugsave
1480     lctl set_param debug="+other"
1481     # Slow down a request to the current service time, this is critical
1482     # because previous tests may have caused this value to increase.
1483     REQ_DELAY=`lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts |
1484                awk '/portal 12/ {print $5}'`
1485     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1486
1487     do_facet mds lctl set_param fail_val=$((${REQ_DELAY} * 1000))
1488 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1489     do_facet mds lctl set_param fail_loc=0x8000050a
1490     createmany -o $DIR/$tfile 10 > /dev/null
1491     unlinkmany $DIR/$tfile 10 > /dev/null
1492     # check for log message
1493     $LCTL dk | grep "Early reply #" || error "No early reply"
1494     # client should show REQ_DELAY estimates
1495     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1496     sleep 9
1497     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal
1498 }
1499 run_test 65a "AT: verify early replies"
1500
1501 test_65b() #bug 3055
1502 {
1503     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1504
1505     at_start || return 0
1506     # turn on D_ADAPTTO
1507     debugsave
1508     lctl set_param debug="+other"
1509     $LCTL dk > /dev/null
1510     # Slow down a request to the current service time, this is critical
1511     # because previous tests may have caused this value to increase.
1512     REQ_DELAY=`lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts |
1513                awk '/portal 6/ {print $5}'`
1514     REQ_DELAY=$((${REQ_DELAY} + ${REQ_DELAY} / 4 + 5))
1515
1516     do_facet ost1 lctl set_param fail_val=${REQ_DELAY}
1517 #define OBD_FAIL_OST_BRW_PAUSE_PACK      0x224
1518     do_facet ost1 lctl set_param fail_loc=0x224
1519
1520     rm -f $DIR/$tfile
1521     lfs setstripe $DIR/$tfile --index=0 --count=1
1522     # force some real bulk transfer
1523     multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
1524
1525     do_facet ost1 lctl set_param fail_loc=0
1526     # check for log message
1527     $LCTL dk | grep "Early reply #" || error "No early reply"
1528     debugrestore
1529     # client should show REQ_DELAY estimates
1530     lctl get_param -n osc.${FSNAME}-OST0000-osc-*.timeouts | grep portal
1531 }
1532 run_test 65b "AT: verify early replies on packed reply / bulk"
1533
1534 test_66a() #bug 3055
1535 {
1536     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1537
1538     at_start || return 0
1539     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1540     # adjust 5s at a time so no early reply is sent (within deadline)
1541     do_facet mds "lctl set_param fail_val=5000"
1542 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1543     do_facet mds "lctl set_param fail_loc=0x8000050a"
1544     createmany -o $DIR/$tfile 20 > /dev/null
1545     unlinkmany $DIR/$tfile 20 > /dev/null
1546     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1547     do_facet mds "lctl set_param fail_val=10000"
1548     do_facet mds "lctl set_param fail_loc=0x8000050a"
1549     createmany -o $DIR/$tfile 20 > /dev/null
1550     unlinkmany $DIR/$tfile 20 > /dev/null
1551     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep "portal 12"
1552     do_facet mds "lctl set_param fail_loc=0"
1553     sleep 9
1554     createmany -o $DIR/$tfile 20 > /dev/null
1555     unlinkmany $DIR/$tfile 20 > /dev/null
1556     lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | grep portal | grep "portal 12"
1557     CUR=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $5}')
1558     WORST=$(lctl get_param -n mdc.${FSNAME}-MDT0000-mdc-*.timeouts | awk '/portal 12/ {print $7}')
1559     echo "Current MDT timeout $CUR, worst $WORST"
1560     [ $CUR -lt $WORST ] || error "Current $CUR should be less than worst $WORST"
1561 }
1562 run_test 66a "AT: verify MDT service time adjusts with no early replies"
1563
1564 test_66b() #bug 3055
1565 {
1566     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1567
1568     at_start || return 0
1569     ORIG=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $4}')
1570     lctl set_param fail_val=$(($ORIG + 5))
1571 #define OBD_FAIL_PTLRPC_PAUSE_REP      0x50c
1572     lctl set_param fail_loc=0x50c
1573     ls $DIR/$tfile > /dev/null 2>&1
1574     lctl set_param fail_loc=0
1575     CUR=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $4}')
1576     WORST=$(lctl get_param -n mdc.${FSNAME}-*.timeouts | awk '/network/ {print $6}')
1577     echo "network timeout orig $ORIG, cur $CUR, worst $WORST"
1578     [ $WORST -gt $ORIG ] || error "Worst $WORST should be worse than orig $ORIG"
1579 }
1580 run_test 66b "AT: verify net latency adjusts"
1581
1582 test_67a() #bug 3055
1583 {
1584     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1585
1586     at_start || return 0
1587     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1588     # sleeping threads may drive values above this
1589     do_facet ost1 "lctl set_param fail_val=400"
1590 #define OBD_FAIL_PTLRPC_PAUSE_REQ    0x50a
1591     do_facet ost1 "lctl set_param fail_loc=0x50a"
1592     createmany -o $DIR/$tfile 20 > /dev/null
1593     unlinkmany $DIR/$tfile 20 > /dev/null
1594     do_facet ost1 "lctl set_param fail_loc=0"
1595     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1596     ATTEMPTS=$(($CONN2 - $CONN1))
1597     echo "$ATTEMPTS osc reconnect attemps on gradual slow"
1598     [ $ATTEMPTS -gt 0 ] && error_ignore 13721 "AT should have prevented reconnect"
1599     return 0
1600 }
1601 run_test 67a "AT: verify slow request processing doesn't induce reconnects"
1602
1603 test_67b() #bug 3055
1604 {
1605     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1606
1607     at_start || return 0
1608     CONN1=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1609 #define OBD_FAIL_OST_PAUSE_CREATE        0x223
1610     do_facet ost1 "lctl set_param fail_val=20000"
1611     do_facet ost1 "lctl set_param fail_loc=0x80000223"
1612     cp /etc/profile $DIR/$tfile || error "cp failed"
1613     client_reconnect
1614     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1615     log "phase 2"
1616     CONN2=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1617     ATTEMPTS=$(($CONN2 - $CONN1))
1618     echo "$ATTEMPTS osc reconnect attemps on instant slow"
1619     # do it again; should not timeout
1620     do_facet ost1 "lctl set_param fail_loc=0x80000223"
1621     cp /etc/profile $DIR/$tfile || error "cp failed"
1622     do_facet ost1 "lctl set_param fail_loc=0"
1623     client_reconnect
1624     do_facet ost1 "lctl get_param -n ost.OSS.ost_create.timeouts"
1625     CONN3=$(lctl get_param -n osc.*.stats | awk '/_connect/ {total+=$2} END {print total}')
1626     ATTEMPTS=$(($CONN3 - $CONN2))
1627     echo "$ATTEMPTS osc reconnect attemps on 2nd slow"
1628     [ $ATTEMPTS -gt 0 ] && error "AT should have prevented reconnect"
1629     return 0
1630 }
1631 run_test 67b "AT: verify instant slowdown doesn't induce reconnects"
1632
1633 test_68 () #bug 13813
1634 {
1635     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1636
1637     at_start || return 0
1638     local ldlm_enqueue_min=$(find /sys -name ldlm_enqueue_min)
1639     [ -z "$ldlm_enqueue_min" ] && skip "missing /sys/.../ldlm_enqueue_min" && return 0
1640     local ENQ_MIN=$(cat $ldlm_enqueue_min)
1641     echo $TIMEOUT >> $ldlm_enqueue_min
1642     rm -f $DIR/${tfile}_[1-2]
1643     lfs setstripe $DIR/$tfile --index=0 --count=1
1644 #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
1645     lctl set_param fail_val=$(($TIMEOUT - 1))
1646     lctl set_param fail_loc=0x80000312
1647     cp /etc/profile $DIR/${tfile}_1 || error "1st cp failed $?"
1648     lctl set_param fail_val=$((TIMEOUT * 3 / 2))
1649     lctl set_param fail_loc=0x80000312
1650     cp /etc/profile $DIR/${tfile}_2 || error "2nd cp failed $?"
1651     lctl set_param fail_loc=0
1652     echo $ENQ_MIN >> $ldlm_enqueue_min
1653     return 0
1654 }
1655 run_test 68 "AT: verify slowing locks"
1656
1657 if [ -n "$ATOLDBASE" ]; then
1658     at_history=$(do_facet mds "find /sys/ -name at_history")
1659     do_facet mds "echo $ATOLDBASE >> $at_history" || true
1660     do_facet ost1 "echo $ATOLDBASE >> $at_history" || true
1661 fi
1662
1663 if [ $AT_MAX_SET -ne 0 ]; then
1664     for facet in mds client ost; do
1665         var=AT_MAX_SAVE_${facet}
1666         echo restore AT on $facet to saved value ${!var}
1667         at_max_set ${!var} $facet
1668         AT_NEW=$(at_max_get $facet)
1669         echo Restored AT value on $facet $AT_NEW
1670         [ $AT_NEW -ne ${!var} ] && \
1671             error "$facet : AT value was not restored SAVED ${!var} NEW $AT_NEW"
1672     done
1673 fi
1674
1675 # end of AT tests includes above lines
1676
1677 # start multi-client tests
1678 test_70a () {
1679         [ -z "$CLIENTS" ] && \
1680                 { skip "Need two or more clients." && return; }
1681         [ $CLIENTCOUNT -lt 2 ] && \
1682                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
1683
1684         echo "mount clients $CLIENTS ..."
1685         zconf_mount_clients $CLIENTS $DIR
1686
1687         local clients=${CLIENTS//,/ }
1688         echo "Write/read files on $DIR ; clients $CLIENTS ... "
1689         for CLIENT in $clients; do
1690                 do_node $CLIENT dd bs=1M count=10 if=/dev/zero \
1691                         of=$DIR/${tfile}_${CLIENT} 2>/dev/null || \
1692                                 error "dd failed on $CLIENT"
1693         done
1694
1695         local prev_client=$(echo $clients | sed 's/^.* \(.\+\)$/\1/')
1696         for C in ${CLIENTS//,/ }; do
1697                 do_node $prev_client dd if=$DIR/${tfile}_${C} of=/dev/null 2>/dev/null || \
1698                         error "dd if=$DIR/${tfile}_${C} failed on $prev_client"
1699                 prev_client=$C
1700         done
1701
1702         ls $DIR
1703 }
1704 run_test 70a "check multi client t-f"
1705
1706 test_70b () {
1707         [ -z "$CLIENTS" ] && \
1708                 { skip "Need two or more clients." && return; }
1709         [ $CLIENTCOUNT -lt 2 ] && \
1710                 { skip "Need two or more clients, have $CLIENTCOUNT" && return; }
1711
1712         zconf_mount_clients $CLIENTS $DIR
1713
1714         local duration=120
1715         [ "$SLOW" = "no" ] && duration=60
1716         local cmd="rundbench 1 -t $duration"
1717         local PID=""
1718         do_nodes $CLIENTS "set -x; MISSING_DBENCH_OK=$MISSING_DBENCH_OK \
1719                 PATH=:$PATH:$LUSTRE/utils:$LUSTRE/tests/:$DBENCH_LIB \
1720                 DBENCH_LIB=$DBENCH_LIB TESTSUITE=$TESTSUITE TESTNAME=$TESTNAME \
1721                 LCTL=$LCTL $cmd" &
1722         PID=$!
1723         log "Started rundbench load PID=$PID ..."
1724
1725         sleep $((duration / 4))
1726         replay_barrier mds
1727         sleep 3 # give clients a time to do operations
1728
1729         log "$TESTNAME fail mds 1"
1730         fail mds
1731
1732         wait $PID || error "rundbench load on $CLIENTS failed!"
1733
1734 }
1735 run_test 70b "mds recovery; $CLIENTCOUNT clients"
1736 # end multi-client tests
1737
1738 # vbr export handling
1739 test_71a() {
1740     delayed_recovery_enabled || { skip "No delayed recovery support"; return 0; }
1741
1742     UUID=$(lctl dl | awk '/mdc.*-mdc-/ { print $5 }')
1743     echo "Client UUID is $UUID"
1744     replay_barrier mds
1745     umount $DIR
1746     facet_failover mds
1747     zconf_mount `hostname` $DIR || error "mount fails"
1748     df $DIR || error "post-failover df failed"
1749     do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep $UUID" || \
1750         error "no delayed exports"
1751     OLD_AGE=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_export_age")
1752     NEW_AGE=10
1753     do_facet mds "lctl set_param mds.${mds_svc}.stale_export_age=$NEW_AGE"
1754     sleep $((NEW_AGE + 2))
1755     do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep \"$UUID.*EXPIRED\"" || \
1756         error "exports didn't expire"
1757     do_facet mds "lctl set_param mds.${mds_svc}.evict_client=$UUID"
1758     do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep $UUID" && \
1759         error "Export wasn't removed manually"
1760     do_facet mds "lctl set_param mds.${mds_svc}.stale_export_age=$OLD_AGE"
1761     return 0;
1762 }
1763 run_test 71a "lost client export is kept"
1764
1765 test_71b() {
1766     delayed_recovery_enabled || { skip "No delayed recovery support"; return 0; }
1767
1768     FAKE_NUM=10
1769     create_fake_exports mds $FAKE_NUM
1770     NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|wc -l")
1771     [ $NUM -eq 0 ] && error "no fake exports $NUM - $FAKE_NUM"
1772     OLD_AGE=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_export_age")
1773     NEW_AGE=10
1774     do_facet mds "lctl set_param mds.${mds_svc}.stale_export_age=$NEW_AGE"
1775     sleep $((NEW_AGE + 2))
1776     EX_NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep -c EXPIRED")
1777     [ "$EX_NUM" -eq "$NUM" ] || error "not all exports are expired $EX_NUM != $NUM"
1778     do_facet mds "lctl set_param mds.${mds_svc}.flush_stale_exports=1"
1779     do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep EXPIRED" && \
1780         error "Exports weren't flushed"
1781     do_facet mds "lctl set_param mds.${mds_svc}.stale_export_age=$OLD_AGE"
1782     return 0;
1783 }
1784 run_test 71b "stale exports are expired, lctl flushes them"
1785
1786 test_71c() {
1787     delayed_recovery_enabled || { skip "No delayed recovery support"; return 0; }
1788
1789     FAKE_NUM=10
1790     create_fake_exports mds $FAKE_NUM
1791     NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|wc -l")
1792     [ "$NUM" -eq "$FAKE_NUM" ] || error "no fake exports $NUM - $FAKE_NUM"
1793     OLD_AGE=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_export_age")
1794     NEW_AGE=10
1795     do_facet mds "lctl set_param mds.${mds_svc}.stale_export_age=$NEW_AGE"
1796     sleep $((NEW_AGE + 2))
1797     EX_NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep -c EXPIRED")
1798     [ "$EX_NUM" -eq "$NUM" ] || error "not all exports are expired $EX_NUM != $NUM"
1799
1800     umount $DIR
1801     zconf_mount `hostname` $DIR || error "mount fails"
1802
1803     NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|wc -l")
1804     [ $NUM -eq 0 ] || error "$NUM fake exports are still exists"
1805     do_facet mds "lctl set_param mds.${mds_svc}.stale_export_age=$OLD_AGE"
1806     return 0;
1807 }
1808 run_test 71c "stale exports are expired, new client connection flush them"
1809
1810 test_71d() {
1811     delayed_recovery_enabled || { skip "No delayed recovery support"; return 0; }
1812
1813     FAKE_NUM=10
1814     create_fake_exports mds $FAKE_NUM
1815     NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|wc -l")
1816     [ "$NUM" -eq "$FAKE_NUM" ] || error "no fake exports $NUM - $FAKE_NUM"
1817     OLD_AGE=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_export_age")
1818     NEW_AGE=10
1819     do_facet mds "lctl conf_param ${mds_svc}.mdt.stale_export_age=$NEW_AGE"
1820     sleep $((NEW_AGE + 2))
1821     EX_NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|grep -c EXPIRED")
1822     [ "$EX_NUM" -eq "$NUM" ] || error "not all exports are expired $EX_NUM != $NUM"
1823
1824     fail mds
1825
1826     FAIL_AGE=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_export_age")
1827     [ $FAIL_AGE -eq $NEW_AGE ] || error "new age wasn't set after recovery"
1828     NUM=$(do_facet mds "lctl get_param -n mds.${mds_svc}.stale_exports|wc -l")
1829     [ $NUM -eq 0 ] || error "$NUM fake exports are still exists"
1830     do_facet mds "lctl conf_param ${mds_svc}.mdt.stale_export_age=$OLD_AGE"
1831     return 0;
1832 }
1833 run_test 71d "expired exports, server init removes them, conf_param works"
1834
1835 # end vbr exports tests
1836
1837 test_72() { #bug 16711
1838     replay_barrier mds
1839     multiop_bg_pause $DIR/$tfile O_c || return 4
1840     pid=$!
1841 #define OBD_FAIL_TGT_REPLAY_DELAY 0x709
1842     do_facet mds "lctl set_param fail_loc=0x80000709"
1843     fail mds
1844     kill -USR1 $pid || return 1
1845     wait $pid || return 2
1846     $CHECKSTAT -t file $DIR/$tfile || return 3
1847 }
1848 run_test 72 "target_finish_recovery vs process_recovery_queue race"
1849
1850 test_73a() {
1851     multiop_bg_pause $DIR/$tfile O_tSc || return 3
1852     pid=$!
1853     rm -f $DIR/$tfile
1854
1855     replay_barrier mds
1856 #define OBD_FAIL_LDLM_ENQUEUE       0x302
1857     do_facet mds "lctl set_param fail_loc=0x80000302"
1858     fail mds
1859     kill -USR1 $pid
1860     wait $pid || return 1
1861     [ -e $DIR/$tfile ] && return 2
1862     return 0
1863 }
1864 run_test 73a "open(O_CREAT), unlink, replay, reconnect before open replay , close"
1865
1866 test_73b() {
1867     multiop_bg_pause $DIR/$tfile O_tSc || return 3
1868     pid=$!
1869     rm -f $DIR/$tfile
1870
1871     replay_barrier mds
1872 #define OBD_FAIL_LDLM_REPLY       0x30c
1873     do_facet mds "lctl set_param fail_loc=0x8000030c"
1874     fail mds
1875     kill -USR1 $pid
1876     wait $pid || return 1
1877     [ -e $DIR/$tfile ] && return 2
1878     return 0
1879 }
1880 run_test 73b "open(O_CREAT), unlink, replay, reconnect at open_replay reply, close"
1881
1882 test_73c() {
1883     multiop_bg_pause $DIR/$tfile O_tSc || return 3
1884     pid=$!
1885     rm -f $DIR/$tfile
1886
1887     replay_barrier mds
1888 #define OBD_FAIL_TGT_LAST_REPLAY       0x710
1889     do_facet mds "lctl set_param fail_loc=0x80000710"
1890     fail mds
1891     kill -USR1 $pid
1892     wait $pid || return 1
1893     [ -e $DIR/$tfile ] && return 2
1894     return 0
1895 }
1896 run_test 73c "open(O_CREAT), unlink, replay, reconnect at last_replay, close"
1897
1898 test_80a() {
1899     do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
1900
1901     replay_barrier ost1
1902     lfs setstripe -i 0 -c 1 $DIR/$tfile
1903     dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 || error "Cannot write"
1904     cksum=`md5sum $DIR/$tfile | awk '{print $1}'`
1905     cancel_lru_locks osc
1906     fail ost1
1907     dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
1908     cksum2=`md5sum $DIR/$tfile | awk '{print $1}'`
1909     if [ $cksum != $cksum2 ] ; then
1910         error "New checksum $cksum2 does not match original $cksum"
1911     fi
1912 }
1913 run_test 80a "write replay"
1914
1915 test_80b() {
1916     do_facet ost1 "lctl set_param -n obdfilter.${ost1_svc}.sync_journal 0"
1917
1918     replay_barrier ost1
1919     lfs setstripe -i 0 -c 1 $DIR/$tfile
1920     dd if=/dev/urandom of=$DIR/$tfile bs=1024k count=8 || error "Cannot write"
1921     sleep 1 # Give it a chance to flush dirty data
1922     echo TESTTEST | dd of=$DIR/$tfile bs=1 count=8 seek=64
1923     cksum=`md5sum $DIR/$tfile | awk '{print $1}'`
1924     cancel_lru_locks osc
1925     fail ost1
1926     dd if=$DIR/$tfile of=/dev/null bs=1024k count=8 || error "Cannot read"
1927     cksum2=`md5sum $DIR/$tfile | awk '{print $1}'`
1928     if [ $cksum != $cksum2 ] ; then
1929         error "New checksum $cksum2 does not match original $cksum"
1930     fi
1931 }
1932 run_test 80b "write replay with changed data (checksum resend)"
1933
1934 equals_msg `basename $0`: test complete, cleaning up
1935 check_and_cleanup_lustre
1936 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG && grep -q FAIL $TESTSUITELOG && exit 1 || true