lustre/tests/replay-single.sh

   1 #!/bin/sh
   2
   3 set -e
   4
   5 #
   6 # This test needs to be run on the client
   7 #
   8
   9 LUSTRE=${LUSTRE:-`dirname $0`/..}
  10 . $LUSTRE/tests/test-framework.sh
  11
  12 init_test_env $@
  13
  14 . ${CONFIG:=$LUSTRE/tests/cfg/lmv.sh}
  15
  16 build_test_filter
  17
  18 assert_env MDSCOUNT
  19
  20 # Skip these tests
  21 ALWAYS_EXCEPT=""
  22
  23 gen_config() {
  24     rm -f $XMLCONFIG
  25
  26     if [ "$MDSCOUNT" -gt 1 ]; then
  27         add_lmv lmv1
  28         for mds in `mds_list`; do
  29             MDSDEV=$TMP/${mds}-`hostname`
  30             add_mds $mds --dev $MDSDEV --size $MDSSIZE --lmv lmv1
  31         done
  32         MDS=lmv1
  33         add_lov_to_lmv lov1 lmv1 --stripe_sz $STRIPE_BYTES \
  34             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  35     else
  36         add_mds mds1 --dev $MDSDEV --size $MDSSIZE
  37         if [ ! -z "$mds1failover_HOST" ]; then
  38              add_mdsfailover mds1 --dev $MDSDEV --size $MDSSIZE
  39         fi
  40         add_lov lov1 mds1 --stripe_sz $STRIPE_BYTES \
  41             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  42         MDS=mds1_svc
  43     fi
  44
  45     add_ost ost --lov lov1 --dev $OSTDEV --size $OSTSIZE
  46     add_ost ost2 --lov lov1 --dev ${OSTDEV}-2 --size $OSTSIZE
  47     add_client client --mds $MDS --lov lov1 --path $MOUNT
  48
  49 }
  50
  51 build_test_filter
  52
  53 cleanup() {
  54     # make sure we are using the primary MDS, so the config log will
  55     # be able to clean up properly.
  56     activemds=`facet_active mds1`
  57     if [ $activemds != "mds1" ]; then
  58         fail mds1
  59     fi
  60     zconf_umount `hostname` $MOUNT
  61     for mds in `mds_list`; do
  62         stop $mds ${FORCE} $MDSLCONFARGS
  63     done
  64     stop ost2 ${FORCE} --dump cleanup.log
  65     stop ost ${FORCE} --dump cleanup.log
  66 }
  67
  68 if [ "$ONLY" == "cleanup" ]; then
  69     sysctl -w portals.debug=0 || true
  70     cleanup
  71     exit
  72 fi
  73
  74 SETUP=${SETUP:-"setup"}
  75 CLEANUP=${CLEANUP:-"cleanup"}
  76
  77 setup() {
  78     gen_config
  79
  80     start ost --reformat $OSTLCONFARGS
  81     start ost2 --reformat $OSTLCONFARGS
  82     [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  83     for mds in `mds_list`; do
  84         start $mds --reformat $MDSLCONFARGS
  85     done
  86     grep " $MOUNT " /proc/mounts || zconf_mount `hostname` $MOUNT
  87 }
  88
  89 $SETUP
  90
  91 if [ "$ONLY" == "setup" ]; then
  92     exit 0
  93 fi
  94
  95 mkdir -p $DIR
  96
  97 test_0() {
  98     replay_barrier mds1
  99     fail mds1
 100 }
 101 run_test 0 "empty replay"
 102
 103 test_0b() {
 104     # this test attempts to trigger a race in the precreation code,
 105     # and must run before any other objects are created on the filesystem
 106     fail ost
 107     createmany -o $DIR/$tfile 20 || return 1
 108     unlinkmany $DIR/$tfile 20 || return 2
 109 }
 110 run_test 0b "ensure object created after recover exists. (3284)"
 111
 112 test_1() {
 113     replay_barrier mds1
 114     mcreate $DIR/$tfile
 115     fail mds1
 116     $CHECKSTAT -t file $DIR/$tfile || return 1
 117     rm $DIR/$tfile
 118 }
 119 run_test 1 "simple create"
 120
 121 test_2a() {
 122     replay_barrier mds1
 123     touch $DIR/$tfile
 124     fail mds1
 125     $CHECKSTAT -t file $DIR/$tfile || return 1
 126     rm $DIR/$tfile
 127 }
 128 run_test 2a "touch"
 129
 130 test_2b() {
 131     ./mcreate $DIR/$tfile
 132     replay_barrier mds1
 133     touch $DIR/$tfile
 134     fail mds1
 135     $CHECKSTAT -t file $DIR/$tfile || return 1
 136     rm $DIR/$tfile
 137 }
 138 run_test 2b "touch"
 139
 140 test_3a() {
 141     replay_barrier mds1
 142     mcreate $DIR/$tfile
 143     o_directory $DIR/$tfile
 144     fail mds1
 145     $CHECKSTAT -t file $DIR/$tfile || return 2
 146     rm $DIR/$tfile
 147 }
 148 run_test 3a "replay failed open(O_DIRECTORY)"
 149
 150 test_3b() {
 151     replay_barrier mds1
 152 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 153     do_facet mds "sysctl -w lustre.fail_loc=0x80000114"
 154     touch $DIR/$tfile
 155     do_facet mds "sysctl -w lustre.fail_loc=0"
 156     fail mds1
 157     $CHECKSTAT -t file $DIR/$tfile && return 2
 158     return 0
 159 }
 160 run_test 3b "replay failed open -ENOMEM"
 161
 162 test_3c() {
 163     replay_barrier mds1
 164 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 165     do_facet mds "sysctl -w lustre.fail_loc=0x80000128"
 166     touch $DIR/$tfile
 167     do_facet mds "sysctl -w lustre.fail_loc=0"
 168     fail mds1
 169
 170     $CHECKSTAT -t file $DIR/$tfile && return 2
 171     return 0
 172 }
 173 run_test 3c "replay failed open -ENOMEM"
 174
 175 test_4() {
 176     replay_barrier mds1
 177     for i in `seq 10`; do
 178         echo "tag-$i" > $DIR/$tfile-$i
 179     done
 180     fail mds1
 181     for i in `seq 10`; do
 182       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 183     done
 184 }
 185 run_test 4 "|x| 10 open(O_CREAT)s"
 186
 187 test_4b() {
 188     replay_barrier mds1
 189     rm -rf $DIR/$tfile-*
 190     fail mds1
 191     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 192 }
 193 run_test 4b "|x| rm 10 files"
 194
 195 # The idea is to get past the first block of precreated files on both
 196 # osts, and then replay.
 197 test_5() {
 198     replay_barrier mds1
 199     for i in `seq 220`; do
 200         echo "tag-$i" > $DIR/$tfile-$i
 201     done
 202     fail mds1
 203     for i in `seq 220`; do
 204       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
 205     done
 206     rm -rf $DIR/$tfile-*
 207     sleep 3
 208     # waiting for commitment of removal
 209 }
 210 run_test 5 "|x| 220 open(O_CREAT)"
 211
 212
 213 test_6() {
 214     replay_barrier mds1
 215     mkdir $DIR/$tdir
 216     mcreate $DIR/$tdir/$tfile
 217     fail mds1
 218     $CHECKSTAT -t dir $DIR/$tdir || return 1
 219     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 220     sleep 2
 221     # waiting for log process thread
 222 }
 223 run_test 6 "mkdir + contained create"
 224
 225 test_6b() {
 226     replay_barrier mds1
 227     rm -rf $DIR/$tdir
 228     fail mds1
 229     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 230 }
 231 run_test 6b "|X| rmdir"
 232
 233 test_7() {
 234     mkdir $DIR/$tdir
 235     replay_barrier mds1
 236     mcreate $DIR/$tdir/$tfile
 237     fail mds1
 238     $CHECKSTAT -t dir $DIR/$tdir || return 1
 239     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 240     rm -fr $DIR/$tdir
 241 }
 242 run_test 7 "mkdir |X| contained create"
 243
 244 test_8() {
 245     replay_barrier mds1
 246     multiop $DIR/$tfile mo_c &
 247     MULTIPID=$!
 248     sleep 1
 249     fail mds1
 250     ls $DIR/$tfile
 251     $CHECKSTAT -t file $DIR/$tfile || return 1
 252     kill -USR1 $MULTIPID || return 2
 253     wait $MULTIPID || return 3
 254     rm $DIR/$tfile
 255 }
 256 run_test 8 "creat open |X| close"
 257
 258 test_9() {
 259     replay_barrier mds1
 260     mcreate $DIR/$tfile
 261     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 262     fail mds1
 263     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 264
 265     echo " old_inum == $old_inum, new_inum == $new_inum"
 266     if [ $old_inum -eq $new_inum  ] ;
 267     then
 268         echo " old_inum and new_inum match"
 269     else
 270         echo "!!!! old_inum and new_inum NOT match"
 271         return 1
 272     fi
 273     rm $DIR/$tfile
 274 }
 275 run_test 9  "|X| create (same inum/gen)"
 276
 277 test_10() {
 278     mcreate $DIR/$tfile
 279     replay_barrier mds1
 280     mv $DIR/$tfile $DIR/$tfile-2
 281     rm -f $DIR/$tfile
 282     fail mds1
 283     $CHECKSTAT $DIR/$tfile && return 1
 284     $CHECKSTAT $DIR/$tfile-2 ||return 2
 285     rm $DIR/$tfile-2
 286     return 0
 287 }
 288 run_test 10 "create |X| rename unlink"
 289
 290 test_11() {
 291     mcreate $DIR/$tfile
 292     echo "old" > $DIR/$tfile
 293     mv $DIR/$tfile $DIR/$tfile-2
 294     replay_barrier mds1
 295     echo "new" > $DIR/$tfile
 296     grep new $DIR/$tfile
 297     grep old $DIR/$tfile-2
 298     fail mds1
 299     grep new $DIR/$tfile || return 1
 300     grep old $DIR/$tfile-2 || return 2
 301 }
 302 run_test 11 "create open write rename |X| create-old-name read"
 303
 304 test_12() {
 305     mcreate $DIR/$tfile
 306     multiop $DIR/$tfile o_tSc &
 307     pid=$!
 308     # give multiop a chance to open
 309     sleep 1
 310     rm -f $DIR/$tfile
 311     replay_barrier mds1
 312     kill -USR1 $pid
 313     wait $pid || return 1
 314
 315     fail mds1
 316     [ -e $DIR/$tfile ] && return 2
 317     return 0
 318 }
 319 run_test 12 "open, unlink |X| close"
 320
 321
 322 # 1777 - replay open after committed chmod that would make
 323 #        a regular open a failure
 324 test_13() {
 325     mcreate $DIR/$tfile
 326     multiop $DIR/$tfile O_wc &
 327     pid=$!
 328     # give multiop a chance to open
 329     sleep 1
 330     chmod 0 $DIR/$tfile
 331     $CHECKSTAT -p 0 $DIR/$tfile
 332     replay_barrier mds1
 333     fail mds1
 334     kill -USR1 $pid
 335     wait $pid || return 1
 336
 337     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
 338     return 0
 339 }
 340 run_test 13 "open chmod 0 |x| write close"
 341
 342 test_14() {
 343     multiop $DIR/$tfile O_tSc &
 344     pid=$!
 345     # give multiop a chance to open
 346     sleep 1
 347     rm -f $DIR/$tfile
 348     replay_barrier mds1
 349     kill -USR1 $pid || return 1
 350     wait $pid || return 2
 351
 352     fail mds1
 353     [ -e $DIR/$tfile ] && return 3
 354     return 0
 355 }
 356 run_test 14 "open(O_CREAT), unlink |X| close"
 357
 358 test_15() {
 359     multiop $DIR/$tfile O_tSc &
 360     pid=$!
 361     # give multiop a chance to open
 362     sleep 1
 363     rm -f $DIR/$tfile
 364     replay_barrier mds1
 365     touch $DIR/g11 || return 1
 366     kill -USR1 $pid
 367     wait $pid || return 2
 368
 369     fail mds1
 370     [ -e $DIR/$tfile ] && return 3
 371     touch $DIR/h11 || return 4
 372     return 0
 373 }
 374 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 375
 376
 377 test_16() {
 378     replay_barrier mds1
 379     mcreate $DIR/$tfile
 380     munlink $DIR/$tfile
 381     mcreate $DIR/$tfile-2
 382     fail mds1
 383     [ -e $DIR/$tfile ] && return 1
 384     [ -e $DIR/$tfile-2 ] || return 2
 385     munlink $DIR/$tfile-2 || return 3
 386 }
 387 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 388
 389 test_17() {
 390     replay_barrier mds1
 391     multiop $DIR/$tfile O_c &
 392     pid=$!
 393     # give multiop a chance to open
 394     sleep 1
 395     fail mds1
 396     kill -USR1 $pid || return 1
 397     wait $pid || return 2
 398     $CHECKSTAT -t file $DIR/$tfile || return 3
 399     rm $DIR/$tfile
 400 }
 401 run_test 17 "|X| open(O_CREAT), |replay| close"
 402
 403 test_18() {
 404     replay_barrier mds1
 405     multiop $DIR/$tfile O_tSc &
 406     pid=$!
 407     # give multiop a chance to open
 408     sleep 1
 409     rm -f $DIR/$tfile
 410     touch $DIR/$tfile-2 || return 1
 411     echo "pid: $pid will close"
 412     kill -USR1 $pid
 413     wait $pid || return 2
 414
 415     fail mds1
 416     [ -e $DIR/$tfile ] && return 3
 417     [ -e $DIR/$tfile-2 ] || return 4
 418     # this touch frequently fails
 419     touch $DIR/$tfile-3 || return 5
 420     munlink $DIR/$tfile-2 || return 6
 421     munlink $DIR/$tfile-3 || return 7
 422     return 0
 423 }
 424 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
 425
 426 # bug 1855 (a simpler form of test_11 above)
 427 test_19() {
 428     replay_barrier mds1
 429     mcreate $DIR/$tfile
 430     echo "old" > $DIR/$tfile
 431     mv $DIR/$tfile $DIR/$tfile-2
 432     grep old $DIR/$tfile-2
 433     fail mds1
 434     grep old $DIR/$tfile-2 || return 2
 435 }
 436 run_test 19 "|X| mcreate, open, write, rename "
 437
 438 test_20() {
 439     replay_barrier mds1
 440     multiop $DIR/$tfile O_tSc &
 441     pid=$!
 442     # give multiop a chance to open
 443     sleep 1
 444     rm -f $DIR/$tfile
 445
 446     fail mds1
 447     kill -USR1 $pid
 448     wait $pid || return 1
 449     [ -e $DIR/$tfile ] && return 2
 450     return 0
 451 }
 452 run_test 20 "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 453
 454 test_21() {
 455     replay_barrier mds1
 456     multiop $DIR/$tfile O_tSc &
 457     pid=$!
 458     # give multiop a chance to open
 459     sleep 1
 460     rm -f $DIR/$tfile
 461     touch $DIR/g11 || return 1
 462
 463     fail mds1
 464     kill -USR1 $pid
 465     wait $pid || return 2
 466     [ -e $DIR/$tfile ] && return 3
 467     touch $DIR/h11 || return 4
 468     return 0
 469 }
 470 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 471
 472 test_22() {
 473     multiop $DIR/$tfile O_tSc &
 474     pid=$!
 475     # give multiop a chance to open
 476     sleep 1
 477
 478     replay_barrier mds1
 479     rm -f $DIR/$tfile
 480
 481     fail mds1
 482     kill -USR1 $pid
 483     wait $pid || return 1
 484     [ -e $DIR/$tfile ] && return 2
 485     return 0
 486 }
 487 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
 488
 489 test_23() {
 490     multiop $DIR/$tfile O_tSc &
 491     pid=$!
 492     # give multiop a chance to open
 493     sleep 1
 494
 495     replay_barrier mds1
 496     rm -f $DIR/$tfile
 497     touch $DIR/g11 || return 1
 498
 499     fail mds1
 500     kill -USR1 $pid
 501     wait $pid || return 2
 502     [ -e $DIR/$tfile ] && return 3
 503     touch $DIR/h11 || return 4
 504     return 0
 505 }
 506 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 507
 508 test_24() {
 509     multiop $DIR/$tfile O_tSc &
 510     pid=$!
 511     # give multiop a chance to open
 512     sleep 1
 513
 514     replay_barrier mds1
 515     fail mds1
 516     rm -f $DIR/$tfile
 517     kill -USR1 $pid
 518     wait $pid || return 1
 519     [ -e $DIR/$tfile ] && return 2
 520     return 0
 521 }
 522 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 523
 524 test_25() {
 525     multiop $DIR/$tfile O_tSc &
 526     pid=$!
 527     # give multiop a chance to open
 528     sleep 1
 529     rm -f $DIR/$tfile
 530
 531     replay_barrier mds1
 532     fail mds1
 533     kill -USR1 $pid
 534     wait $pid || return 1
 535     [ -e $DIR/$tfile ] && return 2
 536     return 0
 537 }
 538 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 539
 540 test_26() {
 541     replay_barrier mds1
 542     multiop $DIR/$tfile-1 O_tSc &
 543     pid1=$!
 544     multiop $DIR/$tfile-2 O_tSc &
 545     pid2=$!
 546     # give multiop a chance to open
 547     sleep 1
 548     rm -f $DIR/$tfile-1
 549     rm -f $DIR/$tfile-2
 550     kill -USR1 $pid2
 551     wait $pid2 || return 1
 552
 553     fail mds1
 554     kill -USR1 $pid1
 555     wait $pid1 || return 2
 556     [ -e $DIR/$tfile-1 ] && return 3
 557     [ -e $DIR/$tfile-2 ] && return 4
 558     return 0
 559 }
 560 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 561
 562 test_27() {
 563     replay_barrier mds1
 564     multiop $DIR/$tfile-1 O_tSc &
 565     pid1=$!
 566     multiop $DIR/$tfile-2 O_tSc &
 567     pid2=$!
 568     # give multiop a chance to open
 569     sleep 1
 570     rm -f $DIR/$tfile-1
 571     rm -f $DIR/$tfile-2
 572
 573     fail mds1
 574     kill -USR1 $pid1
 575     wait $pid1 || return 1
 576     kill -USR1 $pid2
 577     wait $pid2 || return 2
 578     [ -e $DIR/$tfile-1 ] && return 3
 579     [ -e $DIR/$tfile-2 ] && return 4
 580     return 0
 581 }
 582 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 583
 584 test_28() {
 585     multiop $DIR/$tfile-1 O_tSc &
 586     pid1=$!
 587     multiop $DIR/$tfile-2 O_tSc &
 588     pid2=$!
 589     # give multiop a chance to open
 590     sleep 1
 591     replay_barrier mds1
 592     rm -f $DIR/$tfile-1
 593     rm -f $DIR/$tfile-2
 594     kill -USR1 $pid2
 595     wait $pid2 || return 1
 596
 597     fail mds1
 598     kill -USR1 $pid1
 599     wait $pid1 || return 2
 600     [ -e $DIR/$tfile-1 ] && return 3
 601     [ -e $DIR/$tfile-2 ] && return 4
 602     return 0
 603 }
 604 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 605
 606 test_29() {
 607     multiop $DIR/$tfile-1 O_tSc &
 608     pid1=$!
 609     multiop $DIR/$tfile-2 O_tSc &
 610     pid2=$!
 611     # give multiop a chance to open
 612     sleep 1
 613     replay_barrier mds1
 614     rm -f $DIR/$tfile-1
 615     rm -f $DIR/$tfile-2
 616
 617     fail mds1
 618     kill -USR1 $pid1
 619     wait $pid1 || return 1
 620     kill -USR1 $pid2
 621     wait $pid2 || return 2
 622     [ -e $DIR/$tfile-1 ] && return 3
 623     [ -e $DIR/$tfile-2 ] && return 4
 624     return 0
 625 }
 626 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 627
 628 test_30() {
 629     multiop $DIR/$tfile-1 O_tSc &
 630     pid1=$!
 631     multiop $DIR/$tfile-2 O_tSc &
 632     pid2=$!
 633     # give multiop a chance to open
 634     sleep 1
 635     rm -f $DIR/$tfile-1
 636     rm -f $DIR/$tfile-2
 637
 638     replay_barrier mds1
 639     fail mds1
 640     kill -USR1 $pid1
 641     wait $pid1 || return 1
 642     kill -USR1 $pid2
 643     wait $pid2 || return 2
 644     [ -e $DIR/$tfile-1 ] && return 3
 645     [ -e $DIR/$tfile-2 ] && return 4
 646     return 0
 647 }
 648 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 649
 650 test_31() {
 651     multiop $DIR/$tfile-1 O_tSc &
 652     pid1=$!
 653     multiop $DIR/$tfile-2 O_tSc &
 654     pid2=$!
 655     # give multiop a chance to open
 656     sleep 1
 657     rm -f $DIR/$tfile-1
 658
 659     replay_barrier mds1
 660     rm -f $DIR/$tfile-2
 661     fail mds1
 662     kill -USR1 $pid1
 663     wait $pid1 || return 1
 664     kill -USR1 $pid2
 665     wait $pid2 || return 2
 666     [ -e $DIR/$tfile-1 ] && return 3
 667     [ -e $DIR/$tfile-2 ] && return 4
 668     return 0
 669 }
 670 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 671
 672 # tests for bug 2104; completion without crashing is success.  The close is
 673 # stale, but we always return 0 for close, so the app never sees it.
 674 test_32() {
 675     multiop $DIR/$tfile O_c &
 676     pid1=$!
 677     multiop $DIR/$tfile O_c &
 678     pid2=$!
 679     # give multiop a chance to open
 680     sleep 1
 681     mds_evict_client
 682     df $MOUNT || df $MOUNT || return 1
 683     kill -USR1 $pid1
 684     kill -USR1 $pid2
 685     sleep 1
 686     return 0
 687 }
 688 run_test 32 "close() notices client eviction; close() after client eviction"
 689
 690 # Abort recovery before client complete
 691 test_33() {
 692     replay_barrier mds1
 693     touch $DIR/$tfile
 694     fail_abort mds1
 695     # this file should be gone, because the replay was aborted
 696     $CHECKSTAT -t file $DIR/$tfile && return 1
 697     return 0
 698 }
 699 run_test 33 "abort recovery before client does replay"
 700
 701 test_34() {
 702     multiop $DIR/$tfile O_c &
 703     pid=$!
 704     # give multiop a chance to open
 705     sleep 1
 706     rm -f $DIR/$tfile
 707
 708     replay_barrier mds1
 709     fail_abort mds1
 710     kill -USR1 $pid
 711     [ -e $DIR/$tfile ] && return 1
 712     sync
 713     return 0
 714 }
 715 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 716
 717 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 718 test_35() {
 719     touch $DIR/$tfile
 720
 721 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 722     do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
 723     rm -f $DIR/$tfile &
 724     sleep 1
 725     sync
 726     sleep 1
 727     # give a chance to remove from MDS
 728     fail_abort mds1
 729     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
 730 }
 731 run_test 35 "test recovery from llog for unlink op"
 732
 733 # b=2432 resent cancel after replay uses wrong cookie,
 734 # so don't resend cancels
 735 test_36() {
 736     replay_barrier mds1
 737     touch $DIR/$tfile
 738     checkstat $DIR/$tfile
 739     facet_failover mds1
 740     cancel_lru_locks MDC
 741     if dmesg | grep "unknown lock cookie"; then
 742         echo "cancel after replay failed"
 743         return 1
 744     fi
 745 }
 746 run_test 36 "don't resend cancel"
 747
 748 # b=2368
 749 # directory orphans can't be unlinked from PENDING directory
 750 test_37() {
 751     rmdir $DIR/$tfile 2>/dev/null
 752     multiop $DIR/$tfile dD_c &
 753     pid=$!
 754     # give multiop a chance to open
 755     sleep 1
 756     rmdir $DIR/$tfile
 757
 758     replay_barrier mds1
 759     # clear the dmesg buffer so we only see errors from this recovery
 760     dmesg -c >/dev/null
 761     fail_abort mds1
 762     kill -USR1 $pid
 763     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
 764     sync
 765     return 0
 766 }
 767 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 768
 769 test_38() {
 770     createmany -o $DIR/$tfile-%d 800
 771     unlinkmany $DIR/$tfile-%d 0 400
 772     replay_barrier mds1
 773     fail mds1
 774     unlinkmany $DIR/$tfile-%d 400 400
 775     sleep 2
 776     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 777 }
 778 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 779
 780 test_39() {
 781     createmany -o $DIR/$tfile-%d 800
 782     replay_barrier mds1
 783     unlinkmany $DIR/$tfile-%d 0 400
 784     fail mds1
 785     unlinkmany $DIR/$tfile-%d 400 400
 786     sleep 2
 787     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 788 }
 789 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 790
 791 count_ost_writes() {
 792         cat /proc/fs/lustre/osc/*/stats |
 793             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
 794 }
 795
 796 #b=2477,2532
 797 test_40(){
 798     $LCTL mark multiop $MOUNT/$tfile OS_c
 799     multiop $MOUNT/$tfile OS_c  &
 800     PID=$!
 801     writeme -s $MOUNT/${tfile}-2 &
 802     WRITE_PID=$!
 803     sleep 1
 804     facet_failover mds1
 805 #define OBD_FAIL_MDS_CONNECT_NET         0x117
 806     do_facet mds "sysctl -w lustre.fail_loc=0x80000117"
 807     kill -USR1 $PID
 808     stat1=`count_ost_writes`
 809     sleep $TIMEOUT
 810     stat2=`count_ost_writes`
 811     echo "$stat1, $stat2"
 812     if [ $stat1 -lt $stat2 ]; then
 813        echo "writes continuing during recovery"
 814        RC=0
 815     else
 816        echo "writes not continuing during recovery, bug 2477"
 817        RC=4
 818     fi
 819     echo "waiting for writeme $WRITE_PID"
 820     kill $WRITE_PID
 821     wait $WRITE_PID
 822
 823     echo "waiting for multiop $PID"
 824     wait $PID || return 2
 825     do_facet client munlink $MOUNT/$tfile  || return 3
 826     do_facet client munlink $MOUNT/${tfile}-2  || return 3
 827     return $RC
 828 }
 829 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 830
 831
 832 #b=2814
 833 # make sure that a read to one osc doesn't try to double-unlock its page just
 834 # because another osc is invalid.  trigger_group_io used to mistakenly return
 835 # an error if any oscs were invalid even after having successfully put rpcs
 836 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 837 # the page, guarnateeing that the unlock from the RPC completion would
 838 # assert on trying to unlock the unlocked page.
 839 test_41() {
 840     local f=$MOUNT/$tfile
 841     # make sure the start of the file is ost1
 842     lfs setstripe $f $((128 * 1024)) 0 0
 843     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
 844     cancel_lru_locks OSC
 845     # fail ost2 and read from ost1
 846     local osc2_dev=`$LCTL device_list | \
 847                 awk '(/ost2.*client_facet/){print $4}' `
 848     $LCTL --device %$osc2_dev deactivate
 849     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
 850     $LCTL --device %$osc2_dev activate
 851     return 0
 852 }
 853 run_test 41 "read from a valid osc while other oscs are invalid"
 854
 855 # test MDS recovery after ost failure
 856 test_42() {
 857     blocks=`df $MOUNT | tail -n 1 | awk '{ print $1 }'`
 858     createmany -o $DIR/$tfile-%d 800
 859     replay_barrier ost
 860     unlinkmany $DIR/$tfile-%d 0 400
 861     facet_failover ost
 862
 863     # osc is evicted, fs is smaller
 864     blocks_after=`df $MOUNT | tail -n 1 | awk '{ print $1 }'`
 865     [ $blocks_after -lt $blocks ] || return 1
 866     echo wait for MDS to timeout and recover
 867     sleep $((TIMEOUT * 2))
 868     unlinkmany $DIR/$tfile-%d 400 400
 869     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
 870 }
 871 run_test 42 "recovery after ost failure"
 872
 873 # b=2530
 874 # timeout in MDS/OST recovery RPC will LBUG MDS
 875 test_43() {
 876     replay_barrier mds1
 877
 878     # OBD_FAIL_OST_CREATE_NET 0x204
 879     do_facet ost "sysctl -w lustre.fail_loc=0x80000204"
 880     facet_failover mds1
 881     df $MOUNT || return 1
 882     sleep 10
 883     do_facet ost "sysctl -w lustre.fail_loc=0"
 884
 885     return 0
 886 }
 887 run_test 43 "mds osc import failure during recovery; don't LBUG"
 888
 889 test_44() {
 890     mdcdev=`awk '/mds_svc_MNT/ {print $1}' < /proc/fs/lustre/devices`
 891     do_facet mds "sysctl -w lustre.fail_loc=0x80000701"
 892     $LCTL --device $mdcdev recover
 893     df $MOUNT
 894     do_facet mds "sysctl -w lustre.fail_loc=0"
 895     return 0
 896 }
 897 run_test 44 "race in target handle connect"
 898
 899 # Handle failed close
 900 test_45() {
 901     mdcdev=`awk '/mds_svc_MNT/ {print $1}' < /proc/fs/lustre/devices`
 902     $LCTL --device $mdcdev recover
 903
 904     multiop $DIR/$tfile O_c &
 905     pid=$!
 906     sleep 1
 907
 908     # This will cause the CLOSE to fail before even
 909     # allocating a reply buffer
 910     $LCTL --device $mdcdev deactivate
 911
 912     # try the close
 913     kill -USR1 $pid
 914     wait $pid || return 1
 915
 916     $LCTL --device $mdcdev activate
 917
 918     $CHECKSTAT -t file $DIR/$tfile || return 2
 919     return 0
 920 }
 921 run_test 45 "Handle failed close"
 922
 923 test_46() {
 924     dmesg -c >/dev/null
 925     drop_reply "touch $DIR/$tfile"
 926     fail mds1
 927     # ironically, the previous test, 45, will cause a real forced close,
 928     # so just look for one for this test
 929     dmesg | grep -i "force closing client file handle for $tfile" && return 1
 930     return 0
 931 }
 932 run_test 46 "Don't leak file handle after open resend (3325)"
 933
 934 # b=2824
 935 test_47() {
 936
 937     # create some files to make sure precreate has been done on all
 938     # OSTs. (just in case this test is run independently)
 939     createmany -o $DIR/$tfile 20  || return 1
 940
 941     # OBD_FAIL_OST_CREATE_NET 0x204
 942     fail ost
 943     do_facet ost "sysctl -w lustre.fail_loc=0x80000204"
 944     df $MOUNT || return 2
 945
 946     # let the MDS discover the OST failure, attempt to recover, fail
 947     # and recover again.
 948     sleep $((3 * TIMEOUT))
 949
 950     # Without 2824, this createmany would hang
 951     createmany -o $DIR/$tfile 20 || return 3
 952     unlinkmany $DIR/$tfile 20 || return 4
 953
 954     do_facet ost "sysctl -w lustre.fail_loc=0"
 955     return 0
 956 }
 957 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
 958
 959 equals_msg test complete, cleaning up
 960 $CLEANUP
 961