lustre/tests/replay-single.sh

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