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