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