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