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 # 46 - The MDS will always have to force close the cached opens
  22 ALWAYS_EXCEPT="46"
  23
  24 if [ `using_krb5_sec $SECURITY` == 'n' ] ; then
  25     ALWAYS_EXCEPT="0c $ALWAYS_EXCEPT"
  26 fi
  27
  28
  29 gen_config() {
  30     rm -f $XMLCONFIG
  31
  32     if [ "$MDSCOUNT" -gt 1 ]; then
  33         add_lmv lmv1_svc
  34         for mds in `mds_list`; do
  35             MDSDEV=$TMP/${mds}-`hostname`
  36             add_mds $mds --dev $MDSDEV --size $MDSSIZE --lmv lmv1_svc
  37         done
  38         add_lov_to_lmv lov1 lmv1_svc --stripe_sz $STRIPE_BYTES \
  39             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  40         MDS=lmv1
  41     else
  42         add_mds $SINGLEMDS --dev $MDSDEV --size $MDSSIZE
  43         add_lov lov1 $SINGLEMDS --stripe_sz $STRIPE_BYTES \
  44             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  45         MDS=$SINGLEMDS
  46     fi
  47
  48     add_ost ost --lov lov1 --dev $OSTDEV --size $OSTSIZE
  49     add_ost ost2 --lov lov1 --dev ${OSTDEV}-2 --size $OSTSIZE
  50     add_client client $MDS --lov lov1 --path $MOUNT
  51 }
  52
  53 build_test_filter
  54
  55 cleanup() {
  56     # make sure we are using the primary MDS, so the config log will
  57     # be able to clean up properly.
  58     activemds=`facet_active $SINGLEMDS`
  59     if [ $activemds != "$SINGLEMDS" ]; then
  60         fail $SINGLEMDS
  61     fi
  62     zconf_umount `hostname` $MOUNT
  63     for mds in `mds_list`; do
  64         stop $mds ${FORCE} $MDSLCONFARGS
  65     done
  66     stop ost2 ${FORCE} --dump cleanup.log
  67     stop ost ${FORCE} --dump cleanup.log
  68     stop_lgssd
  69     stop_lsvcgssd
  70 }
  71
  72 if [ "$ONLY" == "cleanup" ]; then
  73     sysctl -w portals.debug=0 || true
  74     cleanup
  75     exit
  76 fi
  77
  78 SETUP=${SETUP:-"setup"}
  79 CLEANUP=${CLEANUP:-"cleanup"}
  80
  81 setup() {
  82     gen_config
  83
  84     start_krb5_kdc || exit 1
  85     start_lsvcgssd || exit 2
  86     start_lgssd || exit 3
  87     start ost --reformat $OSTLCONFARGS
  88     start ost2 --reformat $OSTLCONFARGS
  89     [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  90     for mds in `mds_list`; do
  91         start $mds --reformat $MDSLCONFARGS
  92     done
  93     grep " $MOUNT " /proc/mounts || zconf_mount `hostname` $MOUNT
  94 }
  95
  96 $SETUP
  97
  98 if [ "$ONLY" == "setup" ]; then
  99     exit 0
 100 fi
 101
 102 mkdir -p $DIR
 103
 104 test_0() {
 105     replay_barrier $SINGLEMDS
 106     fail $SINGLEMDS
 107 }
 108 run_test 0 "empty replay"
 109
 110 test_0b() {
 111     # this test attempts to trigger a race in the precreation code,
 112     # and must run before any other objects are created on the filesystem
 113     fail ost
 114     createmany -o $DIR/$tfile 20 || return 1
 115     unlinkmany $DIR/$tfile 20 || return 2
 116 }
 117 run_test 0b "ensure object created after recover exists. (3284)"
 118
 119 test_0c() {
 120     if [ `using_krb5_sec $SECURITY` == 'n' ] ; then
 121         echo "Skip 0c in non-gss mode"
 122         return 0
 123     fi
 124     # drop gss error notification
 125     replay_barrier $SINGLEMDS
 126     fail_drop $SINGLEMDS 0x760
 127
 128     # drop gss init request
 129     replay_barrier $SINGLEMDS
 130     fail_drop $SINGLEMDS 0x780
 131 }
 132 run_test 0c "empty replay with gss init failures"
 133
 134 test_1() {
 135     replay_barrier $SINGLEMDS
 136     mcreate $DIR/$tfile
 137     fail $SINGLEMDS
 138     $CHECKSTAT -t file $DIR/$tfile || return 1
 139     rm $DIR/$tfile
 140 }
 141 run_test 1 "simple create"
 142
 143 test_2a() {
 144     replay_barrier $SINGLEMDS
 145     touch $DIR/$tfile
 146     fail $SINGLEMDS
 147     $CHECKSTAT -t file $DIR/$tfile || return 1
 148     rm $DIR/$tfile
 149 }
 150 run_test 2a "touch"
 151
 152 test_2b() {
 153     ./mcreate $DIR/$tfile
 154     replay_barrier $SINGLEMDS
 155     touch $DIR/$tfile
 156     fail $SINGLEMDS
 157     $CHECKSTAT -t file $DIR/$tfile || return 1
 158     rm $DIR/$tfile
 159 }
 160 run_test 2b "touch"
 161
 162 test_3a() {
 163     replay_barrier $SINGLEMDS
 164     mcreate $DIR/$tfile
 165     o_directory $DIR/$tfile
 166     fail $SINGLEMDS
 167     $CHECKSTAT -t file $DIR/$tfile || return 2
 168     rm $DIR/$tfile
 169 }
 170 run_test 3a "replay failed open(O_DIRECTORY)"
 171
 172 test_3b() {
 173     replay_barrier $SINGLEMDS
 174 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 175     do_facet mds "sysctl -w lustre.fail_loc=0x80000114"
 176     touch $DIR/$tfile
 177     do_facet mds "sysctl -w lustre.fail_loc=0"
 178     fail $SINGLEMDS
 179     $CHECKSTAT -t file $DIR/$tfile && return 2
 180     return 0
 181 }
 182 run_test 3b "replay failed open -ENOMEM"
 183
 184 test_3c() {
 185     replay_barrier $SINGLEMDS
 186 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 187     do_facet mds "sysctl -w lustre.fail_loc=0x80000128"
 188     touch $DIR/$tfile
 189     do_facet mds "sysctl -w lustre.fail_loc=0"
 190     fail $SINGLEMDS
 191
 192     $CHECKSTAT -t file $DIR/$tfile && return 2
 193     return 0
 194 }
 195 run_test 3c "replay failed open -ENOMEM"
 196
 197 test_4() {
 198     replay_barrier $SINGLEMDS
 199     for i in `seq 10`; do
 200         echo "tag-$i" > $DIR/$tfile-$i
 201     done
 202     fail $SINGLEMDS
 203     for i in `seq 10`; do
 204       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 205     done
 206 }
 207 run_test 4 "|x| 10 open(O_CREAT)s"
 208
 209 test_4b() {
 210     replay_barrier $SINGLEMDS
 211     rm -rf $DIR/$tfile-*
 212     fail $SINGLEMDS
 213     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 214 }
 215 run_test 4b "|x| rm 10 files"
 216
 217 # The idea is to get past the first block of precreated files on both
 218 # osts, and then replay.
 219 test_5() {
 220     replay_barrier $SINGLEMDS
 221     for i in `seq 220`; do
 222         echo "tag-$i" > $DIR/$tfile-$i
 223     done
 224     fail $SINGLEMDS
 225     for i in `seq 220`; do
 226       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
 227     done
 228     rm -rf $DIR/$tfile-*
 229     sleep 3
 230     # waiting for commitment of removal
 231 }
 232 run_test 5 "|x| 220 open(O_CREAT)"
 233
 234
 235 test_6() {
 236     replay_barrier $SINGLEMDS
 237     mkdir $DIR/$tdir
 238     mcreate $DIR/$tdir/$tfile
 239     fail $SINGLEMDS
 240     $CHECKSTAT -t dir $DIR/$tdir || return 1
 241     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 242     sleep 2
 243     # waiting for log process thread
 244 }
 245 run_test 6 "mkdir + contained create"
 246
 247 test_6b() {
 248     replay_barrier $SINGLEMDS
 249     rm -rf $DIR/$tdir
 250     fail $SINGLEMDS
 251     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 252 }
 253 run_test 6b "|X| rmdir"
 254
 255 test_7() {
 256     mkdir $DIR/$tdir
 257     replay_barrier $SINGLEMDS
 258     mcreate $DIR/$tdir/$tfile
 259     fail $SINGLEMDS
 260     $CHECKSTAT -t dir $DIR/$tdir || return 1
 261     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 262     rm -fr $DIR/$tdir
 263 }
 264 run_test 7 "mkdir |X| contained create"
 265
 266 test_8() {
 267     replay_barrier $SINGLEMDS
 268     multiop $DIR/$tfile mo_c &
 269     MULTIPID=$!
 270     sleep 1
 271     fail $SINGLEMDS
 272     ls $DIR/$tfile
 273     $CHECKSTAT -t file $DIR/$tfile || return 1
 274     kill -USR1 $MULTIPID || return 2
 275     wait $MULTIPID || return 3
 276     rm $DIR/$tfile
 277 }
 278 run_test 8 "creat open |X| close"
 279
 280 test_9() {
 281     replay_barrier $SINGLEMDS
 282     mcreate $DIR/$tfile
 283     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 284     fail $SINGLEMDS
 285     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 286
 287     echo " old_inum == $old_inum, new_inum == $new_inum"
 288     if [ $old_inum -eq $new_inum  ] ;
 289     then
 290         echo " old_inum and new_inum match"
 291     else
 292         echo "!!!! old_inum and new_inum NOT match"
 293         return 1
 294     fi
 295     rm $DIR/$tfile
 296 }
 297 run_test 9  "|X| create (same inum/gen)"
 298
 299 test_10() {
 300     mcreate $DIR/$tfile
 301     replay_barrier $SINGLEMDS
 302     mv $DIR/$tfile $DIR/$tfile-2
 303     rm -f $DIR/$tfile
 304     fail $SINGLEMDS
 305
 306     $CHECKSTAT $DIR/$tfile && return 1
 307     $CHECKSTAT $DIR/$tfile-2 || return 2
 308     rm $DIR/$tfile-2
 309     return 0
 310 }
 311 run_test 10 "create |X| rename unlink"
 312
 313 test_11() {
 314     mcreate $DIR/$tfile
 315     echo "old" > $DIR/$tfile
 316     mv $DIR/$tfile $DIR/$tfile-2
 317     replay_barrier $SINGLEMDS
 318     echo "new" > $DIR/$tfile
 319     grep new $DIR/$tfile
 320     grep old $DIR/$tfile-2
 321     fail $SINGLEMDS
 322     grep new $DIR/$tfile || return 1
 323     grep old $DIR/$tfile-2 || return 2
 324 }
 325 run_test 11 "create open write rename |X| create-old-name read"
 326
 327 test_12() {
 328     mcreate $DIR/$tfile
 329     multiop $DIR/$tfile o_tSc &
 330     pid=$!
 331     # give multiop a chance to open
 332     sleep 1
 333     rm -f $DIR/$tfile
 334     replay_barrier $SINGLEMDS
 335     kill -USR1 $pid
 336     wait $pid || return 1
 337
 338     fail $SINGLEMDS
 339     [ -e $DIR/$tfile ] && return 2
 340     return 0
 341 }
 342 run_test 12 "open, unlink |X| close"
 343
 344
 345 # 1777 - replay open after committed chmod that would make
 346 #        a regular open a failure
 347 test_13() {
 348     mcreate $DIR/$tfile
 349     multiop $DIR/$tfile O_wc &
 350     pid=$!
 351     # give multiop a chance to open
 352     sleep 1
 353     chmod 0 $DIR/$tfile
 354     $CHECKSTAT -p 0 $DIR/$tfile
 355     replay_barrier $SINGLEMDS
 356     fail $SINGLEMDS
 357     kill -USR1 $pid
 358     wait $pid || return 1
 359
 360     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
 361     return 0
 362 }
 363 run_test 13 "open chmod 0 |x| write close"
 364
 365 test_14() {
 366     multiop $DIR/$tfile O_tSc &
 367     pid=$!
 368     # give multiop a chance to open
 369     sleep 1
 370     rm -f $DIR/$tfile
 371     replay_barrier $SINGLEMDS
 372     kill -USR1 $pid || return 1
 373     wait $pid || return 2
 374
 375     fail $SINGLEMDS
 376     [ -e $DIR/$tfile ] && return 3
 377     return 0
 378 }
 379 run_test 14 "open(O_CREAT), unlink |X| close"
 380
 381 test_15() {
 382     multiop $DIR/$tfile O_tSc &
 383     pid=$!
 384     # give multiop a chance to open
 385     sleep 1
 386     rm -f $DIR/$tfile
 387     replay_barrier $SINGLEMDS
 388     touch $DIR/g11 || return 1
 389     kill -USR1 $pid
 390     wait $pid || return 2
 391
 392     fail $SINGLEMDS
 393     [ -e $DIR/$tfile ] && return 3
 394     touch $DIR/h11 || return 4
 395     return 0
 396 }
 397 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 398
 399
 400 test_16() {
 401     replay_barrier $SINGLEMDS
 402     mcreate $DIR/$tfile
 403     munlink $DIR/$tfile
 404     mcreate $DIR/$tfile-2
 405     fail $SINGLEMDS
 406     [ -e $DIR/$tfile ] && return 1
 407     [ -e $DIR/$tfile-2 ] || return 2
 408     munlink $DIR/$tfile-2 || return 3
 409 }
 410 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 411
 412 test_17() {
 413     replay_barrier $SINGLEMDS
 414     multiop $DIR/$tfile O_c &
 415     pid=$!
 416     # give multiop a chance to open
 417     sleep 1
 418     fail $SINGLEMDS
 419     kill -USR1 $pid || return 1
 420     wait $pid || return 2
 421     $CHECKSTAT -t file $DIR/$tfile || return 3
 422     rm $DIR/$tfile
 423 }
 424 run_test 17 "|X| open(O_CREAT), |replay| close"
 425
 426 test_18() {
 427     replay_barrier $SINGLEMDS
 428     multiop $DIR/$tfile O_tSc &
 429     pid=$!
 430     # give multiop a chance to open
 431     sleep 1
 432     rm -f $DIR/$tfile
 433     touch $DIR/$tfile-2 || return 1
 434     echo "pid: $pid will close"
 435     kill -USR1 $pid
 436     wait $pid || return 2
 437
 438     fail $SINGLEMDS
 439     [ -e $DIR/$tfile ] && return 3
 440     [ -e $DIR/$tfile-2 ] || return 4
 441     # this touch frequently fails
 442     touch $DIR/$tfile-3 || return 5
 443     munlink $DIR/$tfile-2 || return 6
 444     munlink $DIR/$tfile-3 || return 7
 445     return 0
 446 }
 447 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
 448
 449 # bug 1855 (a simpler form of test_11 above)
 450 test_19() {
 451     replay_barrier $SINGLEMDS
 452     mcreate $DIR/$tfile
 453     echo "old" > $DIR/$tfile
 454     mv $DIR/$tfile $DIR/$tfile-2
 455     grep old $DIR/$tfile-2
 456     fail $SINGLEMDS
 457     grep old $DIR/$tfile-2 || return 2
 458 }
 459 run_test 19 "|X| mcreate, open, write, rename "
 460
 461 test_20() {
 462     replay_barrier $SINGLEMDS
 463     multiop $DIR/$tfile O_tSc &
 464     pid=$!
 465     # give multiop a chance to open
 466     sleep 1
 467     rm -f $DIR/$tfile
 468
 469     fail $SINGLEMDS
 470     kill -USR1 $pid
 471     wait $pid || return 1
 472     [ -e $DIR/$tfile ] && return 2
 473     return 0
 474 }
 475 run_test 20 "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 476
 477 test_21() {
 478     replay_barrier $SINGLEMDS
 479     multiop $DIR/$tfile O_tSc &
 480     pid=$!
 481     # give multiop a chance to open
 482     sleep 1
 483     rm -f $DIR/$tfile
 484     touch $DIR/g11 || return 1
 485
 486     fail $SINGLEMDS
 487     kill -USR1 $pid
 488     wait $pid || return 2
 489     [ -e $DIR/$tfile ] && return 3
 490     touch $DIR/h11 || return 4
 491     return 0
 492 }
 493 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 494
 495 test_22() {
 496     multiop $DIR/$tfile O_tSc &
 497     pid=$!
 498     # give multiop a chance to open
 499     sleep 1
 500
 501     replay_barrier $SINGLEMDS
 502     rm -f $DIR/$tfile
 503
 504     fail $SINGLEMDS
 505     kill -USR1 $pid
 506     wait $pid || return 1
 507     [ -e $DIR/$tfile ] && return 2
 508     return 0
 509 }
 510 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
 511
 512 test_23() {
 513     multiop $DIR/$tfile O_tSc &
 514     pid=$!
 515     # give multiop a chance to open
 516     sleep 1
 517
 518     replay_barrier $SINGLEMDS
 519     rm -f $DIR/$tfile
 520     touch $DIR/g11 || return 1
 521
 522     fail $SINGLEMDS
 523     kill -USR1 $pid
 524     wait $pid || return 2
 525     [ -e $DIR/$tfile ] && return 3
 526     touch $DIR/h11 || return 4
 527     return 0
 528 }
 529 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 530
 531 test_24() {
 532     multiop $DIR/$tfile O_tSc &
 533     pid=$!
 534     # give multiop a chance to open
 535     sleep 1
 536
 537     replay_barrier $SINGLEMDS
 538     fail $SINGLEMDS
 539     rm -f $DIR/$tfile
 540     kill -USR1 $pid
 541     wait $pid || return 1
 542     [ -e $DIR/$tfile ] && return 2
 543     return 0
 544 }
 545 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 546
 547 test_25() {
 548     multiop $DIR/$tfile O_tSc &
 549     pid=$!
 550     # give multiop a chance to open
 551     sleep 1
 552     rm -f $DIR/$tfile
 553
 554     replay_barrier $SINGLEMDS
 555     fail $SINGLEMDS
 556     kill -USR1 $pid
 557     wait $pid || return 1
 558     [ -e $DIR/$tfile ] && return 2
 559     return 0
 560 }
 561 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 562
 563 test_26() {
 564     replay_barrier $SINGLEMDS
 565     multiop $DIR/$tfile-1 O_tSc &
 566     pid1=$!
 567     multiop $DIR/$tfile-2 O_tSc &
 568     pid2=$!
 569     # give multiop a chance to open
 570     sleep 1
 571     rm -f $DIR/$tfile-1
 572     rm -f $DIR/$tfile-2
 573     kill -USR1 $pid2
 574     wait $pid2 || return 1
 575
 576     fail $SINGLEMDS
 577     kill -USR1 $pid1
 578     wait $pid1 || return 2
 579     [ -e $DIR/$tfile-1 ] && return 3
 580     [ -e $DIR/$tfile-2 ] && return 4
 581     return 0
 582 }
 583 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 584
 585 test_27() {
 586     replay_barrier $SINGLEMDS
 587     multiop $DIR/$tfile-1 O_tSc &
 588     pid1=$!
 589     multiop $DIR/$tfile-2 O_tSc &
 590     pid2=$!
 591     # give multiop a chance to open
 592     sleep 1
 593     rm -f $DIR/$tfile-1
 594     rm -f $DIR/$tfile-2
 595
 596     fail $SINGLEMDS
 597     kill -USR1 $pid1
 598     wait $pid1 || return 1
 599     kill -USR1 $pid2
 600     wait $pid2 || return 2
 601     [ -e $DIR/$tfile-1 ] && return 3
 602     [ -e $DIR/$tfile-2 ] && return 4
 603     return 0
 604 }
 605 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 606
 607 test_28() {
 608     multiop $DIR/$tfile-1 O_tSc &
 609     pid1=$!
 610     multiop $DIR/$tfile-2 O_tSc &
 611     pid2=$!
 612     # give multiop a chance to open
 613     sleep 1
 614     replay_barrier $SINGLEMDS
 615     rm -f $DIR/$tfile-1
 616     rm -f $DIR/$tfile-2
 617     kill -USR1 $pid2
 618     wait $pid2 || return 1
 619
 620     fail $SINGLEMDS
 621     kill -USR1 $pid1
 622     wait $pid1 || return 2
 623     [ -e $DIR/$tfile-1 ] && return 3
 624     [ -e $DIR/$tfile-2 ] && return 4
 625     return 0
 626 }
 627 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 628
 629 test_29() {
 630     multiop $DIR/$tfile-1 O_tSc &
 631     pid1=$!
 632     multiop $DIR/$tfile-2 O_tSc &
 633     pid2=$!
 634     # give multiop a chance to open
 635     sleep 1
 636     replay_barrier $SINGLEMDS
 637     rm -f $DIR/$tfile-1
 638     rm -f $DIR/$tfile-2
 639
 640     fail $SINGLEMDS
 641     kill -USR1 $pid1
 642     wait $pid1 || return 1
 643     kill -USR1 $pid2
 644     wait $pid2 || return 2
 645     [ -e $DIR/$tfile-1 ] && return 3
 646     [ -e $DIR/$tfile-2 ] && return 4
 647     return 0
 648 }
 649 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 650
 651 test_30() {
 652     multiop $DIR/$tfile-1 O_tSc &
 653     pid1=$!
 654     multiop $DIR/$tfile-2 O_tSc &
 655     pid2=$!
 656     # give multiop a chance to open
 657     sleep 1
 658     rm -f $DIR/$tfile-1
 659     rm -f $DIR/$tfile-2
 660
 661     replay_barrier $SINGLEMDS
 662     fail $SINGLEMDS
 663     kill -USR1 $pid1
 664     wait $pid1 || return 1
 665     kill -USR1 $pid2
 666     wait $pid2 || return 2
 667     [ -e $DIR/$tfile-1 ] && return 3
 668     [ -e $DIR/$tfile-2 ] && return 4
 669     return 0
 670 }
 671 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 672
 673 test_31() {
 674     multiop $DIR/$tfile-1 O_tSc &
 675     pid1=$!
 676     multiop $DIR/$tfile-2 O_tSc &
 677     pid2=$!
 678     # give multiop a chance to open
 679     sleep 1
 680     rm -f $DIR/$tfile-1
 681
 682     replay_barrier $SINGLEMDS
 683     rm -f $DIR/$tfile-2
 684     fail $SINGLEMDS
 685     kill -USR1 $pid1
 686     wait $pid1 || return 1
 687     kill -USR1 $pid2
 688     wait $pid2 || return 2
 689     [ -e $DIR/$tfile-1 ] && return 3
 690     [ -e $DIR/$tfile-2 ] && return 4
 691     return 0
 692 }
 693 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 694
 695 # tests for bug 2104; completion without crashing is success.  The close is
 696 # stale, but we always return 0 for close, so the app never sees it.
 697 test_32() {
 698     multiop $DIR/$tfile O_c &
 699     pid1=$!
 700     multiop $DIR/$tfile O_c &
 701     pid2=$!
 702     # give multiop a chance to open.
 703     # 1 second is not enough, I increased it to 5, however in ideal word
 704     # I should have to wait for open finish in more smart manner. --umka
 705     sleep 5
 706     mds_evict_client
 707     df $MOUNT || sleep 1 && df $MOUNT || return 1
 708     kill -USR1 $pid1
 709     kill -USR1 $pid2
 710     sleep 5
 711     return 0
 712 }
 713 run_test 32 "close() notices client eviction; close() after client eviction"
 714
 715 # Abort recovery before client complete
 716 test_33() {
 717     replay_barrier $SINGLEMDS
 718     touch $DIR/$tfile
 719     fail_abort $SINGLEMDS
 720     # this file should be gone, because the replay was aborted
 721     $CHECKSTAT -t file $DIR/$tfile && return 1
 722     return 0
 723 }
 724 run_test 33 "abort recovery before client does replay"
 725
 726 test_34() {
 727     multiop $DIR/$tfile O_c &
 728     pid=$!
 729     # give multiop a chance to open
 730     sleep 1
 731     rm -f $DIR/$tfile
 732
 733     replay_barrier $SINGLEMDS
 734     fail_abort $SINGLEMDS
 735     kill -USR1 $pid
 736     [ -e $DIR/$tfile ] && return 1
 737     sync
 738     return 0
 739 }
 740 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 741
 742 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 743 test_35() {
 744     touch $DIR/$tfile
 745
 746 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 747     do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
 748     rm -f $DIR/$tfile &
 749     sleep 1
 750     sync
 751     sleep 1
 752     # give a chance to remove from MDS
 753     fail_abort $SINGLEMDS
 754     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
 755 }
 756 run_test 35 "test recovery from llog for unlink op"
 757
 758 # b=2432 resent cancel after replay uses wrong cookie,
 759 # so don't resend cancels
 760 test_36() {
 761     replay_barrier $SINGLEMDS
 762     touch $DIR/$tfile
 763     checkstat $DIR/$tfile
 764     facet_failover $SINGLEMDS
 765     cancel_lru_locks MDC
 766     if dmesg | grep "unknown lock cookie"; then
 767         echo "cancel after replay failed"
 768         return 1
 769     fi
 770 }
 771 run_test 36 "don't resend cancel"
 772
 773 # b=2368
 774 # directory orphans can't be unlinked from PENDING directory
 775 test_37() {
 776     rmdir $DIR/$tfile 2>/dev/null
 777     multiop $DIR/$tfile dD_c &
 778     pid=$!
 779     # give multiop a chance to open
 780     sleep 1
 781     rmdir $DIR/$tfile
 782
 783     replay_barrier $SINGLEMDS
 784     # clear the dmesg buffer so we only see errors from this recovery
 785     dmesg -c >/dev/null
 786     fail_abort $SINGLEMDS
 787     kill -USR1 $pid
 788     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
 789     sync
 790     return 0
 791 }
 792 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 793
 794 test_38() {
 795     createmany -o $DIR/$tfile-%d 800
 796     unlinkmany $DIR/$tfile-%d 0 400
 797     replay_barrier $SINGLEMDS
 798     fail $SINGLEMDS
 799     unlinkmany $DIR/$tfile-%d 400 400
 800     sleep 2
 801     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 802 }
 803 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 804
 805 test_39() {
 806     createmany -o $DIR/$tfile-%d 800
 807     replay_barrier $SINGLEMDS
 808     unlinkmany $DIR/$tfile-%d 0 400
 809     fail $SINGLEMDS
 810     unlinkmany $DIR/$tfile-%d 400 400
 811     sleep 2
 812     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 813 }
 814 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 815
 816 count_ost_writes() {
 817         cat /proc/fs/lustre/osc/*/stats |
 818             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
 819 }
 820
 821 #b=2477,2532
 822 test_40(){
 823     $LCTL mark multiop $MOUNT/$tfile OS_c
 824     multiop $MOUNT/$tfile OS_c  &
 825     PID=$!
 826     writeme -s $MOUNT/${tfile}-2 &
 827     WRITE_PID=$!
 828     sleep 1
 829     facet_failover $SINGLEMDS
 830 #define OBD_FAIL_MDS_CONNECT_NET         0x117
 831     do_facet mds "sysctl -w lustre.fail_loc=0x80000117"
 832     kill -USR1 $PID
 833     stat1=`count_ost_writes`
 834     sleep $TIMEOUT
 835     stat2=`count_ost_writes`
 836     echo "$stat1, $stat2"
 837     if [ $stat1 -lt $stat2 ]; then
 838        echo "writes continuing during recovery"
 839        RC=0
 840     else
 841        echo "writes not continuing during recovery, bug 2477"
 842        RC=4
 843     fi
 844     echo "waiting for writeme $WRITE_PID"
 845     kill $WRITE_PID
 846     wait $WRITE_PID
 847
 848     echo "waiting for multiop $PID"
 849     wait $PID || return 2
 850     do_facet client munlink $MOUNT/$tfile  || return 3
 851     do_facet client munlink $MOUNT/${tfile}-2  || return 3
 852     return $RC
 853 }
 854 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 855
 856
 857 #b=2814
 858 # make sure that a read to one osc doesn't try to double-unlock its page just
 859 # because another osc is invalid.  trigger_group_io used to mistakenly return
 860 # an error if any oscs were invalid even after having successfully put rpcs
 861 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 862 # the page, guarnateeing that the unlock from the RPC completion would
 863 # assert on trying to unlock the unlocked page.
 864 test_41() {
 865     local f=$MOUNT/$tfile
 866     # make sure the start of the file is ost1
 867     lfs setstripe $f $((128 * 1024)) 0 0
 868     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
 869     cancel_lru_locks OSC
 870     # fail ost2 and read from ost1
 871     local osc2_dev=`$LCTL device_list | \
 872                 awk '(/ost2.*client_facet/){print $4}' `
 873     $LCTL --device %$osc2_dev deactivate
 874     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
 875     $LCTL --device %$osc2_dev activate
 876     return 0
 877 }
 878 run_test 41 "read from a valid osc while other oscs are invalid"
 879
 880 # test MDS recovery after ost failure
 881 test_42() {
 882     blocks=`df $MOUNT | tail -n 1 | awk '{ print $1 }'`
 883     createmany -o $DIR/$tfile-%d 800
 884     replay_barrier ost
 885     unlinkmany $DIR/$tfile-%d 0 400
 886     facet_failover ost
 887
 888     # osc is evicted, fs is smaller
 889     blocks_after=`df $MOUNT | tail -n 1 | awk '{ print $1 }'`
 890     [ $blocks_after -lt $blocks ] || return 1
 891     echo wait for MDS to timeout and recover
 892     sleep $((TIMEOUT * 2))
 893     unlinkmany $DIR/$tfile-%d 400 400
 894     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
 895 }
 896 run_test 42 "recovery after ost failure"
 897
 898 # b=2530
 899 # timeout in MDS/OST recovery RPC will LBUG MDS
 900 test_43() {
 901     replay_barrier $SINGLEMDS
 902
 903     # OBD_FAIL_OST_CREATE_NET 0x204
 904     do_facet ost "sysctl -w lustre.fail_loc=0x80000204"
 905     facet_failover $SINGLEMDS
 906     df $MOUNT || return 1
 907     sleep 10
 908     do_facet ost "sysctl -w lustre.fail_loc=0"
 909
 910     return 0
 911 }
 912 run_test 43 "mds osc import failure during recovery; don't LBUG"
 913
 914 test_44() {
 915     mdcdev=`awk '/mds_svc_MNT/ {print $1}' < /proc/fs/lustre/devices`
 916     do_facet mds "sysctl -w lustre.fail_loc=0x80000701"
 917     $LCTL --device $mdcdev recover
 918     df $MOUNT
 919     do_facet mds "sysctl -w lustre.fail_loc=0"
 920     return 0
 921 }
 922 run_test 44 "race in target handle connect"
 923
 924 # Handle failed close
 925 test_45() {
 926     mdcdev=`awk '/mds_svc_MNT/ {print $1}' < /proc/fs/lustre/devices`
 927     $LCTL --device $mdcdev recover
 928
 929     multiop $DIR/$tfile O_c &
 930     pid=$!
 931     sleep 1
 932
 933     # This will cause the CLOSE to fail before even
 934     # allocating a reply buffer
 935     $LCTL --device $mdcdev deactivate
 936
 937     # try the close
 938     kill -USR1 $pid
 939     wait $pid || return 1
 940
 941     $LCTL --device $mdcdev activate
 942     sleep 1
 943
 944     $CHECKSTAT -t file $DIR/$tfile || return 2
 945     return 0
 946 }
 947 run_test 45 "Handle failed close"
 948
 949 test_46() {
 950     dmesg -c >/dev/null
 951     drop_reply "touch $DIR/$tfile"
 952     fail $SINGLEMDS
 953     # ironically, the previous test, 45, will cause a real forced close,
 954     # so just look for one for this test
 955     dmesg | grep -i "force closing client file handle for $tfile" && return 1
 956     return 0
 957 }
 958 run_test 46 "Don't leak file handle after open resend (3325)"
 959
 960 # b=2824
 961 test_47() {
 962
 963     # create some files to make sure precreate has been done on all
 964     # OSTs. (just in case this test is run independently)
 965     createmany -o $DIR/$tfile 20  || return 1
 966
 967     # OBD_FAIL_OST_CREATE_NET 0x204
 968     fail ost
 969     do_facet ost "sysctl -w lustre.fail_loc=0x80000204"
 970     df $MOUNT || return 2
 971
 972     # let the MDS discover the OST failure, attempt to recover, fail
 973     # and recover again.
 974     sleep $((3 * TIMEOUT))
 975
 976     # Without 2824, this createmany would hang
 977     createmany -o $DIR/$tfile 20 || return 3
 978     unlinkmany $DIR/$tfile 20 || return 4
 979
 980     do_facet ost "sysctl -w lustre.fail_loc=0"
 981     return 0
 982 }
 983 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
 984
 985
 986 test_48() {
 987     createmany -o $DIR/${tfile}- 100
 988     $CHECKSTAT $DIR/${tfile}-99 || return 1
 989     mds_evict_client
 990     df $MOUNT || echo "first df failed"
 991     sleep 1
 992     df $MOUNT || return 2
 993     sleep 1
 994     $CHECKSTAT $DIR/${tfile}-99 || return 3
 995
 996     dmesg -c >/dev/null
 997     replay_barrier $SINGLEMDS
 998     fail $SINGLEMDS
 999     unlinkmany $DIR/${tfile}- 100 || return 4
1000     if dmesg | grep "back in time"; then
1001         echo "server went back in time!"
1002         return 5
1003     fi
1004     return 0
1005 }
1006 run_test 48 "Don't lose transno when client is evicted (2525)"
1007
1008 # b=3550 - replay of unlink
1009 test_49() {
1010     replay_barrier $SINGLEMDS
1011     createmany -o $DIR/$tfile-%d 400 || return 1
1012     unlinkmany $DIR/$tfile-%d 0 400 || return 2
1013     fail $SINGLEMDS
1014     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
1015 }
1016 run_test 49 "re-write records to llog as written during fail"
1017
1018 test_50() {
1019     local osc_dev=`$LCTL device_list | \
1020                awk '(/ost_svc_$SINGLEMDS_svc/){print $4}' `
1021     $LCTL --device %$osc_dev recover &&  $LCTL --device %$osc_dev recover
1022     # give the mds_lov_sync threads a chance to run
1023     sleep 5
1024 }
1025 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
1026
1027 # bug 3462 - simultaneous MDC requests
1028 test_51a() {
1029     replay_barrier_nodf $SINGLEMDS
1030     mkdir -p $DIR/${tdir}-1
1031     mkdir -p $DIR/${tdir}-2
1032     touch $DIR/${tdir}-2/f
1033     multiop $DIR/${tdir}-1/f O_c &
1034     pid=$!
1035     # give multiop a chance to open
1036     sleep 1
1037
1038     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000115"
1039     kill -USR1 $pid
1040     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1041     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 1
1042
1043     fail $SINGLEMDS
1044
1045     wait $pid || return 2
1046     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1047     rm -rf $DIR/${tdir}-*
1048 }
1049 run_test 51a "|X| close request while two MDC requests in flight"
1050
1051 test_51b() {
1052     replay_barrier_nodf $SINGLEMDS
1053     mkdir -p $DIR/$tdir-1
1054     mkdir -p $DIR/$tdir-2
1055     multiop $DIR/$tdir-1/f O_c &
1056     pid=$!
1057
1058     # give multiop a chance to open
1059     # 1 second seems to be not enough, we met already such a cases
1060     # --umka
1061     sleep 5
1062
1063     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000107"
1064     touch $DIR/${tdir}-2/f &
1065     usleep 500
1066     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1067
1068     kill -USR1 $pid
1069     wait $pid || return 1
1070
1071     fail $SINGLEMDS
1072
1073     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 2
1074     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 3
1075     rm -rf $DIR/${tdir}-*
1076 }
1077 run_test 51b "|X| open request while two MDC requests in flight"
1078
1079 test_51c() {
1080     replay_barrier_nodf $SINGLEMDS
1081     mkdir -p $DIR/${tdir}-1
1082     mkdir -p $DIR/${tdir}-2
1083     multiop $DIR/${tdir}-1/f O_c &
1084     pid=$!
1085     # give multiop a chance to open
1086     sleep 1
1087
1088     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000107"
1089     touch $DIR/${tdir}-2/f &
1090     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1091
1092     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000115"
1093     kill -USR1 $pid
1094     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1095
1096     fail $SINGLEMDS
1097
1098     wait $pid || return 1
1099     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 2
1100     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 3
1101     rm -rf $DIR/${tdir}-*
1102 }
1103 run_test 51c "|X| open request and close request while two MDC requests in flight"
1104
1105 test_51d() {
1106     replay_barrier_nodf $SINGLEMDS
1107     mkdir -p $DIR/${tdir}-1
1108     mkdir -p $DIR/${tdir}-2
1109     touch $DIR/${tdir}-2/f
1110     multiop $DIR/${tdir}-1/f O_c &
1111     pid=$!
1112     # give multiop a chance to open
1113     sleep 1
1114
1115     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000122"
1116     kill -USR1 $pid
1117     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1118     #$CHECKSTAT -t file $DIR/${tdir}-2/f || return 1
1119
1120     fail $SINGLEMDS
1121
1122     wait $pid || return 2
1123     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1124     rm -rf $DIR/${tdir}-*
1125 }
1126 run_test 51d "|X| close reply while two MDC requests in flight"
1127
1128 test_51e() {
1129     replay_barrier_nodf $SINGLEMDS
1130     mkdir -p $DIR/$tdir-1
1131     mkdir -p $DIR/$tdir-2
1132     multiop $DIR/$tdir-1/f O_c &
1133     pid=$!
1134     # give multiop a chance to open
1135     sleep 1
1136
1137     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000119"
1138     touch $DIR/${tdir}-2/f &
1139     usleep 500
1140     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1141
1142     kill -USR1 $pid
1143     wait $pid || return 1
1144
1145     fail $SINGLEMDS
1146
1147     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 2
1148     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 3
1149     rm -rf $DIR/${tdir}-*
1150 }
1151 run_test 51e "|X| open reply while two MDC requests in flight"
1152
1153 test_51f() {
1154     replay_barrier_nodf $SINGLEMDS
1155     mkdir -p $DIR/${tdir}-1
1156     mkdir -p $DIR/${tdir}-2
1157     multiop $DIR/${tdir}-1/f O_c &
1158     pid=$!
1159     # give multiop a chance to open
1160     sleep 1
1161
1162     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000119"
1163     touch $DIR/${tdir}-2/f &
1164     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1165
1166     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000122"
1167     kill -USR1 $pid
1168     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1169
1170     fail $SINGLEMDS
1171
1172     wait $pid || return 1
1173     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 2
1174     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 3
1175     rm -rf $DIR/${tdir}-*
1176 }
1177 run_test 51f "|X| open reply and close reply while two MDC requests in flight"
1178
1179 test_51g() {
1180     replay_barrier_nodf $SINGLEMDS
1181     mkdir -p $DIR/${tdir}-1
1182     mkdir -p $DIR/${tdir}-2
1183     multiop $DIR/${tdir}-1/f O_c &
1184     pid=$!
1185     # give multiop a chance to open
1186     sleep 1
1187
1188     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000119"
1189     touch $DIR/${tdir}-2/f &
1190     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1191
1192     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000115"
1193     kill -USR1 $pid
1194     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1195
1196     fail $SINGLEMDS
1197
1198     wait $pid || return 1
1199     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 2
1200     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 3
1201     rm -rf $DIR/${tdir}-*
1202 }
1203 run_test 51g "|X| open reply and close request while two MDC requests in flight"
1204
1205 test_51h() {
1206     replay_barrier_nodf $SINGLEMDS
1207     mkdir -p $DIR/${tdir}-1
1208     mkdir -p $DIR/${tdir}-2
1209     multiop $DIR/${tdir}-1/f O_c &
1210     pid=$!
1211     # give multio:wp a chance to open
1212     sleep 1
1213
1214     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000107"
1215     touch $DIR/${tdir}-2/f &
1216     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1217
1218     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000122"
1219     kill -USR1 $pid
1220     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1221
1222     fail $SINGLEMDS
1223
1224     wait $pid || return 1
1225     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 2
1226     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 3
1227     rm -rf $DIR/${tdir}-*
1228 }
1229 run_test 51h "|X| open request and close reply while two MDC requests in flight"
1230
1231 # b3764 timed out lock replay
1232 test_52() {
1233     touch $DIR/$tfile
1234     cancel_lru_locks MDC
1235
1236     multiop $DIR/$tfile s
1237     replay_barrier $SINGLEMDS
1238     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x8000030c"
1239     fail $SINGLEMDS
1240     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x0"
1241
1242     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
1243 }
1244 run_test 52 "time out lock replay (3764)"
1245
1246 test_53() {
1247     replay_barrier_nodf $SINGLEMDS
1248     f1=$DIR/${tfile}-1
1249     cat <<EOF > $f1
1250 #!/bin/sh
1251 true
1252 EOF
1253     chmod +x $f1
1254     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x80000107"
1255     $f1 || return 1
1256     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0"
1257
1258     fail $SINGLEMDS
1259     rm -f $f1
1260 }
1261 run_test 53 "|X| open request and close reply while two MDC requests in flight"
1262
1263 test_54() {
1264     replay_barrier $SINGLEMDS
1265     createmany -o $DIR/$tfile 20
1266     unlinkmany $DIR/$tfile 20
1267     fail $SINGLEMDS
1268 }
1269 run_test 54 "|X| open request and close reply while two MDC requests in flight"
1270
1271 #b3440 ASSERTION(rec->ur_fid2->id) failed
1272 test_55() {
1273     sysctl -w portals.debug=-1 portals.debug_mb=25
1274     ln -s foo $DIR/$tfile
1275     replay_barrier $SINGLEMDS
1276     #drop_reply "cat $DIR/$tfile"
1277     fail $SINGLEMDS
1278     sleep 10
1279 }
1280 run_test 55 "don't replay a symlink open request (3440)"
1281
1282 #b3761 ASSERTION(hash != 0) failed
1283 test_56() {
1284 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1285     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x8000012b"
1286     touch $DIR/$tfile
1287     pid=$!
1288     # give a chance for touch to run
1289     sleep 5
1290     do_facet $SINGLEMDS "sysctl -w lustre.fail_loc=0x0"
1291     wait $pid || return 1
1292     rm $DIR/$tfile
1293     return 0
1294 }
1295 run_test 56 "let MDS_CHECK_RESENT return the original return code instead of 0"
1296
1297 #b7312 LASSERT(!IS_ERR(parent)) in reconstruct_open()
1298 test_57() {
1299     mkdir $DIR/$tdir || return 1
1300     touch $DIR/$tdir/$tfile || return 2
1301     multiop $DIR/$tdir/$tfile o_ &
1302     MULTIPID=$!
1303     sleep 1
1304     rm -f $DIR/$tdir/$tfile || return 3
1305     rm -rf $DIR/$tdir || return 4
1306     # drop first reint reply
1307     sysctl -w lustre.fail_loc=0x0000030c
1308     facet_failover $SINGLEMDS
1309     df $MOUNT || return 1
1310     kill -USR1 $MULTIPID || return 5
1311     wait $MULTIPID || return 6
1312     sysctl -w lustre.fail_loc=0
1313 }
1314 run_test 57 "open orphan in reconstruct_open()"
1315
1316 equals_msg test complete, cleaning up
1317 $CLEANUP
1318