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