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 # Skip these tests
  20 # bug number:
  21 ALWAYS_EXCEPT="$REPLAY_SINGLE_EXCEPT"
  22
  23 #                                                     63 min  7 min  AT AT AT AT"
  24 [ "$SLOW" = "no" ] && EXCEPT_SLOW="1 2 3 4 6 6b 12 16 44      44b    65 66 67 68"
  25
  26 build_test_filter
  27
  28 cleanup_and_setup_lustre
  29
  30 mkdir -p $DIR
  31
  32 rm -rf $DIR/${TESTSUITE}/[df][0-9]* # bug 13798 new t-f tdir staff
  33 rm -rf $DIR/[df][0-9]*
  34
  35 test_0() {
  36     replay_barrier mds
  37     fail mds
  38 }
  39 run_test 0 "empty replay"
  40
  41 test_0b() {
  42     # this test attempts to trigger a race in the precreation code,
  43     # and must run before any other objects are created on the filesystem
  44     fail ost1
  45     createmany -o $DIR/$tfile 20 || return 1
  46     unlinkmany $DIR/$tfile 20 || return 2
  47 }
  48 run_test 0b "ensure object created after recover exists. (3284)"
  49
  50 test_1() {
  51     replay_barrier mds
  52     mcreate $DIR/$tfile
  53     fail mds
  54     $CHECKSTAT -t file $DIR/$tfile || return 1
  55     rm $DIR/$tfile
  56 }
  57 run_test 1 "simple create"
  58
  59 test_1a() {
  60     do_facet ost1 "sysctl -w lustre.fail_loc=0"
  61
  62     rm -fr $DIR/$tfile
  63     local old_last_id=`cat $LPROC/obdfilter/*/last_id`
  64     touch -o $DIR/$tfile 1
  65     sync
  66     local new_last_id=`cat $LPROC/obdfilter/*/last_id`
  67
  68     test "$old_last_id" = "$new_last_id" || {
  69         echo "OST object create is caused by MDS"
  70         return 1
  71     }
  72
  73     old_last_id=`cat $LPROC/obdfilter/*/last_id`
  74     echo "data" > $DIR/$tfile
  75     sync
  76     new_last_id=`cat $LPROC/obdfilter/*/last_id`
  77     test "$old_last_id" = "$new_last_id "&& {
  78         echo "CROW does not work on write"
  79         return 1
  80     }
  81
  82     rm -fr $DIR/$tfile
  83
  84 #define OBD_FAIL_OST_CROW_EIO | OBD_FAIL_ONCE
  85     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000801"
  86
  87     rm -fr $DIR/1a1
  88     old_last_id=`cat $LPROC/obdfilter/*/last_id`
  89     echo "data" > $DIR/1a1
  90     sync
  91     new_last_id=`cat $LPROC/obdfilter/*/last_id`
  92     test "$old_last_id" = "$new_last_id" || {
  93         echo "CROW does work with fail_loc=0x80000801"
  94         return 1
  95     }
  96
  97     rm -fr $DIR/1a1
  98
  99     do_facet ost1 "sysctl -w lustre.fail_loc=0"
 100 }
 101 #CROW run_test 1a "CROW object create (check OST last_id)"
 102
 103 test_2a() {
 104     replay_barrier mds
 105     touch $DIR/$tfile
 106     fail mds
 107     $CHECKSTAT -t file $DIR/$tfile || return 1
 108     rm $DIR/$tfile
 109 }
 110 run_test 2a "touch"
 111
 112 test_2b() {
 113     mcreate $DIR/$tfile
 114     replay_barrier mds
 115     touch $DIR/$tfile
 116     fail mds
 117     $CHECKSTAT -t file $DIR/$tfile || return 1
 118     rm $DIR/$tfile
 119 }
 120 run_test 2b "touch"
 121
 122 test_3a() {
 123     replay_barrier mds
 124     mcreate $DIR/$tfile
 125     o_directory $DIR/$tfile
 126     fail mds
 127     $CHECKSTAT -t file $DIR/$tfile || return 2
 128     rm $DIR/$tfile
 129 }
 130 run_test 3a "replay failed open(O_DIRECTORY)"
 131
 132 test_3b() {
 133     replay_barrier mds
 134 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 135     do_facet mds "sysctl -w lustre.fail_loc=0x80000114"
 136     touch $DIR/$tfile
 137     do_facet mds "sysctl -w lustre.fail_loc=0"
 138     fail mds
 139     $CHECKSTAT -t file $DIR/$tfile && return 2
 140     return 0
 141 }
 142 run_test 3b "replay failed open -ENOMEM"
 143
 144 test_3c() {
 145     replay_barrier mds
 146 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 147     do_facet mds "sysctl -w lustre.fail_loc=0x80000128"
 148     touch $DIR/$tfile
 149     do_facet mds "sysctl -w lustre.fail_loc=0"
 150     fail mds
 151
 152     $CHECKSTAT -t file $DIR/$tfile && return 2
 153     return 0
 154 }
 155 run_test 3c "replay failed open -ENOMEM"
 156
 157 test_4() {
 158     replay_barrier mds
 159     for i in `seq 10`; do
 160         echo "tag-$i" > $DIR/$tfile-$i
 161     done
 162     fail mds
 163     for i in `seq 10`; do
 164       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 165     done
 166 }
 167 run_test 4 "|x| 10 open(O_CREAT)s"
 168
 169 test_4b() {
 170     replay_barrier mds
 171     rm -rf $DIR/$tfile-*
 172     fail mds
 173     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 174 }
 175 run_test 4b "|x| rm 10 files"
 176
 177 # The idea is to get past the first block of precreated files on both
 178 # osts, and then replay.
 179 test_5() {
 180     replay_barrier mds
 181     for i in `seq 220`; do
 182         echo "tag-$i" > $DIR/$tfile-$i
 183     done
 184     fail mds
 185     for i in `seq 220`; do
 186       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
 187     done
 188     rm -rf $DIR/$tfile-*
 189     sleep 3
 190     # waiting for commitment of removal
 191 }
 192 run_test 5 "|x| 220 open(O_CREAT)"
 193
 194
 195 test_6() {
 196     replay_barrier mds
 197     mcreate $DIR/$tdir/$tfile
 198     fail mds
 199     $CHECKSTAT -t dir $DIR/$tdir || return 1
 200     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 201     sleep 2
 202     # waiting for log process thread
 203 }
 204 run_test 6 "mkdir + contained create"
 205
 206 test_6b() {
 207     replay_barrier mds
 208     rm -rf $DIR/$tdir
 209     fail mds
 210     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 211 }
 212 run_test 6b "|X| rmdir"
 213
 214 test_7() {
 215     replay_barrier mds
 216     mcreate $DIR/$tdir/$tfile
 217     fail mds
 218     $CHECKSTAT -t dir $DIR/$tdir || return 1
 219     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 220     rm -fr $DIR/$tdir
 221 }
 222 run_test 7 "mkdir |X| contained create"
 223
 224 test_8() {
 225     replay_barrier mds
 226     multiop $DIR/$tfile mo_c &
 227     MULTIPID=$!
 228     sleep 1
 229     fail mds
 230     ls $DIR/$tfile
 231     $CHECKSTAT -t file $DIR/$tfile || return 1
 232     kill -USR1 $MULTIPID || return 2
 233     wait $MULTIPID || return 3
 234     rm $DIR/$tfile
 235 }
 236 run_test 8 "creat open |X| close"
 237
 238 test_9() {
 239     replay_barrier mds
 240     mcreate $DIR/$tfile
 241     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 242     fail mds
 243     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 244
 245     echo " old_inum == $old_inum, new_inum == $new_inum"
 246     if [ $old_inum -eq $new_inum  ] ;
 247     then
 248         echo " old_inum and new_inum match"
 249     else
 250         echo "!!!! old_inum and new_inum NOT match"
 251         return 1
 252     fi
 253     rm $DIR/$tfile
 254 }
 255 run_test 9  "|X| create (same inum/gen)"
 256
 257 test_10() {
 258     mcreate $DIR/$tfile
 259     replay_barrier mds
 260     mv $DIR/$tfile $DIR/$tfile-2
 261     rm -f $DIR/$tfile
 262     fail mds
 263     $CHECKSTAT $DIR/$tfile && return 1
 264     $CHECKSTAT $DIR/$tfile-2 ||return 2
 265     rm $DIR/$tfile-2
 266     return 0
 267 }
 268 run_test 10 "create |X| rename unlink"
 269
 270 test_11() {
 271     mcreate $DIR/$tfile
 272     echo "old" > $DIR/$tfile
 273     mv $DIR/$tfile $DIR/$tfile-2
 274     replay_barrier mds
 275     echo "new" > $DIR/$tfile
 276     grep new $DIR/$tfile
 277     grep old $DIR/$tfile-2
 278     fail mds
 279     grep new $DIR/$tfile || return 1
 280     grep old $DIR/$tfile-2 || return 2
 281 }
 282 run_test 11 "create open write rename |X| create-old-name read"
 283
 284 test_12() {
 285     mcreate $DIR/$tfile
 286     multiop $DIR/$tfile o_tSc &
 287     pid=$!
 288     # give multiop a chance to open
 289     sleep 1
 290     rm -f $DIR/$tfile
 291     replay_barrier mds
 292     kill -USR1 $pid
 293     wait $pid || return 1
 294
 295     fail mds
 296     [ -e $DIR/$tfile ] && return 2
 297     return 0
 298 }
 299 run_test 12 "open, unlink |X| close"
 300
 301
 302 # 1777 - replay open after committed chmod that would make
 303 #        a regular open a failure
 304 test_13() {
 305     mcreate $DIR/$tfile
 306     multiop $DIR/$tfile O_wc &
 307     pid=$!
 308     # give multiop a chance to open
 309     sleep 1
 310     chmod 0 $DIR/$tfile
 311     $CHECKSTAT -p 0 $DIR/$tfile
 312     replay_barrier mds
 313     fail mds
 314     kill -USR1 $pid
 315     wait $pid || return 1
 316
 317     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
 318     return 0
 319 }
 320 run_test 13 "open chmod 0 |x| write close"
 321
 322 test_14() {
 323     multiop $DIR/$tfile O_tSc &
 324     pid=$!
 325     # give multiop a chance to open
 326     sleep 1
 327     rm -f $DIR/$tfile
 328     replay_barrier mds
 329     kill -USR1 $pid || return 1
 330     wait $pid || return 2
 331
 332     fail mds
 333     [ -e $DIR/$tfile ] && return 3
 334     return 0
 335 }
 336 run_test 14 "open(O_CREAT), unlink |X| close"
 337
 338 test_15() {
 339     multiop $DIR/$tfile O_tSc &
 340     pid=$!
 341     # give multiop a chance to open
 342     sleep 1
 343     rm -f $DIR/$tfile
 344     replay_barrier mds
 345     touch $DIR/g11 || return 1
 346     kill -USR1 $pid
 347     wait $pid || return 2
 348
 349     fail mds
 350     [ -e $DIR/$tfile ] && return 3
 351     touch $DIR/h11 || return 4
 352     return 0
 353 }
 354 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 355
 356
 357 test_16() {
 358     replay_barrier mds
 359     mcreate $DIR/$tfile
 360     munlink $DIR/$tfile
 361     mcreate $DIR/$tfile-2
 362     fail mds
 363     [ -e $DIR/$tfile ] && return 1
 364     [ -e $DIR/$tfile-2 ] || return 2
 365     munlink $DIR/$tfile-2 || return 3
 366 }
 367 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 368
 369 test_17() {
 370     replay_barrier mds
 371     multiop $DIR/$tfile O_c &
 372     pid=$!
 373     # give multiop a chance to open
 374     sleep 1
 375     fail mds
 376     kill -USR1 $pid || return 1
 377     wait $pid || return 2
 378     $CHECKSTAT -t file $DIR/$tfile || return 3
 379     rm $DIR/$tfile
 380 }
 381 run_test 17 "|X| open(O_CREAT), |replay| close"
 382
 383 test_18() {
 384     replay_barrier mds
 385     multiop $DIR/$tfile O_tSc &
 386     pid=$!
 387     # give multiop a chance to open
 388     sleep 1
 389     rm -f $DIR/$tfile
 390     touch $DIR/$tfile-2 || return 1
 391     echo "pid: $pid will close"
 392     kill -USR1 $pid
 393     wait $pid || return 2
 394
 395     fail mds
 396     [ -e $DIR/$tfile ] && return 3
 397     [ -e $DIR/$tfile-2 ] || return 4
 398     # this touch frequently fails
 399     touch $DIR/$tfile-3 || return 5
 400     munlink $DIR/$tfile-2 || return 6
 401     munlink $DIR/$tfile-3 || return 7
 402     return 0
 403 }
 404 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
 405
 406 # bug 1855 (a simpler form of test_11 above)
 407 test_19() {
 408     replay_barrier mds
 409     mcreate $DIR/$tfile
 410     echo "old" > $DIR/$tfile
 411     mv $DIR/$tfile $DIR/$tfile-2
 412     grep old $DIR/$tfile-2
 413     fail mds
 414     grep old $DIR/$tfile-2 || return 2
 415 }
 416 run_test 19 "|X| mcreate, open, write, rename "
 417
 418 test_20() {
 419     replay_barrier mds
 420     multiop $DIR/$tfile O_tSc &
 421     pid=$!
 422     # give multiop a chance to open
 423     sleep 1
 424     rm -f $DIR/$tfile
 425
 426     fail mds
 427     kill -USR1 $pid
 428     wait $pid || return 1
 429     [ -e $DIR/$tfile ] && return 2
 430     return 0
 431 }
 432 run_test 20 "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 433
 434 test_20b() { # bug 10480
 435     BEFOREUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 436
 437     dd if=/dev/zero of=$DIR/$tfile bs=4k count=10000 &
 438     pid=$!
 439     while [ ! -e $DIR/$tfile ] ; do
 440         sleep 0.060s                           # give dd a chance to start
 441     done
 442
 443     lfs getstripe $DIR/$tfile || return 1
 444     rm -f $DIR/$tfile || return 2       # make it an orphan
 445     mds_evict_client
 446     df -P $DIR || df -P $DIR || true    # reconnect
 447
 448     fail mds                            # start orphan recovery
 449     df -P $DIR || df -P $DIR || true    # reconnect
 450     wait_mds_recovery_done || error "MDS recovery not done"
 451
 452     AFTERUSED=`df -P $DIR | tail -1 | awk '{ print $3 }'`
 453     log "before $BEFOREUSED, after $AFTERUSED"
 454     [ $AFTERUSED -gt $((BEFOREUSED + 20)) ] && \
 455         error "after $AFTERUSED > before $BEFOREUSED" && return 5
 456     return 0
 457 }
 458 run_test 20b "write, unlink, eviction, replay, (test mds_cleanup_orphans)"
 459
 460 test_20c() { # bug 10480
 461     multiop $DIR/$tfile Ow_c &
 462     pid=$!
 463     # give multiop a chance to open
 464     sleep 1
 465
 466     ls -la $DIR/$tfile
 467
 468     mds_evict_client
 469
 470     df -P $DIR || df -P $DIR || true    # reconnect
 471
 472     kill -USR1 $pid
 473     test -s $DIR/$tfile || error "File was truncated"
 474
 475     return 0
 476 }
 477 run_test 20c "check that client eviction does not affect file content"
 478
 479 test_21() {
 480     replay_barrier mds
 481     multiop $DIR/$tfile O_tSc &
 482     pid=$!
 483     # give multiop a chance to open
 484     sleep 1
 485     rm -f $DIR/$tfile
 486     touch $DIR/g11 || return 1
 487
 488     fail mds
 489     kill -USR1 $pid
 490     wait $pid || return 2
 491     [ -e $DIR/$tfile ] && return 3
 492     touch $DIR/h11 || return 4
 493     return 0
 494 }
 495 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 496
 497 test_22() {
 498     multiop $DIR/$tfile O_tSc &
 499     pid=$!
 500     # give multiop a chance to open
 501     sleep 1
 502
 503     replay_barrier mds
 504     rm -f $DIR/$tfile
 505
 506     fail mds
 507     kill -USR1 $pid
 508     wait $pid || return 1
 509     [ -e $DIR/$tfile ] && return 2
 510     return 0
 511 }
 512 run_test 22 "open(O_CREAT), |X| unlink, replay, close (test mds_cleanup_orphans)"
 513
 514 test_23() {
 515     multiop $DIR/$tfile O_tSc &
 516     pid=$!
 517     # give multiop a chance to open
 518     sleep 1
 519
 520     replay_barrier mds
 521     rm -f $DIR/$tfile
 522     touch $DIR/g11 || return 1
 523
 524     fail mds
 525     kill -USR1 $pid
 526     wait $pid || return 2
 527     [ -e $DIR/$tfile ] && return 3
 528     touch $DIR/h11 || return 4
 529     return 0
 530 }
 531 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 532
 533 test_24() {
 534     multiop $DIR/$tfile O_tSc &
 535     pid=$!
 536     # give multiop a chance to open
 537     sleep 1
 538
 539     replay_barrier mds
 540     fail mds
 541     rm -f $DIR/$tfile
 542     kill -USR1 $pid
 543     wait $pid || return 1
 544     [ -e $DIR/$tfile ] && return 2
 545     return 0
 546 }
 547 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 548
 549 test_25() {
 550     multiop $DIR/$tfile O_tSc &
 551     pid=$!
 552     # give multiop a chance to open
 553     sleep 1
 554     rm -f $DIR/$tfile
 555
 556     replay_barrier mds
 557     fail mds
 558     kill -USR1 $pid
 559     wait $pid || return 1
 560     [ -e $DIR/$tfile ] && return 2
 561     return 0
 562 }
 563 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 564
 565 test_26() {
 566     replay_barrier mds
 567     multiop $DIR/$tfile-1 O_tSc &
 568     pid1=$!
 569     multiop $DIR/$tfile-2 O_tSc &
 570     pid2=$!
 571     # give multiop a chance to open
 572     sleep 1
 573     rm -f $DIR/$tfile-1
 574     rm -f $DIR/$tfile-2
 575     kill -USR1 $pid2
 576     wait $pid2 || return 1
 577
 578     fail mds
 579     kill -USR1 $pid1
 580     wait $pid1 || return 2
 581     [ -e $DIR/$tfile-1 ] && return 3
 582     [ -e $DIR/$tfile-2 ] && return 4
 583     return 0
 584 }
 585 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 586
 587 test_27() {
 588     replay_barrier mds
 589     multiop $DIR/$tfile-1 O_tSc &
 590     pid1=$!
 591     multiop $DIR/$tfile-2 O_tSc &
 592     pid2=$!
 593     # give multiop a chance to open
 594     sleep 1
 595     rm -f $DIR/$tfile-1
 596     rm -f $DIR/$tfile-2
 597
 598     fail mds
 599     kill -USR1 $pid1
 600     wait $pid1 || return 1
 601     kill -USR1 $pid2
 602     wait $pid2 || return 2
 603     [ -e $DIR/$tfile-1 ] && return 3
 604     [ -e $DIR/$tfile-2 ] && return 4
 605     return 0
 606 }
 607 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 608
 609 test_28() {
 610     multiop $DIR/$tfile-1 O_tSc &
 611     pid1=$!
 612     multiop $DIR/$tfile-2 O_tSc &
 613     pid2=$!
 614     # give multiop a chance to open
 615     sleep 1
 616     replay_barrier mds
 617     rm -f $DIR/$tfile-1
 618     rm -f $DIR/$tfile-2
 619     kill -USR1 $pid2
 620     wait $pid2 || return 1
 621
 622     fail mds
 623     kill -USR1 $pid1
 624     wait $pid1 || return 2
 625     [ -e $DIR/$tfile-1 ] && return 3
 626     [ -e $DIR/$tfile-2 ] && return 4
 627     return 0
 628 }
 629 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 630
 631 test_29() {
 632     multiop $DIR/$tfile-1 O_tSc &
 633     pid1=$!
 634     multiop $DIR/$tfile-2 O_tSc &
 635     pid2=$!
 636     # give multiop a chance to open
 637     sleep 1
 638     replay_barrier mds
 639     rm -f $DIR/$tfile-1
 640     rm -f $DIR/$tfile-2
 641
 642     fail mds
 643     kill -USR1 $pid1
 644     wait $pid1 || return 1
 645     kill -USR1 $pid2
 646     wait $pid2 || return 2
 647     [ -e $DIR/$tfile-1 ] && return 3
 648     [ -e $DIR/$tfile-2 ] && return 4
 649     return 0
 650 }
 651 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 652
 653 test_30() {
 654     multiop $DIR/$tfile-1 O_tSc &
 655     pid1=$!
 656     multiop $DIR/$tfile-2 O_tSc &
 657     pid2=$!
 658     # give multiop a chance to open
 659     sleep 1
 660     rm -f $DIR/$tfile-1
 661     rm -f $DIR/$tfile-2
 662
 663     replay_barrier mds
 664     fail mds
 665     kill -USR1 $pid1
 666     wait $pid1 || return 1
 667     kill -USR1 $pid2
 668     wait $pid2 || return 2
 669     [ -e $DIR/$tfile-1 ] && return 3
 670     [ -e $DIR/$tfile-2 ] && return 4
 671     return 0
 672 }
 673 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 674
 675 test_31() {
 676     multiop $DIR/$tfile-1 O_tSc &
 677     pid1=$!
 678     multiop $DIR/$tfile-2 O_tSc &
 679     pid2=$!
 680     # give multiop a chance to open
 681     sleep 1
 682     rm -f $DIR/$tfile-1
 683
 684     replay_barrier mds
 685     rm -f $DIR/$tfile-2
 686     fail mds
 687     kill -USR1 $pid1
 688     wait $pid1 || return 1
 689     kill -USR1 $pid2
 690     wait $pid2 || return 2
 691     [ -e $DIR/$tfile-1 ] && return 3
 692     [ -e $DIR/$tfile-2 ] && return 4
 693     return 0
 694 }
 695 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 696
 697 # tests for bug 2104; completion without crashing is success.  The close is
 698 # stale, but we always return 0 for close, so the app never sees it.
 699 test_32() {
 700     multiop $DIR/$tfile O_c &
 701     pid1=$!
 702     multiop $DIR/$tfile O_c &
 703     pid2=$!
 704     # give multiop a chance to open
 705     sleep 1
 706     mds_evict_client
 707     df $MOUNT || sleep 1 && df $MOUNT || return 1
 708     kill -USR1 $pid1
 709     kill -USR1 $pid2
 710     sleep 1
 711     return 0
 712 }
 713 run_test 32 "close() notices client eviction; close() after client eviction"
 714
 715 # Abort recovery before client complete
 716 test_33() {
 717     replay_barrier mds
 718     createmany -o $DIR/$tfile-%d 100
 719     fail_abort mds
 720     # this file should be gone, because the replay was aborted
 721     $CHECKSTAT -t file $DIR/$tfile-* && return 3
 722     unlinkmany $DIR/$tfile-%d 0 100
 723     return 0
 724 }
 725 run_test 33 "abort recovery before client does replay"
 726
 727 test_34() {
 728     multiop $DIR/$tfile O_c &
 729     pid=$!
 730     # give multiop a chance to open
 731     sleep 1
 732     rm -f $DIR/$tfile
 733
 734     replay_barrier mds
 735     fail_abort mds
 736     kill -USR1 $pid
 737     [ -e $DIR/$tfile ] && return 1
 738     sync
 739     return 0
 740 }
 741 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 742
 743 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 744 test_35() {
 745     touch $DIR/$tfile
 746
 747 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 748     do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
 749     rm -f $DIR/$tfile &
 750     sleep 1
 751     sync
 752     sleep 1
 753     # give a chance to remove from MDS
 754     fail_abort mds
 755     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
 756 }
 757 run_test 35 "test recovery from llog for unlink op"
 758
 759 # b=2432 resent cancel after replay uses wrong cookie,
 760 # so don't resend cancels
 761 test_36() {
 762     replay_barrier mds
 763     touch $DIR/$tfile
 764     checkstat $DIR/$tfile
 765     facet_failover mds
 766     cancel_lru_locks mdc
 767     if dmesg | grep "unknown lock cookie"; then
 768         echo "cancel after replay failed"
 769         return 1
 770     fi
 771 }
 772 run_test 36 "don't resend cancel"
 773
 774 # b=2368
 775 # directory orphans can't be unlinked from PENDING directory
 776 test_37() {
 777     rmdir $DIR/$tfile 2>/dev/null
 778     multiop $DIR/$tfile dD_c &
 779     pid=$!
 780     # give multiop a chance to open
 781     sleep 1
 782     rmdir $DIR/$tfile
 783
 784     replay_barrier mds
 785     # clear the dmesg buffer so we only see errors from this recovery
 786     dmesg -c >/dev/null
 787     fail_abort mds
 788     kill -USR1 $pid
 789     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
 790     sync
 791     return 0
 792 }
 793 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 794
 795 test_38() {
 796     createmany -o $DIR/$tfile-%d 800
 797     unlinkmany $DIR/$tfile-%d 0 400
 798     replay_barrier mds
 799     fail mds
 800     unlinkmany $DIR/$tfile-%d 400 400
 801     sleep 2
 802     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 803 }
 804 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 805
 806 test_39() { # bug 4176
 807     createmany -o $DIR/$tfile-%d 800
 808     replay_barrier mds
 809     unlinkmany $DIR/$tfile-%d 0 400
 810     fail mds
 811     unlinkmany $DIR/$tfile-%d 400 400
 812     sleep 2
 813     ls -1f $DIR/$tfile-*
 814     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 815 }
 816 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 817
 818 count_ost_writes() {
 819     awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }' $LPROC/osc/*/stats
 820 }
 821
 822 #b=2477,2532
 823 test_40(){
 824     $LCTL mark multiop $MOUNT/$tfile OS_c
 825     multiop $MOUNT/$tfile OS_c  &
 826     PID=$!
 827     writeme -s $MOUNT/${tfile}-2 &
 828     WRITE_PID=$!
 829     sleep 1
 830     facet_failover mds
 831 #define OBD_FAIL_MDS_CONNECT_NET         0x117
 832     do_facet mds "sysctl -w lustre.fail_loc=0x80000117"
 833     kill -USR1 $PID
 834     stat1=`count_ost_writes`
 835     sleep $TIMEOUT
 836     stat2=`count_ost_writes`
 837     echo "$stat1, $stat2"
 838     if [ $stat1 -lt $stat2 ]; then
 839        echo "writes continuing during recovery"
 840        RC=0
 841     else
 842        echo "writes not continuing during recovery, bug 2477"
 843        RC=4
 844     fi
 845     echo "waiting for writeme $WRITE_PID"
 846     kill $WRITE_PID
 847     wait $WRITE_PID
 848
 849     echo "waiting for multiop $PID"
 850     wait $PID || return 2
 851     do_facet client munlink $MOUNT/$tfile  || return 3
 852     do_facet client munlink $MOUNT/${tfile}-2  || return 3
 853     return $RC
 854 }
 855 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 856
 857
 858 #b=2814
 859 # make sure that a read to one osc doesn't try to double-unlock its page just
 860 # because another osc is invalid.  trigger_group_io used to mistakenly return
 861 # an error if any oscs were invalid even after having successfully put rpcs
 862 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 863 # the page, guarnateeing that the unlock from the RPC completion would
 864 # assert on trying to unlock the unlocked page.
 865 test_41() {
 866     [ $OSTCOUNT -lt 2 ] && \
 867         skip "skipping test 41: we don't have a second OST to test with" && \
 868         return
 869
 870     local f=$MOUNT/$tfile
 871     # make sure the start of the file is ost1
 872     lfs setstripe $f -s $((128 * 1024)) -i 0
 873     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
 874     cancel_lru_locks osc
 875     # fail ost2 and read from ost1
 876     local osc2dev=`grep ${ost2_svc}-osc- $LPROC/devices | awk '{print $1}'`
 877     [ "$osc2dev" ] || return 4
 878     $LCTL --device $osc2dev deactivate || return 1
 879     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
 880     $LCTL --device $osc2dev activate || return 2
 881     return 0
 882 }
 883 run_test 41 "read from a valid osc while other oscs are invalid"
 884
 885 # test MDS recovery after ost failure
 886 test_42() {
 887     blocks=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 888     createmany -o $DIR/$tfile-%d 800
 889     replay_barrier ost1
 890     unlinkmany $DIR/$tfile-%d 0 400
 891     debugsave
 892     sysctl -w lnet.debug=-1
 893     facet_failover ost1
 894
 895     # osc is evicted, fs is smaller (but only with failout OSTs (bug 7287)
 896     #blocks_after=`df -P $MOUNT | tail -n 1 | awk '{ print $2 }'`
 897     #[ $blocks_after -lt $blocks ] || return 1
 898     echo wait for MDS to timeout and recover
 899     sleep $((TIMEOUT * 2))
 900     debugrestore
 901     unlinkmany $DIR/$tfile-%d 400 400
 902     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
 903 }
 904 run_test 42 "recovery after ost failure"
 905
 906 # timeout in MDS/OST recovery RPC will LBUG MDS
 907 test_43() { # bug 2530
 908     replay_barrier mds
 909
 910     # OBD_FAIL_OST_CREATE_NET 0x204
 911     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000204"
 912     fail mds
 913     sleep 10
 914     do_facet ost1 "sysctl -w lustre.fail_loc=0"
 915
 916     return 0
 917 }
 918 run_test 43 "mds osc import failure during recovery; don't LBUG"
 919
 920 test_44() {
 921     mdcdev=`awk '/-mdc-/ {print $1}' $LPROC/devices`
 922     [ "$mdcdev" ] || exit 2
 923     # adaptive timeouts slow this way down
 924     local at_max=$(do_facet mds "find /sys/ -name at_max")
 925     [ -z "$at_max" ] && skip "missing /sys/.../at_max" && return 0
 926     MDS_AT_MAX=$(do_facet mds "cat $at_max")
 927     do_facet mds "echo 40 >> $at_max"
 928     for i in `seq 1 10`; do
 929         echo "$i of 10 ($(date +%s))"
 930         do_facet mds "grep service $LPROC/mdt/MDS/mds/timeouts"
 931         #define OBD_FAIL_TGT_CONN_RACE     0x701
 932         do_facet mds "sysctl -w lustre.fail_loc=0x80000701"
 933         $LCTL --device $mdcdev recover
 934         df $MOUNT
 935     done
 936     do_facet mds "sysctl -w lustre.fail_loc=0"
 937     do_facet mds "echo $MDS_AT_MAX >> $at_max"
 938     return 0
 939 }
 940 run_test 44 "race in target handle connect"
 941
 942 test_44b() {
 943     mdcdev=`awk '/-mdc-/ {print $1}' $LPROC/devices`
 944     [ "$mdcdev" ] || exit 2
 945     for i in `seq 1 10`; do
 946         echo "$i of 10 ($(date +%s))"
 947         do_facet mds "grep service $LPROC/mdt/MDS/mds/timeouts"
 948         #define OBD_FAIL_TGT_DELAY_RECONNECT 0x704
 949         do_facet mds "sysctl -w lustre.fail_loc=0x80000704"
 950         $LCTL --device $mdcdev recover
 951         df $MOUNT
 952     done
 953     do_facet mds "sysctl -w lustre.fail_loc=0"
 954     return 0
 955 }
 956 run_test 44b "race in target handle connect"
 957
 958 # Handle failed close
 959 test_45() {
 960     mdcdev=`awk '/-mdc-/ {print $1}' $LPROC/devices`
 961     [ "$mdcdev" ] || exit 2
 962     $LCTL --device $mdcdev recover
 963
 964     multiop $DIR/$tfile O_c &
 965     pid=$!
 966     sleep 1
 967
 968     # This will cause the CLOSE to fail before even
 969     # allocating a reply buffer
 970     $LCTL --device $mdcdev deactivate || return 4
 971
 972     # try the close
 973     kill -USR1 $pid
 974     wait $pid || return 1
 975
 976     $LCTL --device $mdcdev activate || return 5
 977     sleep 1
 978
 979     $CHECKSTAT -t file $DIR/$tfile || return 2
 980     return 0
 981 }
 982 run_test 45 "Handle failed close"
 983
 984 test_46() {
 985     dmesg -c >/dev/null
 986     drop_reply "touch $DIR/$tfile"
 987     fail mds
 988     # ironically, the previous test, 45, will cause a real forced close,
 989     # so just look for one for this test
 990     dmesg | grep -i "force closing client file handle for $tfile" && return 1
 991     return 0
 992 }
 993 run_test 46 "Don't leak file handle after open resend (3325)"
 994
 995 test_47() { # bug 2824
 996     # create some files to make sure precreate has been done on all
 997     # OSTs. (just in case this test is run independently)
 998     createmany -o $DIR/$tfile 20  || return 1
 999
1000     # OBD_FAIL_OST_CREATE_NET 0x204
1001     fail ost1
1002     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000204"
1003     df $MOUNT || return 2
1004
1005     # let the MDS discover the OST failure, attempt to recover, fail
1006     # and recover again.
1007     sleep $((3 * TIMEOUT))
1008
1009     # Without 2824, this createmany would hang
1010     createmany -o $DIR/$tfile 20 || return 3
1011     unlinkmany $DIR/$tfile 20 || return 4
1012
1013     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1014     return 0
1015 }
1016 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
1017
1018 test_48() {
1019     replay_barrier mds
1020     createmany -o $DIR/$tfile 20  || return 1
1021     # OBD_FAIL_OST_EROFS 0x216
1022     fail mds
1023     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000216"
1024     df $MOUNT || return 2
1025
1026     createmany -o $DIR/$tfile 20 20 || return 2
1027     unlinkmany $DIR/$tfile 40 || return 3
1028
1029     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1030     return 0
1031 }
1032 run_test 48 "MDS->OSC failure during precreate cleanup (2824)"
1033
1034 test_50() {
1035     local oscdev=`do_facet mds grep \'${ost1_svc}-osc \' $LPROC/devices | awk '{print $1}' | head -1`
1036     [ "$oscdev" ] || return 1
1037     do_facet mds $LCTL --device $oscdev recover || return 2
1038     do_facet mds $LCTL --device $oscdev recover || return 3
1039     # give the mds_lov_sync threads a chance to run
1040     sleep 5
1041 }
1042 run_test 50 "Double OSC recovery, don't LASSERT (3812)"
1043
1044 # b3764 timed out lock replay
1045 test_52() {
1046     touch $DIR/$tfile
1047     cancel_lru_locks mdc
1048
1049     multiop $DIR/$tfile s || return 1
1050     replay_barrier mds
1051 #define OBD_FAIL_LDLM_REPLY              0x30c
1052     do_facet mds "sysctl -w lustre.fail_loc=0x8000030c"
1053     fail mds || return 2
1054     do_facet mds "sysctl -w lustre.fail_loc=0x0"
1055
1056     $CHECKSTAT -t file $DIR/$tfile-* && return 3 || true
1057 }
1058 run_test 52 "time out lock replay (3764)"
1059
1060 # bug 3462 - simultaneous MDC requests
1061 test_53a() {
1062     mkdir -p $DIR/${tdir}-1
1063     mkdir -p $DIR/${tdir}-2
1064     multiop $DIR/${tdir}-1/f O_c &
1065     close_pid=$!
1066     # give multiop a chance to open
1067     sleep 1
1068
1069     #define OBD_FAIL_MDS_CLOSE_NET 0x115
1070     do_facet mds "sysctl -w lustre.fail_loc=0x80000115"
1071     kill -USR1 $close_pid
1072     cancel_lru_locks MDC # force the close
1073     do_facet mds "sysctl -w lustre.fail_loc=0"
1074     mcreate $DIR/${tdir}-2/f || return 1
1075
1076     # close should still be here
1077     [ -d /proc/$close_pid ] || return 2
1078     replay_barrier_nodf mds
1079     fail mds
1080     wait $close_pid || return 3
1081
1082     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1083     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1084     rm -rf $DIR/${tdir}-*
1085 }
1086 run_test 53a "|X| close request while two MDC requests in flight"
1087
1088 test_53b() {
1089     mkdir -p $DIR/$tdir-1
1090     mkdir -p $DIR/$tdir-2
1091     multiop $DIR/$tdir-1/f O_c &
1092     close_pid=$!
1093
1094     #define OBD_FAIL_MDS_REINT_NET 0x107
1095     do_facet mds "sysctl -w lustre.fail_loc=0x80000107"
1096     mcreate $DIR/${tdir}-2/f &
1097     open_pid=$!
1098     sleep 1
1099
1100     do_facet mds "sysctl -w lustre.fail_loc=0"
1101     kill -USR1 $close_pid
1102     cancel_lru_locks MDC # force the close
1103     wait $close_pid || return 1
1104     # open should still be here
1105     [ -d /proc/$open_pid ] || return 2
1106
1107     replay_barrier_nodf mds
1108     fail mds
1109     wait $open_pid || return 3
1110
1111     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1112     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1113     rm -rf $DIR/${tdir}-*
1114 }
1115 run_test 53b "|X| open request while two MDC requests in flight"
1116
1117 test_53c() {
1118     mkdir -p $DIR/${tdir}-1
1119     mkdir -p $DIR/${tdir}-2
1120     multiop $DIR/${tdir}-1/f O_c &
1121     close_pid=$!
1122
1123     do_facet mds "sysctl -w lustre.fail_loc=0x80000107"
1124     mcreate $DIR/${tdir}-2/f &
1125     open_pid=$!
1126     sleep 1
1127
1128     do_facet mds "sysctl -w lustre.fail_loc=0x80000115"
1129     kill -USR1 $close_pid
1130     cancel_lru_locks MDC  # force the close
1131
1132     replay_barrier_nodf mds
1133     fail_nodf mds
1134     wait $open_pid || return 1
1135     sleep 2
1136     # close should be gone
1137     [ -d /proc/$close_pid ] && return 2
1138     do_facet mds "sysctl -w lustre.fail_loc=0"
1139
1140     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1141     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1142     rm -rf $DIR/${tdir}-*
1143 }
1144 run_test 53c "|X| open request and close request while two MDC requests in flight"
1145
1146 test_53d() {
1147     mkdir -p $DIR/${tdir}-1
1148     mkdir -p $DIR/${tdir}-2
1149     multiop $DIR/${tdir}-1/f O_c &
1150     close_pid=$!
1151     # give multiop a chance to open
1152     sleep 1
1153
1154     # define OBD_FAIL_MDS_CLOSE_NET_REP 0X138
1155     do_facet mds "sysctl -w lustre.fail_loc=0x8000013b"
1156     kill -USR1 $close_pid
1157     cancel_lru_locks MDC  # force the close
1158     do_facet mds "sysctl -w lustre.fail_loc=0"
1159     mcreate $DIR/${tdir}-2/f || return 1
1160
1161     # close should still be here
1162     [ -d /proc/$close_pid ] || return 2
1163     replay_barrier_nodf mds
1164     fail mds
1165     wait $close_pid || return 3
1166
1167     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1168     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1169     rm -rf $DIR/${tdir}-*
1170 }
1171 run_test 53d "|X| close reply while two MDC requests in flight"
1172
1173 test_53e() {
1174     mkdir -p $DIR/$tdir-1
1175     mkdir -p $DIR/$tdir-2
1176     multiop $DIR/$tdir-1/f O_c &
1177     close_pid=$!
1178
1179     #define OBD_FAIL_MDS_REINT_NET_REP       0x119
1180     do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
1181     mcreate $DIR/${tdir}-2/f &
1182     open_pid=$!
1183     sleep 1
1184
1185     do_facet mds "sysctl -w lustre.fail_loc=0"
1186     kill -USR1 $close_pid
1187     cancel_lru_locks MDC  # force the close
1188     wait $close_pid || return 1
1189     # open should still be here
1190     [ -d /proc/$open_pid ] || return 2
1191
1192     replay_barrier_nodf mds
1193     fail mds
1194     wait $open_pid || return 3
1195
1196     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 4
1197     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 5
1198     rm -rf $DIR/${tdir}-*
1199 }
1200 run_test 53e "|X| open reply while two MDC requests in flight"
1201
1202 test_53f() {
1203         mkdir -p $DIR/${tdir}-1
1204         mkdir -p $DIR/${tdir}-2
1205         multiop $DIR/${tdir}-1/f O_c &
1206         close_pid=$!
1207
1208         do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
1209         mcreate $DIR/${tdir}-2/f &
1210         open_pid=$!
1211         sleep 1
1212
1213         do_facet mds "sysctl -w lustre.fail_loc=0x8000013b"
1214         kill -USR1 $close_pid
1215         cancel_lru_locks MDC
1216
1217         replay_barrier_nodf mds
1218         fail_nodf mds
1219         wait $open_pid || return 1
1220         sleep 2
1221         #close should be gone
1222         [ -d /proc/$close_pid ] && return 2
1223         do_facet mds "sysctl -w lustre.fail_loc=0"
1224
1225         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1226         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1227         rm -rf $DIR/${tdir}-*
1228 }
1229 run_test 53f "|X| open reply and close reply while two MDC requests in flight"
1230
1231 test_53g() {
1232         mkdir -p $DIR/${tdir}-1
1233         mkdir -p $DIR/${tdir}-2
1234         multiop $DIR/${tdir}-1/f O_c &
1235         close_pid=$!
1236
1237         do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
1238         mcreate $DIR/${tdir}-2/f &
1239         open_pid=$!
1240         sleep 1
1241
1242         do_facet mds "sysctl -w lustre.fail_loc=0x80000115"
1243         kill -USR1 $close_pid
1244         cancel_lru_locks MDC # force the close
1245
1246         do_facet mds "sysctl -w lustre.fail_loc=0"
1247         replay_barrier_nodf mds
1248         fail_nodf mds
1249         wait $open_pid || return 1
1250         sleep 2
1251         # close should be gone
1252         [ -d /proc/$close_pid ] && return 2
1253
1254         $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1255         $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1256         rm -rf $DIR/${tdir}-*
1257 }
1258 run_test 53g "|X| drop open reply and close request while close and open are both in flight"
1259
1260 test_53h() {
1261     mkdir -p $DIR/${tdir}-1
1262     mkdir -p $DIR/${tdir}-2
1263     multiop $DIR/${tdir}-1/f O_c &
1264     close_pid=$!
1265
1266     do_facet mds "sysctl -w lustre.fail_loc=0x80000107"
1267     mcreate $DIR/${tdir}-2/f &
1268     open_pid=$!
1269     sleep 1
1270
1271     do_facet mds "sysctl -w lustre.fail_loc=0x8000013b"
1272     kill -USR1 $close_pid
1273     cancel_lru_locks MDC  # force the close
1274     sleep 1
1275
1276     replay_barrier_nodf mds
1277     fail_nodf mds
1278     wait $open_pid || return 1
1279     sleep 2
1280     # close should be gone
1281     [ -d /proc/$close_pid ] && return 2
1282     do_facet mds "sysctl -w lustre.fail_loc=0"
1283
1284     $CHECKSTAT -t file $DIR/${tdir}-1/f || return 3
1285     $CHECKSTAT -t file $DIR/${tdir}-2/f || return 4
1286     rm -rf $DIR/${tdir}-*
1287 }
1288 run_test 53h "|X| open request and close reply while two MDC requests in flight"
1289
1290 #b3761 ASSERTION(hash != 0) failed
1291 test_55() {
1292 # OBD_FAIL_MDS_OPEN_CREATE | OBD_FAIL_ONCE
1293     do_facet mds "sysctl -w lustre.fail_loc=0x8000012b"
1294     touch $DIR/$tfile &
1295     # give touch a chance to run
1296     sleep 5
1297     do_facet mds "sysctl -w lustre.fail_loc=0x0"
1298     rm $DIR/$tfile
1299     return 0
1300 }
1301 run_test 55 "let MDS_CHECK_RESENT return the original return code instead of 0"
1302
1303 #b3440 ASSERTION(rec->ur_fid2->id) failed
1304 test_56() {
1305     ln -s foo $DIR/$tfile
1306     replay_barrier mds
1307     #drop_reply "cat $DIR/$tfile"
1308     fail mds
1309     sleep 10
1310 }
1311 run_test 56 "don't replay a symlink open request (3440)"
1312
1313 #recovery one mds-ost setattr from llog
1314 test_57() {
1315 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1316     do_facet mds "sysctl -w lustre.fail_loc=0x8000012c"
1317     touch $DIR/$tfile
1318     replay_barrier mds
1319     fail mds
1320     sleep 1
1321     $CHECKSTAT -t file $DIR/$tfile || return 1
1322     do_facet mds "sysctl -w lustre.fail_loc=0x0"
1323     rm $DIR/$tfile
1324 }
1325 run_test 57 "test recovery from llog for setattr op"
1326
1327 #recovery many mds-ost setattr from llog
1328 test_58() {
1329 #define OBD_FAIL_MDS_OST_SETATTR       0x12c
1330     do_facet mds "sysctl -w lustre.fail_loc=0x8000012c"
1331     createmany -o $DIR/$tdir/$tfile-%d 2500
1332     replay_barrier mds
1333     fail mds
1334     sleep 2
1335     $CHECKSTAT -t file $DIR/$tdir/$tfile-* >/dev/null || return 1
1336     do_facet mds "sysctl -w lustre.fail_loc=0x0"
1337     unlinkmany $DIR/$tdir/$tfile-%d 2500
1338     rmdir $DIR/$tdir
1339 }
1340 run_test 58 "test recovery from llog for setattr op (test llog_gen_rec)"
1341
1342 # log_commit_thread vs filter_destroy race used to lead to import use after free
1343 # bug 11658
1344 test_59() {
1345     createmany -o $DIR/$tdir/$tfile-%d 200
1346     sync
1347     unlinkmany $DIR/$tdir/$tfile-%d 200
1348 #define OBD_FAIL_PTLRPC_DELAY_RECOV       0x507
1349     do_facet ost1 "sysctl -w lustre.fail_loc=0x507"
1350     fail ost1
1351     fail mds
1352     do_facet ost1 "sysctl -w lustre.fail_loc=0x0"
1353     sleep 20
1354     rmdir $DIR/$tdir
1355 }
1356 run_test 59 "test log_commit_thread vs filter_destroy race"
1357
1358 # race between add unlink llog vs cat log init in post_recovery (only for b1_6)
1359 # bug 12086: should no oops and No ctxt error for this test
1360 test_60() {
1361     createmany -o $DIR/$tdir/$tfile-%d 200
1362     replay_barrier mds
1363     unlinkmany $DIR/$tdir/$tfile-%d 0 100
1364     fail mds
1365     unlinkmany $DIR/$tdir/$tfile-%d 100 100
1366     local no_ctxt=`dmesg | grep "No ctxt"`
1367     [ -z "$no_ctxt" ] || error "ctxt is not initialized in recovery"
1368 }
1369 run_test 60 "test llog post recovery init vs llog unlink"
1370
1371 #test race  llog recovery thread vs llog cleanup
1372 test_61a() {
1373     createmany -o $DIR/$tdir/$tfile-%d 800
1374     replay_barrier ost1
1375 #   OBD_FAIL_OST_LLOG_RECOVERY_TIMEOUT 0x221
1376     unlinkmany $DIR/$tdir/$tfile-%d 800
1377     do_facet ost "sysctl -w lustre.fail_loc=0x80000221"
1378     facet_failover ost1
1379     sleep 10
1380     fail ost1
1381     sleep 30
1382     do_facet ost "sysctl -w lustre.fail_loc=0x0"
1383     $CHECKSTAT -t file $DIR/$tdir/$tfile-* && return 1
1384     rmdir $DIR/$tdir
1385 }
1386 run_test 61a "test race llog recovery vs llog cleanup"
1387
1388 #test race  mds llog sync vs llog cleanup
1389 test_61b() {
1390 #   OBD_FAIL_MDS_LLOG_SYNC_TIMEOUT 0x13a
1391     do_facet mds "sysctl -w lustre.fail_loc=0x8000013a"
1392     facet_failover mds
1393     sleep 10
1394     fail mds
1395     do_facet client dd if=/dev/zero of=$DIR/$tfile bs=4k count=1 || return 1
1396 }
1397 run_test 61b "test race mds llog sync vs llog cleanup"
1398
1399 #test race  cancel cookie cb vs llog cleanup
1400 test_61c() {
1401 #   OBD_FAIL_OST_CANCEL_COOKIE_TIMEOUT 0x222
1402     touch $DIR/$tfile
1403     do_facet ost "sysctl -w lustre.fail_loc=0x80000222"
1404     rm $DIR/$tfile
1405     sleep 10
1406     fail ost1
1407 }
1408 run_test 61c "test race mds llog sync vs llog cleanup"
1409
1410 #Adaptive Timeouts
1411 at_start() #bug 3055
1412 {
1413     if [ -z "$ATOLDBASE" ]; then
1414         local at_history=$(do_facet mds "find /sys/ -name at_history")
1415         [ -z "$at_history" ] && skip "missing /sys/.../at_history " && return 1
1416         ATOLDBASE=$(do_facet mds "cat $at_history")
1417         # speed up the timebase so we can check decreasing AT
1418         do_facet mds "echo 8 >> $at_history"
1419         do_facet ost1 "echo 8 >> $at_history"
1420     fi
1421 }
1422
1423 test_65a() #bug 3055
1424 {
1425     at_start || return 0
1426     $LCTL dk > /dev/null
1427     debugsave
1428     sysctl -w lnet.debug="+other"
1429     # slow down a request
1430     do_facet mds sysctl -w lustre.fail_val=30000
1431 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1432     do_facet mds sysctl -w lustre.fail_loc=0x8000050a
1433     createmany -o $DIR/$tfile 10 > /dev/null
1434     unlinkmany $DIR/$tfile 10 > /dev/null
1435     # check for log message
1436     $LCTL dk | grep "Early reply #" || error "No early reply"
1437     # client should show 30s estimates
1438     grep portal $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts
1439     sleep 9
1440     grep portal $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts
1441 }
1442 run_test 65a "AT: verify early replies"
1443
1444 test_65b() #bug 3055
1445 {
1446     at_start || return 0
1447     # turn on D_ADAPTTO
1448     debugsave
1449     sysctl -w lnet.debug="+other"
1450     $LCTL dk > /dev/null
1451     # slow down bulk i/o
1452     do_facet ost1 sysctl -w lustre.fail_val=30
1453 #define OBD_FAIL_OST_BRW_PAUSE_PACK      0x224
1454     do_facet ost1 sysctl -w lustre.fail_loc=0x224
1455
1456     rm -f $DIR/$tfile
1457     lfs setstripe $DIR/$tfile --index=0 --count=1
1458     # force some real bulk transfer
1459     multiop $DIR/$tfile oO_CREAT:O_RDWR:O_SYNC:w4096c
1460
1461     do_facet ost1 sysctl -w lustre.fail_loc=0
1462     # check for log message
1463     $LCTL dk | grep "Early reply #" || error "No early reply"
1464     debugrestore
1465     # client should show 30s estimates
1466     grep portal $LPROC/osc/${FSNAME}-OST0000-osc-*/timeouts
1467 }
1468 run_test 65b "AT: verify early replies on packed reply / bulk"
1469
1470 test_66a() #bug 3055
1471 {
1472     at_start || return 0
1473     grep "portal 12" $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts
1474     # adjust 5s at a time so no early reply is sent (within deadline)
1475     do_facet mds "sysctl -w lustre.fail_val=5000"
1476 #define OBD_FAIL_PTLRPC_PAUSE_REQ        0x50a
1477     do_facet mds "sysctl -w lustre.fail_loc=0x8000050a"
1478     createmany -o $DIR/$tfile 20 > /dev/null
1479     unlinkmany $DIR/$tfile 20 > /dev/null
1480     grep "portal 12" $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts
1481     do_facet mds "sysctl -w lustre.fail_val=10000"
1482     do_facet mds "sysctl -w lustre.fail_loc=0x8000050a"
1483     createmany -o $DIR/$tfile 20 > /dev/null
1484     unlinkmany $DIR/$tfile 20 > /dev/null
1485     grep "portal 12" $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts
1486     do_facet mds "sysctl -w lustre.fail_loc=0"
1487     sleep 9
1488     createmany -o $DIR/$tfile 20 > /dev/null
1489     unlinkmany $DIR/$tfile 20 > /dev/null
1490     grep portal $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts | grep "portal 12"
1491     CUR=$(awk '/portal 12/ {print $5}' $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts)
1492     WORST=$(awk '/portal 12/ {print $7}' $LPROC/mdc/${FSNAME}-MDT0000-mdc-*/timeouts)
1493     echo "Current MDT timeout $CUR, worst $WORST"
1494     [ $CUR -lt $WORST ] || error "Current $CUR should be less than worst $WORST"
1495 }
1496 run_test 66a "AT: verify MDT service time adjusts with no early replies"
1497
1498 test_66b() #bug 3055
1499 {
1500     at_start || return 0
1501     ORIG=$(awk '/network/ {print $4}' $LPROC/mdc/lustre-*/timeouts)
1502     sysctl -w lustre.fail_val=$(($ORIG + 5))
1503 #define OBD_FAIL_PTLRPC_PAUSE_REP      0x50c
1504     sysctl -w lustre.fail_loc=0x50c
1505     ls $DIR/$tfile > /dev/null 2>&1
1506     sysctl -w lustre.fail_loc=0
1507     CUR=$(awk '/network/ {print $4}' $LPROC/mdc/${FSNAME}-*/timeouts)
1508     WORST=$(awk '/network/ {print $6}' $LPROC/mdc/${FSNAME}-*/timeouts)
1509     echo "network timeout orig $ORIG, cur $CUR, worst $WORST"
1510     [ $WORST -gt $ORIG ] || error "Worst $WORST should be worse than orig $ORIG"
1511 }
1512 run_test 66b "AT: verify net latency adjusts"
1513
1514 test_67a() #bug 3055
1515 {
1516     at_start || return 0
1517     CONN1=$(awk '/_connect/ {total+=$2} END {print total}' $LPROC/osc/*/stats)
1518     # sleeping threads may drive values above this
1519     do_facet ost1 "sysctl -w lustre.fail_val=400"
1520 #define OBD_FAIL_PTLRPC_PAUSE_REQ    0x50a
1521     do_facet ost1 "sysctl -w lustre.fail_loc=0x50a"
1522     createmany -o $DIR/$tfile 20 > /dev/null
1523     unlinkmany $DIR/$tfile 20 > /dev/null
1524     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1525     CONN2=$(awk '/_connect/ {total+=$2} END {print total}' $LPROC/osc/*/stats)
1526     ATTEMPTS=$(($CONN2 - $CONN1))
1527     echo "$ATTEMPTS osc reconnect attemps on gradual slow"
1528     [ $ATTEMPTS -gt 0 ] && error "AT should have prevented reconnect"
1529     return 0
1530 }
1531 run_test 67a "AT: verify slow request processing doesn't induce reconnects"
1532
1533 test_67b() #bug 3055
1534 {
1535     at_start || return 0
1536     CONN1=$(awk '/_connect/ {total+=$2} END {print total}' $LPROC/osc/*/stats)
1537 #define OBD_FAIL_OST_PAUSE_CREATE        0x223
1538     do_facet ost1 "sysctl -w lustre.fail_val=20000"
1539     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000223"
1540     cp /etc/profile $DIR/$tfile || error "cp failed"
1541     client_reconnect
1542     cat $LPROC/ost/OSS/ost_create/timeouts
1543     log "phase 2"
1544     CONN2=$(awk '/_connect/ {total+=$2} END {print total}' $LPROC/osc/*/stats)
1545     ATTEMPTS=$(($CONN2 - $CONN1))
1546     echo "$ATTEMPTS osc reconnect attemps on instant slow"
1547     # do it again; should not timeout
1548     do_facet ost1 "sysctl -w lustre.fail_loc=0x80000223"
1549     cp /etc/profile $DIR/$tfile || error "cp failed"
1550     do_facet ost1 "sysctl -w lustre.fail_loc=0"
1551     client_reconnect
1552     cat $LPROC/ost/OSS/ost_create/timeouts
1553     CONN3=$(awk '/_connect/ {total+=$2} END {print total}' $LPROC/osc/*/stats)
1554     ATTEMPTS=$(($CONN3 - $CONN2))
1555     echo "$ATTEMPTS osc reconnect attemps on 2nd slow"
1556     [ $ATTEMPTS -gt 0 ] && error_ignore 13721 "AT should have prevented reconnect"
1557     return 0
1558 }
1559 run_test 67b "AT: verify instant slowdown doesn't induce reconnects"
1560
1561 test_68 () #bug 13813
1562 {
1563     at_start || return 0
1564     local ldlm_enqueue_min=$(find /sys -name ldlm_enqueue_min)
1565     [ -z "$ldlm_enqueue_min" ] && skip "missing /sys/.../ldlm_enqueue_min" && return 0
1566     local ENQ_MIN=$(cat $ldlm_enqueue_min)
1567     echo $TIMEOUT >> $ldlm_enqueue_min
1568     rm -f $DIR/${tfile}_[1-2]
1569     lfs setstripe $DIR/$tfile --index=0 --count=1
1570 #define OBD_FAIL_LDLM_PAUSE_CANCEL       0x312
1571     sysctl -w lustre.fail_val=$(($TIMEOUT - 1))
1572     sysctl -w lustre.fail_loc=0x80000312
1573     cp /etc/profile $DIR/${tfile}_1 || error "1st cp failed $?"
1574     sysctl -w lustre.fail_val=$((TIMEOUT * 3 / 2))
1575     sysctl -w lustre.fail_loc=0x80000312
1576     cp /etc/profile $DIR/${tfile}_2 || error "2nd cp failed $?"
1577     sysctl -w lustre.fail_loc=0
1578     echo $ENQ_MIN >> $ldlm_enqueue_min
1579     return 0
1580 }
1581 run_test 68 "AT: verify slowing locks"
1582
1583 if [ -n "$ATOLDBASE" ]; then
1584     at_history=$(do_facet mds "find /sys/ -name at_history")
1585     do_facet mds "echo $ATOLDBASE >> $at_history" || true
1586     do_facet ost1 "echo $ATOLDBASE >> $at_history" || true
1587 fi
1588 # end of AT tests includes above lines
1589
1590 equals_msg `basename $0`: test complete, cleaning up
1591 check_and_cleanup_lustre
1592 [ -f "$TESTSUITELOG" ] && cat $TESTSUITELOG || true