lustre/tests/replay-single.sh

   1 #!/bin/sh
   2
   3 set -e
   4
   5 #
   6 # This test needs to be run on the client
   7 #
   8
   9 LUSTRE=${LUSTRE:-`dirname $0`/..}
  10 . $LUSTRE/tests/test-framework.sh
  11
  12 init_test_env $@
  13
  14 . ${CONFIG:=$LUSTRE/tests/cfg/lmv.sh}
  15
  16 # Skip these tests
  17 ALWAYS_EXCEPT=""
  18
  19
  20 gen_config() {
  21     rm -f $XMLCONFIG
  22
  23     if [ "$MDSCOUNT" -gt 1 ]; then
  24         add_lmv lmv1
  25         for num in `seq $MDSCOUNT`; do
  26             MDSDEV=$TMP/mds${num}-`hostname`
  27             add_mds mds$num --dev $MDSDEV --size $MDSSIZE --master --lmv lmv1
  28         done
  29         add_lov_to_lmv lov1 lmv1 --stripe_sz $STRIPE_BYTES \
  30             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  31         add_ost ost --lov lov1 --dev $OSTDEV --size $OSTSIZE
  32         add_ost ost2 --lov lov1 --dev ${OSTDEV}-2 --size $OSTSIZE
  33         add_client client --lmv lmv1 --lov lov1 --path $MOUNT
  34     else
  35         add_mds mds1 --dev $MDSDEV --size $MDSSIZE
  36         if [ ! -z "$mdsfailover_HOST" ]; then
  37              add_mdsfailover mds --dev $MDSDEV --size $MDSSIZE
  38         fi
  39
  40         add_lov lov1 mds1 --stripe_sz $STRIPE_BYTES \
  41             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  42         add_ost ost --lov lov1 --dev $OSTDEV --size $OSTSIZE
  43         add_ost ost2 --lov lov1 --dev ${OSTDEV}-2 --size $OSTSIZE
  44         add_client client --mds mds1_svc --lov lov1 --path $MOUNT
  45     fi
  46
  47     add_lov lov1 mds --stripe_sz $STRIPE_BYTES \
  48         --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  49     add_ost ost --lov lov1 --dev $OSTDEV --size $OSTSIZE
  50     add_ost ost2 --lov lov1 --dev ${OSTDEV}-2 --size $OSTSIZE
  51     add_client client mds --lov lov1 --path $MOUNT
  52 }
  53
  54 build_test_filter
  55
  56 cleanup() {
  57     # make sure we are using the primary MDS, so the config log will
  58     # be able to clean up properly.
  59     activemds=`facet_active mds`
  60     if [ $activemds != "mds" ]; then
  61         fail mds
  62     fi
  63     zconf_umount `hostname` $MOUNT
  64     if [ "$MDSCOUNT" -gt 1 ]; then
  65         for num in `seq $MDSCOUNT`; do
  66             stop mds$num ${FORCE} $MDSLCONFARGS
  67         done
  68     else
  69         stop mds ${FORCE} $MDSLCONFARGS
  70     fi
  71     stop ost2 ${FORCE} --dump cleanup.log
  72     stop ost ${FORCE} --dump cleanup.log
  73 }
  74
  75 if [ "$ONLY" == "cleanup" ]; then
  76     sysctl -w portals.debug=0 || true
  77     cleanup
  78     exit
  79 fi
  80
  81 SETUP=${SETUP:-"setup"}
  82 CLEANUP=${CLEANUP:-"cleanup"}
  83
  84 setup() {
  85     gen_config
  86
  87     start ost --reformat $OSTLCONFARGS
  88     start ost2 --reformat $OSTLCONFARGS
  89     [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  90     start mds $MDSLCONFARGS --reformat
  91     grep " $MOUNT " /proc/mounts || zconf_mount `hostname` $MOUNT
  92 }
  93
  94 $SETUP
  95
  96 if [ "$ONLY" == "setup" ]; then
  97     exit 0
  98 fi
  99
 100 mkdir -p $DIR
 101
 102 test_0() {
 103     replay_barrier mds1
 104     fail mds1
 105 }
 106 run_test 0 "empty replay"
 107
 108 test_0b() {
 109     # this test attempts to trigger a race in the precreation code,
 110     # and must run before any other objects are created on the filesystem
 111     fail ost
 112     createmany -o $DIR/$tfile 20 || return 1
 113     unlinkmany $DIR/$tfile 20 || return 2
 114 }
 115 run_test 0b "ensure object created after recover exists. (3284)"
 116
 117 test_1() {
 118     replay_barrier mds2
 119     mcreate $DIR/$tfile
 120     fail mds2
 121     $CHECKSTAT -t file $DIR/$tfile || return 1
 122     rm $DIR/$tfile
 123 }
 124 run_test 1 "simple create"
 125
 126 test_2a() {
 127     replay_barrier mds
 128     touch $DIR/$tfile
 129     fail mds
 130     $CHECKSTAT -t file $DIR/$tfile || return 1
 131     rm $DIR/$tfile
 132 }
 133 run_test 2a "touch"
 134
 135 test_2b() {
 136     ./mcreate $DIR/$tfile
 137     replay_barrier mds
 138     touch $DIR/$tfile
 139     fail mds
 140     $CHECKSTAT -t file $DIR/$tfile || return 1
 141     rm $DIR/$tfile
 142 }
 143 run_test 2b "touch"
 144
 145 test_3a() {
 146     replay_barrier mds
 147     mcreate $DIR/$tfile
 148     o_directory $DIR/$tfile
 149     fail mds
 150     $CHECKSTAT -t file $DIR/$tfile || return 2
 151     rm $DIR/$tfile
 152 }
 153 run_test 3a "replay failed open(O_DIRECTORY)"
 154
 155 test_3b() {
 156     replay_barrier mds
 157 #define OBD_FAIL_MDS_OPEN_PACK | OBD_FAIL_ONCE
 158     do_facet mds "sysctl -w lustre.fail_loc=0x80000114"
 159     touch $DIR/$tfile
 160     do_facet mds "sysctl -w lustre.fail_loc=0"
 161     fail mds
 162     $CHECKSTAT -t file $DIR/$tfile && return 2
 163     return 0
 164 }
 165 run_test 3b "replay failed open -ENOMEM"
 166
 167 test_3c() {
 168     replay_barrier mds
 169 #define OBD_FAIL_MDS_ALLOC_OBDO | OBD_FAIL_ONCE
 170     do_facet mds "sysctl -w lustre.fail_loc=0x80000128"
 171     touch $DIR/$tfile
 172     do_facet mds "sysctl -w lustre.fail_loc=0"
 173     fail mds
 174
 175     $CHECKSTAT -t file $DIR/$tfile && return 2
 176     return 0
 177 }
 178 run_test 3c "replay failed open -ENOMEM"
 179
 180 test_4() {
 181     replay_barrier mds
 182     for i in `seq 10`; do
 183         echo "tag-$i" > $DIR/$tfile-$i
 184     done
 185     fail mds
 186     for i in `seq 10`; do
 187       grep -q "tag-$i" $DIR/$tfile-$i || error "$tfile-$i"
 188     done
 189 }
 190 run_test 4 "|x| 10 open(O_CREAT)s"
 191
 192 test_4b() {
 193     replay_barrier mds
 194     rm -rf $DIR/$tfile-*
 195     fail mds
 196     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 197 }
 198 run_test 4b "|x| rm 10 files"
 199
 200 # The idea is to get past the first block of precreated files on both
 201 # osts, and then replay.
 202 test_5() {
 203     replay_barrier mds
 204     for i in `seq 220`; do
 205         echo "tag-$i" > $DIR/$tfile-$i
 206     done
 207     fail mds
 208     for i in `seq 220`; do
 209       grep -q "tag-$i" $DIR/$tfile-$i || error "f1c-$i"
 210     done
 211     rm -rf $DIR/$tfile-*
 212     sleep 3
 213     # waiting for commitment of removal
 214 }
 215 run_test 5 "|x| 220 open(O_CREAT)"
 216
 217
 218 test_6() {
 219     replay_barrier mds
 220     mkdir $DIR/$tdir
 221     mcreate $DIR/$tdir/$tfile
 222     fail mds
 223     $CHECKSTAT -t dir $DIR/$tdir || return 1
 224     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 225     sleep 2
 226     # waiting for log process thread
 227 }
 228 run_test 6 "mkdir + contained create"
 229
 230 test_6b() {
 231     replay_barrier mds
 232     rm -rf $DIR/$tdir
 233     fail mds
 234     $CHECKSTAT -t dir $DIR/$tdir && return 1 || true
 235 }
 236 run_test 6b "|X| rmdir"
 237
 238 test_7() {
 239     mkdir $DIR/$tdir
 240     replay_barrier mds
 241     mcreate $DIR/$tdir/$tfile
 242     fail mds
 243     $CHECKSTAT -t dir $DIR/$tdir || return 1
 244     $CHECKSTAT -t file $DIR/$tdir/$tfile || return 2
 245     rm -fr $DIR/$tdir
 246 }
 247 run_test 7 "mkdir |X| contained create"
 248
 249 test_8() {
 250     replay_barrier mds
 251     multiop $DIR/$tfile mo_c &
 252     MULTIPID=$!
 253     sleep 1
 254     fail mds
 255     ls $DIR/$tfile
 256     $CHECKSTAT -t file $DIR/$tfile || return 1
 257     kill -USR1 $MULTIPID || return 2
 258     wait $MULTIPID || return 3
 259     rm $DIR/$tfile
 260 }
 261 run_test 8 "creat open |X| close"
 262
 263 test_9() {
 264     replay_barrier mds
 265     mcreate $DIR/$tfile
 266     local old_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 267     fail mds
 268     local new_inum=`ls -i $DIR/$tfile | awk '{print $1}'`
 269
 270     echo " old_inum == $old_inum, new_inum == $new_inum"
 271     if [ $old_inum -eq $new_inum  ] ;
 272     then
 273         echo " old_inum and new_inum match"
 274     else
 275         echo "!!!! old_inum and new_inum NOT match"
 276         return 1
 277     fi
 278     rm $DIR/$tfile
 279 }
 280 run_test 9  "|X| create (same inum/gen)"
 281
 282 test_10() {
 283     mcreate $DIR/$tfile
 284     replay_barrier mds
 285     mv $DIR/$tfile $DIR/$tfile-2
 286     rm -f $DIR/$tfile
 287     fail mds
 288     $CHECKSTAT $DIR/$tfile && return 1
 289     $CHECKSTAT $DIR/$tfile-2 ||return 2
 290     rm $DIR/$tfile-2
 291     return 0
 292 }
 293 run_test 10 "create |X| rename unlink"
 294
 295 test_11() {
 296     mcreate $DIR/$tfile
 297     echo "old" > $DIR/$tfile
 298     mv $DIR/$tfile $DIR/$tfile-2
 299     replay_barrier mds
 300     echo "new" > $DIR/$tfile
 301     grep new $DIR/$tfile
 302     grep old $DIR/$tfile-2
 303     fail mds
 304     grep new $DIR/$tfile || return 1
 305     grep old $DIR/$tfile-2 || return 2
 306 }
 307 run_test 11 "create open write rename |X| create-old-name read"
 308
 309 test_12() {
 310     mcreate $DIR/$tfile
 311     multiop $DIR/$tfile o_tSc &
 312     pid=$!
 313     # give multiop a chance to open
 314     sleep 1
 315     rm -f $DIR/$tfile
 316     replay_barrier mds
 317     kill -USR1 $pid
 318     wait $pid || return 1
 319
 320     fail mds
 321     [ -e $DIR/$tfile ] && return 2
 322     return 0
 323 }
 324 run_test 12 "open, unlink |X| close"
 325
 326
 327 # 1777 - replay open after committed chmod that would make
 328 #        a regular open a failure
 329 test_13() {
 330     mcreate $DIR/$tfile
 331     multiop $DIR/$tfile O_wc &
 332     pid=$!
 333     # give multiop a chance to open
 334     sleep 1
 335     chmod 0 $DIR/$tfile
 336     $CHECKSTAT -p 0 $DIR/$tfile
 337     replay_barrier mds
 338     fail mds
 339     kill -USR1 $pid
 340     wait $pid || return 1
 341
 342     $CHECKSTAT -s 1 -p 0 $DIR/$tfile || return 2
 343     return 0
 344 }
 345 run_test 13 "open chmod 0 |x| write close"
 346
 347 test_14() {
 348     multiop $DIR/$tfile O_tSc &
 349     pid=$!
 350     # give multiop a chance to open
 351     sleep 1
 352     rm -f $DIR/$tfile
 353     replay_barrier mds
 354     kill -USR1 $pid || return 1
 355     wait $pid || return 2
 356
 357     fail mds
 358     [ -e $DIR/$tfile ] && return 3
 359     return 0
 360 }
 361 run_test 14 "open(O_CREAT), unlink |X| close"
 362
 363 test_15() {
 364     multiop $DIR/$tfile O_tSc &
 365     pid=$!
 366     # give multiop a chance to open
 367     sleep 1
 368     rm -f $DIR/$tfile
 369     replay_barrier mds
 370     touch $DIR/g11 || return 1
 371     kill -USR1 $pid
 372     wait $pid || return 2
 373
 374     fail mds
 375     [ -e $DIR/$tfile ] && return 3
 376     touch $DIR/h11 || return 4
 377     return 0
 378 }
 379 run_test 15 "open(O_CREAT), unlink |X|  touch new, close"
 380
 381
 382 test_16() {
 383     replay_barrier mds
 384     mcreate $DIR/$tfile
 385     munlink $DIR/$tfile
 386     mcreate $DIR/$tfile-2
 387     fail mds
 388     [ -e $DIR/$tfile ] && return 1
 389     [ -e $DIR/$tfile-2 ] || return 2
 390     munlink $DIR/$tfile-2 || return 3
 391 }
 392 run_test 16 "|X| open(O_CREAT), unlink, touch new,  unlink new"
 393
 394 test_17() {
 395     replay_barrier mds
 396     multiop $DIR/$tfile O_c &
 397     pid=$!
 398     # give multiop a chance to open
 399     sleep 1
 400     fail mds
 401     kill -USR1 $pid || return 1
 402     wait $pid || return 2
 403     $CHECKSTAT -t file $DIR/$tfile || return 3
 404     rm $DIR/$tfile
 405 }
 406 run_test 17 "|X| open(O_CREAT), |replay| close"
 407
 408 test_18() {
 409     replay_barrier mds
 410     multiop $DIR/$tfile O_tSc &
 411     pid=$!
 412     # give multiop a chance to open
 413     sleep 1
 414     rm -f $DIR/$tfile
 415     touch $DIR/$tfile-2 || return 1
 416     echo "pid: $pid will close"
 417     kill -USR1 $pid
 418     wait $pid || return 2
 419
 420     fail mds
 421     [ -e $DIR/$tfile ] && return 3
 422     [ -e $DIR/$tfile-2 ] || return 4
 423     # this touch frequently fails
 424     touch $DIR/$tfile-3 || return 5
 425     munlink $DIR/$tfile-2 || return 6
 426     munlink $DIR/$tfile-3 || return 7
 427     return 0
 428 }
 429 run_test 18 "|X| open(O_CREAT), unlink, touch new, close, touch, unlink"
 430
 431 # bug 1855 (a simpler form of test_11 above)
 432 test_19() {
 433     replay_barrier mds
 434     mcreate $DIR/$tfile
 435     echo "old" > $DIR/$tfile
 436     mv $DIR/$tfile $DIR/$tfile-2
 437     grep old $DIR/$tfile-2
 438     fail mds
 439     grep old $DIR/$tfile-2 || return 2
 440 }
 441 run_test 19 "|X| mcreate, open, write, rename "
 442
 443 test_20() {
 444     replay_barrier mds
 445     multiop $DIR/$tfile O_tSc &
 446     pid=$!
 447     # give multiop a chance to open
 448     sleep 1
 449     rm -f $DIR/$tfile
 450
 451     fail mds
 452     kill -USR1 $pid
 453     wait $pid || return 1
 454     [ -e $DIR/$tfile ] && return 2
 455     return 0
 456 }
 457 run_test 20 "|X| open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 458
 459 test_21() {
 460     replay_barrier mds
 461     multiop $DIR/$tfile O_tSc &
 462     pid=$!
 463     # give multiop a chance to open
 464     sleep 1
 465     rm -f $DIR/$tfile
 466     touch $DIR/g11 || return 1
 467
 468     fail mds
 469     kill -USR1 $pid
 470     wait $pid || return 2
 471     [ -e $DIR/$tfile ] && return 3
 472     touch $DIR/h11 || return 4
 473     return 0
 474 }
 475 run_test 21 "|X| open(O_CREAT), unlink touch new, replay, close (test mds_cleanup_orphans)"
 476
 477 test_22() {
 478     multiop $DIR/$tfile O_tSc &
 479     pid=$!
 480     # give multiop a chance to open
 481     sleep 1
 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 $DIR/$tfile O_tSc &
 496     pid=$!
 497     # give multiop a chance to open
 498     sleep 1
 499
 500     replay_barrier mds
 501     rm -f $DIR/$tfile
 502     touch $DIR/g11 || return 1
 503
 504     fail mds
 505     kill -USR1 $pid
 506     wait $pid || return 2
 507     [ -e $DIR/$tfile ] && return 3
 508     touch $DIR/h11 || return 4
 509     return 0
 510 }
 511 run_test 23 "open(O_CREAT), |X| unlink touch new, replay, close (test mds_cleanup_orphans)"
 512
 513 test_24() {
 514     multiop $DIR/$tfile O_tSc &
 515     pid=$!
 516     # give multiop a chance to open
 517     sleep 1
 518
 519     replay_barrier mds
 520     fail mds
 521     rm -f $DIR/$tfile
 522     kill -USR1 $pid
 523     wait $pid || return 1
 524     [ -e $DIR/$tfile ] && return 2
 525     return 0
 526 }
 527 run_test 24 "open(O_CREAT), replay, unlink, close (test mds_cleanup_orphans)"
 528
 529 test_25() {
 530     multiop $DIR/$tfile O_tSc &
 531     pid=$!
 532     # give multiop a chance to open
 533     sleep 1
 534     rm -f $DIR/$tfile
 535
 536     replay_barrier mds
 537     fail mds
 538     kill -USR1 $pid
 539     wait $pid || return 1
 540     [ -e $DIR/$tfile ] && return 2
 541     return 0
 542 }
 543 run_test 25 "open(O_CREAT), unlink, replay, close (test mds_cleanup_orphans)"
 544
 545 test_26() {
 546     replay_barrier mds
 547     multiop $DIR/$tfile-1 O_tSc &
 548     pid1=$!
 549     multiop $DIR/$tfile-2 O_tSc &
 550     pid2=$!
 551     # give multiop a chance to open
 552     sleep 1
 553     rm -f $DIR/$tfile-1
 554     rm -f $DIR/$tfile-2
 555     kill -USR1 $pid2
 556     wait $pid2 || return 1
 557
 558     fail mds
 559     kill -USR1 $pid1
 560     wait $pid1 || return 2
 561     [ -e $DIR/$tfile-1 ] && return 3
 562     [ -e $DIR/$tfile-2 ] && return 4
 563     return 0
 564 }
 565 run_test 26 "|X| open(O_CREAT), unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 566
 567 test_27() {
 568     replay_barrier mds
 569     multiop $DIR/$tfile-1 O_tSc &
 570     pid1=$!
 571     multiop $DIR/$tfile-2 O_tSc &
 572     pid2=$!
 573     # give multiop a chance to open
 574     sleep 1
 575     rm -f $DIR/$tfile-1
 576     rm -f $DIR/$tfile-2
 577
 578     fail mds
 579     kill -USR1 $pid1
 580     wait $pid1 || return 1
 581     kill -USR1 $pid2
 582     wait $pid2 || return 2
 583     [ -e $DIR/$tfile-1 ] && return 3
 584     [ -e $DIR/$tfile-2 ] && return 4
 585     return 0
 586 }
 587 run_test 27 "|X| open(O_CREAT), unlink two, replay, close two (test mds_cleanup_orphans)"
 588
 589 test_28() {
 590     multiop $DIR/$tfile-1 O_tSc &
 591     pid1=$!
 592     multiop $DIR/$tfile-2 O_tSc &
 593     pid2=$!
 594     # give multiop a chance to open
 595     sleep 1
 596     replay_barrier mds
 597     rm -f $DIR/$tfile-1
 598     rm -f $DIR/$tfile-2
 599     kill -USR1 $pid2
 600     wait $pid2 || return 1
 601
 602     fail mds
 603     kill -USR1 $pid1
 604     wait $pid1 || return 2
 605     [ -e $DIR/$tfile-1 ] && return 3
 606     [ -e $DIR/$tfile-2 ] && return 4
 607     return 0
 608 }
 609 run_test 28 "open(O_CREAT), |X| unlink two, close one, replay, close one (test mds_cleanup_orphans)"
 610
 611 test_29() {
 612     multiop $DIR/$tfile-1 O_tSc &
 613     pid1=$!
 614     multiop $DIR/$tfile-2 O_tSc &
 615     pid2=$!
 616     # give multiop a chance to open
 617     sleep 1
 618     replay_barrier mds
 619     rm -f $DIR/$tfile-1
 620     rm -f $DIR/$tfile-2
 621
 622     fail mds
 623     kill -USR1 $pid1
 624     wait $pid1 || return 1
 625     kill -USR1 $pid2
 626     wait $pid2 || return 2
 627     [ -e $DIR/$tfile-1 ] && return 3
 628     [ -e $DIR/$tfile-2 ] && return 4
 629     return 0
 630 }
 631 run_test 29 "open(O_CREAT), |X| unlink two, replay, close two (test mds_cleanup_orphans)"
 632
 633 test_30() {
 634     multiop $DIR/$tfile-1 O_tSc &
 635     pid1=$!
 636     multiop $DIR/$tfile-2 O_tSc &
 637     pid2=$!
 638     # give multiop a chance to open
 639     sleep 1
 640     rm -f $DIR/$tfile-1
 641     rm -f $DIR/$tfile-2
 642
 643     replay_barrier mds
 644     fail mds
 645     kill -USR1 $pid1
 646     wait $pid1 || return 1
 647     kill -USR1 $pid2
 648     wait $pid2 || return 2
 649     [ -e $DIR/$tfile-1 ] && return 3
 650     [ -e $DIR/$tfile-2 ] && return 4
 651     return 0
 652 }
 653 run_test 30 "open(O_CREAT) two, unlink two, replay, close two (test mds_cleanup_orphans)"
 654
 655 test_31() {
 656     multiop $DIR/$tfile-1 O_tSc &
 657     pid1=$!
 658     multiop $DIR/$tfile-2 O_tSc &
 659     pid2=$!
 660     # give multiop a chance to open
 661     sleep 1
 662     rm -f $DIR/$tfile-1
 663
 664     replay_barrier mds
 665     rm -f $DIR/$tfile-2
 666     fail mds
 667     kill -USR1 $pid1
 668     wait $pid1 || return 1
 669     kill -USR1 $pid2
 670     wait $pid2 || return 2
 671     [ -e $DIR/$tfile-1 ] && return 3
 672     [ -e $DIR/$tfile-2 ] && return 4
 673     return 0
 674 }
 675 run_test 31 "open(O_CREAT) two, unlink one, |X| unlink one, close two (test mds_cleanup_orphans)"
 676
 677 # tests for bug 2104; completion without crashing is success.  The close is
 678 # stale, but we always return 0 for close, so the app never sees it.
 679 test_32() {
 680     multiop $DIR/$tfile O_c &
 681     pid1=$!
 682     multiop $DIR/$tfile O_c &
 683     pid2=$!
 684     # give multiop a chance to open
 685     sleep 1
 686     mds_evict_client
 687     df $MOUNT || df $MOUNT || return 1
 688     kill -USR1 $pid1
 689     kill -USR1 $pid2
 690     sleep 1
 691     return 0
 692 }
 693 run_test 32 "close() notices client eviction; close() after client eviction"
 694
 695 # Abort recovery before client complete
 696 test_33() {
 697     replay_barrier mds
 698     touch $DIR/$tfile
 699     fail_abort mds
 700     # this file should be gone, because the replay was aborted
 701     $CHECKSTAT -t file $DIR/$tfile && return 1
 702     return 0
 703 }
 704 run_test 33 "abort recovery before client does replay"
 705
 706 test_34() {
 707     multiop $DIR/$tfile O_c &
 708     pid=$!
 709     # give multiop a chance to open
 710     sleep 1
 711     rm -f $DIR/$tfile
 712
 713     replay_barrier mds
 714     fail_abort mds
 715     kill -USR1 $pid
 716     [ -e $DIR/$tfile ] && return 1
 717     sync
 718     return 0
 719 }
 720 run_test 34 "abort recovery before client does replay (test mds_cleanup_orphans)"
 721
 722 # bug 2278 - generate one orphan on OST, then destroy it during recovery from llog
 723 test_35() {
 724     touch $DIR/$tfile
 725
 726 #define OBD_FAIL_MDS_REINT_NET_REP       0x119
 727     do_facet mds "sysctl -w lustre.fail_loc=0x80000119"
 728     rm -f $DIR/$tfile &
 729     sleep 1
 730     sync
 731     sleep 1
 732     # give a chance to remove from MDS
 733     fail_abort mds
 734     $CHECKSTAT -t file $DIR/$tfile && return 1 || true
 735 }
 736 run_test 35 "test recovery from llog for unlink op"
 737
 738 # b=2432 resent cancel after replay uses wrong cookie,
 739 # so don't resend cancels
 740 test_36() {
 741     replay_barrier mds
 742     touch $DIR/$tfile
 743     checkstat $DIR/$tfile
 744     facet_failover mds
 745     cancel_lru_locks MDC
 746     if dmesg | grep "unknown lock cookie"; then
 747         echo "cancel after replay failed"
 748         return 1
 749     fi
 750 }
 751 run_test 36 "don't resend cancel"
 752
 753 # b=2368
 754 # directory orphans can't be unlinked from PENDING directory
 755 test_37() {
 756     rmdir $DIR/$tfile 2>/dev/null
 757     multiop $DIR/$tfile dD_c &
 758     pid=$!
 759     # give multiop a chance to open
 760     sleep 1
 761     rmdir $DIR/$tfile
 762
 763     replay_barrier mds
 764     # clear the dmesg buffer so we only see errors from this recovery
 765     dmesg -c >/dev/null
 766     fail_abort mds
 767     kill -USR1 $pid
 768     dmesg | grep  "mds_unlink_orphan.*error .* unlinking orphan" && return 1
 769     sync
 770     return 0
 771 }
 772 run_test 37 "abort recovery before client does replay (test mds_cleanup_orphans for directories)"
 773
 774 test_38() {
 775     createmany -o $DIR/$tfile-%d 800
 776     unlinkmany $DIR/$tfile-%d 0 400
 777     replay_barrier mds
 778     fail mds
 779     unlinkmany $DIR/$tfile-%d 400 400
 780     sleep 2
 781     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 782 }
 783 run_test 38 "test recovery from unlink llog (test llog_gen_rec) "
 784
 785 test_39() {
 786     createmany -o $DIR/$tfile-%d 800
 787     replay_barrier mds
 788     unlinkmany $DIR/$tfile-%d 0 400
 789     fail mds
 790     unlinkmany $DIR/$tfile-%d 400 400
 791     sleep 2
 792     $CHECKSTAT -t file $DIR/$tfile-* && return 1 || true
 793 }
 794 run_test 39 "test recovery from unlink llog (test llog_gen_rec) "
 795
 796 count_ost_writes() {
 797         cat /proc/fs/lustre/osc/*/stats |
 798             awk -vwrites=0 '/ost_write/ { writes += $2 } END { print writes; }'
 799 }
 800
 801 #b=2477,2532
 802 test_40(){
 803     $LCTL mark multiop $MOUNT/$tfile OS_c
 804     multiop $MOUNT/$tfile OS_c  &
 805     PID=$!
 806     writeme -s $MOUNT/${tfile}-2 &
 807     WRITE_PID=$!
 808     sleep 1
 809     facet_failover mds
 810 #define OBD_FAIL_MDS_CONNECT_NET         0x117
 811     do_facet mds "sysctl -w lustre.fail_loc=0x80000117"
 812     kill -USR1 $PID
 813     stat1=`count_ost_writes`
 814     sleep $TIMEOUT
 815     stat2=`count_ost_writes`
 816     echo "$stat1, $stat2"
 817     if [ $stat1 -lt $stat2 ]; then
 818        echo "writes continuing during recovery"
 819        RC=0
 820     else
 821        echo "writes not continuing during recovery, bug 2477"
 822        RC=4
 823     fi
 824     echo "waiting for writeme $WRITE_PID"
 825     kill $WRITE_PID
 826     wait $WRITE_PID
 827
 828     echo "waiting for multiop $PID"
 829     wait $PID || return 2
 830     do_facet client munlink $MOUNT/$tfile  || return 3
 831     do_facet client munlink $MOUNT/${tfile}-2  || return 3
 832     return $RC
 833 }
 834 run_test 40 "cause recovery in ptlrpc, ensure IO continues"
 835
 836
 837 #b=2814
 838 # make sure that a read to one osc doesn't try to double-unlock its page just
 839 # because another osc is invalid.  trigger_group_io used to mistakenly return
 840 # an error if any oscs were invalid even after having successfully put rpcs
 841 # on valid oscs.  This was fatal if the caller was ll_readpage who unlocked
 842 # the page, guarnateeing that the unlock from the RPC completion would
 843 # assert on trying to unlock the unlocked page.
 844 test_41() {
 845     local f=$MOUNT/$tfile
 846     # make sure the start of the file is ost1
 847     lfs setstripe $f $((128 * 1024)) 0 0
 848     do_facet client dd if=/dev/zero of=$f bs=4k count=1 || return 3
 849     cancel_lru_locks OSC
 850     # fail ost2 and read from ost1
 851     local osc2_dev=`$LCTL device_list | \
 852                 awk '(/ost2.*client_facet/){print $4}' `
 853     $LCTL --device %$osc2_dev deactivate
 854     do_facet client dd if=$f of=/dev/null bs=4k count=1 || return 3
 855     $LCTL --device %$osc2_dev activate
 856     return 0
 857 }
 858 run_test 41 "read from a valid osc while other oscs are invalid"
 859
 860 # test MDS recovery after ost failure
 861 test_42() {
 862     blocks=`df $MOUNT | tail -n 1 | awk '{ print $1 }'`
 863     createmany -o $DIR/$tfile-%d 800
 864     replay_barrier ost
 865     unlinkmany $DIR/$tfile-%d 0 400
 866     facet_failover ost
 867
 868     # osc is evicted, fs is smaller
 869     blocks_after=`df $MOUNT | tail -n 1 | awk '{ print $1 }'`
 870     [ $blocks_after -lt $blocks ] || return 1
 871     echo wait for MDS to timeout and recover
 872     sleep $((TIMEOUT * 2))
 873     unlinkmany $DIR/$tfile-%d 400 400
 874     $CHECKSTAT -t file $DIR/$tfile-* && return 2 || true
 875 }
 876 run_test 42 "recovery after ost failure"
 877
 878 # b=2530
 879 # timeout in MDS/OST recovery RPC will LBUG MDS
 880 test_43() {
 881     replay_barrier mds
 882
 883     # OBD_FAIL_OST_CREATE_NET 0x204
 884     do_facet ost "sysctl -w lustre.fail_loc=0x80000204"
 885     facet_failover mds
 886     df $MOUNT || return 1
 887     sleep 10
 888     do_facet ost "sysctl -w lustre.fail_loc=0"
 889
 890     return 0
 891 }
 892 run_test 43 "mds osc import failure during recovery; don't LBUG"
 893
 894 test_44() {
 895     mdcdev=`awk '/mds_svc_MNT/ {print $1}' < /proc/fs/lustre/devices`
 896     do_facet mds "sysctl -w lustre.fail_loc=0x80000701"
 897     $LCTL --device $mdcdev recover
 898     df $MOUNT
 899     do_facet mds "sysctl -w lustre.fail_loc=0"
 900     return 0
 901 }
 902 run_test 44 "race in target handle connect"
 903
 904 # Handle failed close
 905 test_45() {
 906     mdcdev=`awk '/mds_svc_MNT/ {print $1}' < /proc/fs/lustre/devices`
 907     $LCTL --device $mdcdev recover
 908
 909     multiop $DIR/$tfile O_c &
 910     pid=$!
 911     sleep 1
 912
 913     # This will cause the CLOSE to fail before even
 914     # allocating a reply buffer
 915     $LCTL --device $mdcdev deactivate
 916
 917     # try the close
 918     kill -USR1 $pid
 919     wait $pid || return 1
 920
 921     $LCTL --device $mdcdev activate
 922
 923     $CHECKSTAT -t file $DIR/$tfile || return 2
 924     return 0
 925 }
 926 run_test 45 "Handle failed close"
 927
 928 test_46() {
 929     dmesg -c >/dev/null
 930     drop_reply "touch $DIR/$tfile"
 931     fail mds
 932     # ironically, the previous test, 45, will cause a real forced close,
 933     # so just look for one for this test
 934     dmesg | grep -i "force closing client file handle for $tfile" && return 1
 935     return 0
 936 }
 937 run_test 46 "Don't leak file handle after open resend (3325)"
 938
 939 # b=2824
 940 test_47() {
 941
 942     # create some files to make sure precreate has been done on all
 943     # OSTs. (just in case this test is run independently)
 944     createmany -o $DIR/$tfile 20  || return 1
 945
 946     # OBD_FAIL_OST_CREATE_NET 0x204
 947     fail ost
 948     do_facet ost "sysctl -w lustre.fail_loc=0x80000204"
 949     df $MOUNT || return 2
 950
 951     # let the MDS discover the OST failure, attempt to recover, fail
 952     # and recover again.
 953     sleep $((3 * TIMEOUT))
 954
 955     # Without 2824, this createmany would hang
 956     createmany -o $DIR/$tfile 20 || return 3
 957     unlinkmany $DIR/$tfile 20 || return 4
 958
 959     do_facet ost "sysctl -w lustre.fail_loc=0"
 960     return 0
 961 }
 962 run_test 47 "MDS->OSC failure during precreate cleanup (2824)"
 963
 964 equals_msg test complete, cleaning up
 965 $CLEANUP
 966