lustre/tests/replay-single.sh

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