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