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