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_svc
  28         for mds in `mds_list`; do
  29             MDSDEV=$TMP/${mds}-`hostname`
  30             add_mds $mds --dev $MDSDEV --size $MDSSIZE --lmv lmv1_svc
  31         done
  32         add_lov_to_lmv lov1 lmv1_svc --stripe_sz $STRIPE_BYTES \
  33             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  34         MDS=lmv1
  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 --lov lov1 --path $MOUNT
  48 }
  49
  50 build_test_filter
  51
  52 cleanup() {
  53     # make sure we are using the primary MDS, so the config log will
  54     # be able to clean up properly.
  55     activemds=`facet_active mds1`
  56     if [ $activemds != "mds1" ]; then
  57         fail mds1
  58     fi
  59     zconf_umount `hostname` $MOUNT
  60     for mds in `mds_list`; do
  61         stop $mds ${FORCE} $MDSLCONFARGS
  62     done
  63     stop ost2 ${FORCE} --dump cleanup.log
  64     stop ost ${FORCE} --dump cleanup.log
  65 }
  66
  67 if [ "$ONLY" == "cleanup" ]; then
  68     sysctl -w portals.debug=0 || true
  69     cleanup
  70     exit
  71 fi
  72
  73 SETUP=${SETUP:-"setup"}
  74 CLEANUP=${CLEANUP:-"cleanup"}
  75
  76 setup() {
  77     gen_config
  78
  79     start ost --reformat $OSTLCONFARGS
  80     start ost2 --reformat $OSTLCONFARGS
  81     [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  82     for mds in `mds_list`; do
  83         start $mds --reformat $MDSLCONFARGS
  84     done
  85     grep " $MOUNT " /proc/mounts || zconf_mount `hostname` $MOUNT
  86 }
  87
  88 $SETUP
  89
  90 if [ "$ONLY" == "setup" ]; then
  91     exit 0
  92 fi
  93
  94 mkdir -p $DIR
  95
  96 test_0() {
  97     replay_barrier mds1
  98     fail mds1
  99 }
 100 run_test 0 "empty replay"
 101
 102 test_0b() {
 103     # this test attempts to trigger a race in the precreation code,
 104     # and must run before any other objects are created on the filesystem
 105     fail ost
 106     createmany -o $DIR/$tfile 20 || return 1
 107     unlinkmany $DIR/$tfile 20 || return 2
 108 }
 109 run_test 0b "ensure object created after recover exists. (3284)"
 110
 111 test_1() {
 112     replay_barrier mds1
 113     mcreate $DIR/$tfile
 114     fail mds1
 115     $CHECKSTAT -t file $DIR/$tfile || return 1
 116     rm $DIR/$tfile
 117 }
 118 run_test 1 "simple create"
 119
 120 test_2a() {
 121     replay_barrier mds1
 122     touch $DIR/$tfile
 123     fail mds1
 124     $CHECKSTAT -t file $DIR/$tfile || return 1
 125     rm $DIR/$tfile
 126 }
 127 run_test 2a "touch"
 128
 129 test_2b() {
 130     ./mcreate $DIR/$tfile
 131     replay_barrier mds1
 132     touch $DIR/$tfile
 133     fail mds1
 134     $CHECKSTAT -t file $DIR/$tfile || return 1
 135     rm $DIR/$tfile
 136 }
 137 run_test 2b "touch"
 138
 139 test_3a() {
 140     replay_barrier mds1
 141     mcreate $DIR/$tfile
 142     o_directory $DIR/$tfile
 143     fail mds1
 144     $CHECKSTAT -t file $DIR/$tfile || return 2
 145     rm $DIR/$tfile
 146 }
 147 run_test 3a "replay failed open(O_DIRECTORY)"
 148
 149 test_3b() {
 150     replay_barrier mds1
 151 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 152     do_facet mds "sysctl -w lustre.fail_loc=0x80000114"
 153     touch $DIR/$tfile
 154     do_facet mds "sysctl -w lustre.fail_loc=0"
 155     fail mds1
 156     $CHECKSTAT -t file $DIR/$tfile && return 2
 157     return 0
 158 }
 159 run_test 3b "replay failed open -ENOMEM"
 160
 161 test_3c() {
 162     replay_barrier mds1
 163 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 164     do_facet mds "sysctl -w lustre.fail_loc=0x80000128"
 165     touch $DIR/$tfile
 166     do_facet mds "sysctl -w lustre.fail_loc=0"
 167     fail mds1
 168
 169     $CHECKSTAT -t file $DIR/$tfile && return 2
 170     return 0
 171 }
 172 run_test 3c "replay failed open -ENOMEM"
 173
 174 test_4() {
 175     replay_barrier mds1
 176     for i in `seq 10`; do
 177         echo "tag-$i" > $DIR/$tfile-$i
 178     done
 179     fail mds1
 180     for i in `seq 10`; do
 181       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 182     done
 183 }
 184 run_test 4 "|x| 10 open(O_CREAT)s"
 185
 186 test_4b() {
 187     replay_barrier mds1
 188     rm -rf $DIR/$tfile-*
 189     fail mds1
 190     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 191 }
 192 run_test 4b "|x| rm 10 files"
 193
 194 # The idea is to get past the first block of precreated files on both
 195 # osts, and then replay.
 196 test_5() {
 197     replay_barrier mds1
 198     for i in `seq 220`; do
 199         echo "tag-$i" > $DIR/$tfile-$i
 200     done
 201     fail mds1
 202     for i in `seq 220`; do
 203       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
 204     done
 205     rm -rf $DIR/$tfile-*
 206     sleep 3
 207     # waiting for commitment of removal
 208 }
 209 run_test 5 "|x| 220 open(O_CREAT)"
 210
 211
 212 test_6() {
 213     replay_barrier mds1
 214     mkdir $DIR/$tdir
 215     mcreate $DIR/$tdir/$tfile
 216     fail mds1
 217     $CHECKSTAT -t dir $DIR/$tdir || return 1
 218     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 219     sleep 2
 220     # waiting for log process thread
 221 }
 222 run_test 6 "mkdir + contained create"
 223
 224 test_6b() {
 225     replay_barrier mds1
 226     rm -rf $DIR/$tdir
 227     fail mds1
 228     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 229 }
 230 run_test 6b "|X| rmdir"
 231
 232 test_7() {
 233     mkdir $DIR/$tdir
 234     replay_barrier mds1
 235     mcreate $DIR/$tdir/$tfile
 236     fail mds1
 237     $CHECKSTAT -t dir $DIR/$tdir || return 1
 238     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 239     rm -fr $DIR/$tdir
 240 }
 241 run_test 7 "mkdir |X| contained create"
 242
 243 test_8() {
 244     replay_barrier mds1
 245     multiop $DIR/$tfile mo_c &
 246     MULTIPID=$!
 247     sleep 1
 248     fail mds1
 249     ls $DIR/$tfile
 250     $CHECKSTAT -t file $DIR/$tfile || return 1
 251     kill -USR1 $MULTIPID || return 2
 252     wait $MULTIPID || return 3
 253     rm $DIR/$tfile
 254 }
 255 run_test 8 "creat open |X| close"
 256
 257 test_9() {
 258     replay_barrier mds1
 259     mcreate $DIR/$tfile
 260     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 261     fail mds1
 262     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 263
 264     echo " old_inum == $old_inum, new_inum == $new_inum"
 265     if [ $old_inum -eq $new_inum  ] ;
 266     then
 267         echo " old_inum and new_inum match"
 268     else
 269         echo "!!!! old_inum and new_inum NOT match"
 270         return 1
 271     fi
 272     rm $DIR/$tfile
 273 }
 274 run_test 9  "|X| create (same inum/gen)"
 275
 276 test_10() {
 277     mcreate $DIR/$tfile
 278     replay_barrier mds1
 279     mv $DIR/$tfile $DIR/$tfile-2
 280     rm -f $DIR/$tfile
 281     fail mds1
 282
 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 || sleep 1 && 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
 960 test_48() {
 961     createmany -o $DIR/${tfile}- 100
 962     $CHECKSTAT $DIR/${tfile}-99 || return 1
 963     mds_evict_client
 964     df $MOUNT || df $MOUNT || return 2
 965     sleep 1
 966     $CHECKSTAT $DIR/${tfile}-99 || return 3
 967
 968     dmesg -c >/dev/null
 969     replay_barrier mds1
 970     fail mds1
 971     unlinkmany $DIR/${tfile}- 100 || return 4
 972     if dmesg | grep "back in time"; then
 973         echo "server went back in time!"
 974         return 5
 975     fi
 976     return 0
 977 }
 978 run_test 48 "Don't lose transno when client is evicted (2525)"
 979
 980 # b=3550 - replay of unlink
 981 test_49() {
 982     replay_barrier mds1
 983     createmany -o $DIR/$tfile-%d 400 || return 1
 984     unlinkmany $DIR/$tfile-%d 0 400 || return 2
 985     fail mds1
 986     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
 987 }
 988 run_test 49 "re-write records to llog as written during fail"
 989
 990 test_50() {
 991     local osc_dev=`$LCTL device_list | \
 992                awk '(/ost_svc_mds1_svc/){print $4}' `
 993     $LCTL --device %$osc_dev recover &&  $LCTL --device %$osc_dev recover
 994     # give the mds_lov_sync threads a chance to run
 995     sleep 5
 996 }
 997 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
 998
 999 # b3764 timed out lock replay
1000 test_52() {
1001     touch $DIR/$tfile
1002     cancel_lru_locks MDC
1003
1004     multiop $DIR/$tfile s
1005     replay_barrier mds1
1006     do_facet mds1 "sysctl -w lustre.fail_loc=0x8000030c"
1007     fail mds1
1008     do_facet mds1 "sysctl -w lustre.fail_loc=0x0"
1009
1010     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
1011 }
1012 run_test 52 "time out lock replay (3764)"
1013
1014 equals_msg test complete, cleaning up
1015 $CLEANUP
1016