lustre/tests/replay-dual.sh

   1 #!/bin/sh
   2
   3 set -e
   4
   5 LUSTRE=${LUSTRE:-`dirname $0`/..}
   6 . $LUSTRE/tests/test-framework.sh
   7
   8 init_test_env $@
   9
  10 . ${CONFIG:=$LUSTRE/tests/cfg/lmv.sh}
  11
  12 # Skip these tests
  13 # 21 - open vs. unlink out of order replay: isn't solved yet
  14 ALWAYS_EXCEPT="21"
  15
  16 SETUP=${SETUP:-"setup"}
  17 CLEANUP=${CLEANUP:-"cleanup"}
  18
  19 gen_config() {
  20     rm -f $XMLCONFIG
  21     if [ "$MDSCOUNT" -gt 1 ]; then
  22         add_lmv lmv1_svc
  23         for mds in `mds_list`; do
  24             MDSDEV=$TMP/${mds}-`hostname`
  25             add_mds $mds --dev $MDSDEV --size $MDSSIZE --lmv lmv1_svc
  26         done
  27         add_lov_to_lmv lov1 lmv1_svc --stripe_sz $STRIPE_BYTES \
  28             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  29         MDS=lmv1
  30     else
  31         add_mds mds1 --dev $MDSDEV --size $MDSSIZE
  32         add_lov lov1 mds1 --stripe_sz $STRIPE_BYTES \
  33             --stripe_cnt $STRIPES_PER_OBJ --stripe_pattern 0
  34         MDS=mds1
  35     fi
  36
  37     add_ost ost --lov lov1 --dev $OSTDEV --size $OSTSIZE --failover
  38     add_ost ost2 --lov lov1 --dev ${OSTDEV}-2 --size $OSTSIZE  --failover
  39     add_client client  ${MDS} --lov lov1 --path $MOUNT
  40 }
  41
  42 build_test_filter
  43
  44 SETUP=${SETUP:-"setup"}
  45 CLEANUP=${CLEANUP:-"cleanup"}
  46
  47 cleanup() {
  48     # make sure we are using the primary MDS, so the config log will
  49     # be able to clean up properly.
  50     activemds=`facet_active mds1`
  51     if [ $activemds != "mds1" ]; then
  52         fail mds1
  53     fi
  54
  55     umount $MOUNT2 || true
  56     umount $MOUNT || true
  57     rmmod llite
  58
  59     # b=3941
  60     # In mds recovery, the mds will clear orphans in ost by
  61     # mds_lov_clear_orphan, which will sent the request to ost and waiting for
  62     # the reply, if we stop mds at this time, we will got the obd_refcount > 1
  63     # errors, because mds_lov_clear_orphan grab a export of mds,
  64     # so the obd_refcount of mds will not be zero. So, wait a while before
  65     # stop mds. This bug needs further work.
  66     for mds in `mds_list`; do
  67         sleep 5
  68         stop $mds ${FORCE} $MDSLCONFARGS
  69     done
  70     stop ost2 ${FORCE}
  71     stop ost ${FORCE}  --dump cleanup-dual.log
  72     stop_lgssd
  73     stop_lsvcgssd
  74 }
  75
  76 if [ "$ONLY" == "cleanup" ]; then
  77     sysctl -w portals.debug=0
  78     cleanup
  79     exit
  80 fi
  81
  82 setup() {
  83     gen_config
  84
  85     start_krb5_kdc || exit 1
  86     start_lsvcgssd || exit 2
  87     start_lgssd || exit 3
  88     start ost --reformat $OSTLCONFARGS
  89     PINGER=`cat /proc/fs/lustre/pinger`
  90
  91     if [ "$PINGER" != "on" ]; then
  92         echo "ERROR: Lustre must be built with --enable-pinger for replay-dual"
  93         stop ost
  94         exit 1
  95     fi
  96
  97     start ost2 --reformat $OSTLCONFARGS
  98     [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
  99     for mds in `mds_list`; do
 100         start $mds --reformat $MDSLCONFARGS
 101     done
 102     grep " $MOUNT " /proc/mounts || zconf_mount `hostname` $MOUNT
 103     grep " $MOUNT2 " /proc/mounts || zconf_mount `hostname` $MOUNT2
 104
 105     echo $TIMEOUT > /proc/sys/lustre/timeout
 106     echo $UPCALL > /proc/sys/lustre/upcall
 107 }
 108
 109 $SETUP
 110 [ "$DAEMONFILE" ] && $LCTL debug_daemon start $DAEMONFILE $DAEMONSIZE
 111
 112
 113 test_1() {
 114     touch $MOUNT1/a
 115     replay_barrier mds1
 116     touch $MOUNT2/b
 117
 118     fail mds1
 119     checkstat $MOUNT2/a || return 1
 120     checkstat $MOUNT1/b || return 2
 121     rm $MOUNT2/a $MOUNT1/b
 122     checkstat $MOUNT1/a && return 3
 123     checkstat $MOUNT2/b && return 4
 124     return 0
 125 }
 126
 127 run_test 1 "|X| simple create"
 128
 129
 130 test_2() {
 131     replay_barrier mds1
 132     mkdir $MOUNT1/adir
 133
 134     fail mds1
 135     checkstat $MOUNT2/adir || return 1
 136     rmdir $MOUNT2/adir
 137     checkstat $MOUNT2/adir && return 2
 138     return 0
 139 }
 140
 141 run_test 2 "|X| mkdir adir"
 142
 143 test_3() {
 144     replay_barrier mds1
 145     mkdir $MOUNT1/adir
 146     mkdir $MOUNT2/adir/bdir
 147
 148     fail mds1
 149     checkstat $MOUNT2/adir      || return 1
 150     checkstat $MOUNT1/adir/bdir || return 2
 151     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 152     checkstat $MOUNT1/adir      && return 3
 153     checkstat $MOUNT2/adir/bdir && return 4
 154     return 0
 155 }
 156
 157 run_test 3 "|X| mkdir adir, mkdir adir/bdir "
 158
 159 test_4() {
 160     mkdir $MOUNT1/adir
 161     replay_barrier mds1
 162     mkdir $MOUNT1/adir  && return 1
 163     mkdir $MOUNT2/adir/bdir
 164
 165     fail mds1
 166     checkstat $MOUNT2/adir      || return 2
 167     checkstat $MOUNT1/adir/bdir || return 3
 168
 169     rmdir $MOUNT2/adir/bdir $MOUNT1/adir
 170     checkstat $MOUNT1/adir      && return 4
 171     checkstat $MOUNT2/adir/bdir && return 5
 172     return 0
 173 }
 174
 175 run_test 4 "|X| mkdir adir (-EEXIST), mkdir adir/bdir "
 176
 177
 178 test_5() {
 179     # multiclient version of replay_single.sh/test_8
 180     mcreate $MOUNT1/a
 181     multiop $MOUNT2/a o_tSc &
 182     pid=$!
 183     # give multiop a chance to open
 184     sleep 1
 185     rm -f $MOUNT1/a
 186     replay_barrier mds1
 187     kill -USR1 $pid
 188     wait $pid || return 1
 189
 190     fail mds1
 191     [ -e $MOUNT2/a ] && return 2
 192     return 0
 193 }
 194 run_test 5 "open, unlink |X| close"
 195
 196
 197 test_6() {
 198     mcreate $MOUNT1/a
 199     multiop $MOUNT2/a o_c &
 200     pid1=$!
 201     multiop $MOUNT1/a o_c &
 202     pid2=$!
 203     # give multiop a chance to open
 204     sleep 1
 205     rm -f $MOUNT1/a
 206     replay_barrier mds1
 207     kill -USR1 $pid1
 208     wait $pid1 || return 1
 209
 210     fail mds1
 211     kill -USR1 $pid2
 212     wait $pid2 || return 1
 213     [ -e $MOUNT2/a ] && return 2
 214     return 0
 215 }
 216 run_test 6 "open1, open2, unlink |X| close1 [fail mds] close2"
 217
 218 test_6b() {
 219     mcreate $MOUNT1/a
 220     multiop $MOUNT2/a o_c &
 221     pid1=$!
 222     multiop $MOUNT1/a o_c &
 223     pid2=$!
 224     # give multiop a chance to open
 225     sleep 1
 226     rm -f $MOUNT1/a
 227     replay_barrier mds1
 228     kill -USR1 $pid2
 229     wait $pid2 || return 1
 230
 231     fail mds1
 232     kill -USR1 $pid1
 233     wait $pid1 || return 1
 234     [ -e $MOUNT2/a ] && return 2
 235     return 0
 236 }
 237 run_test 6b "open1, open2, unlink |X| close2 [fail mds] close1"
 238
 239 test_8() {
 240     replay_barrier mds1
 241     drop_reint_reply "mcreate $MOUNT1/$tfile"    || return 1
 242     fail mds1
 243     checkstat $MOUNT2/$tfile || return 2
 244     rm $MOUNT1/$tfile || return 3
 245
 246     return 0
 247 }
 248 run_test 8 "replay of resent request"
 249
 250 test_9() {
 251     replay_barrier mds1
 252     mcreate $MOUNT1/$tfile-1
 253     mcreate $MOUNT2/$tfile-2
 254     # drop first reint reply
 255     sysctl -w lustre.fail_loc=0x80000119
 256     fail mds1
 257     sysctl -w lustre.fail_loc=0
 258
 259     rm $MOUNT1/$tfile-[1,2] || return 1
 260
 261     return 0
 262 }
 263 run_test 9 "resending a replayed create"
 264
 265 test_10() {
 266     mcreate $MOUNT1/$tfile-1
 267     replay_barrier mds1
 268     munlink $MOUNT1/$tfile-1
 269     mcreate $MOUNT2/$tfile-2
 270     # drop first reint reply
 271     sysctl -w lustre.fail_loc=0x80000119
 272     fail mds1
 273     sysctl -w lustre.fail_loc=0
 274
 275     checkstat $MOUNT1/$tfile-1 && return 1
 276     checkstat $MOUNT1/$tfile-2 || return 2
 277     rm $MOUNT1/$tfile-2
 278
 279     return 0
 280 }
 281 run_test 10 "resending a replayed unlink"
 282
 283 test_11() {
 284     replay_barrier mds1
 285     mcreate $MOUNT1/$tfile-1
 286     mcreate $MOUNT2/$tfile-2
 287     mcreate $MOUNT1/$tfile-3
 288     mcreate $MOUNT2/$tfile-4
 289     mcreate $MOUNT1/$tfile-5
 290     # drop all reint replies for a while
 291     sysctl -w lustre.fail_loc=0x0119
 292     facet_failover mds1
 293     #sleep for while, let both clients reconnect and timeout
 294     sleep $((TIMEOUT * 2))
 295     sysctl -w lustre.fail_loc=0
 296
 297     rm $MOUNT1/$tfile-[1-5] || return 1
 298
 299     return 0
 300 }
 301 run_test 11 "both clients timeout during replay"
 302
 303 test_12() {
 304     replay_barrier mds1
 305
 306     multiop $DIR/$tfile mo_c &
 307     MULTIPID=$!
 308     sleep 5
 309
 310     # drop first enqueue
 311     sysctl -w lustre.fail_loc=0x80000302
 312     facet_failover mds1
 313     df $MOUNT || return 1
 314     sysctl -w lustre.fail_loc=0
 315
 316     ls $DIR/$tfile
 317     $CHECKSTAT -t file $DIR/$tfile || return 2
 318     kill -USR1 $MULTIPID || return 3
 319     wait $MULTIPID || return 4
 320     rm $DIR/$tfile
 321
 322     return 0
 323 }
 324 run_test 12 "open resend timeout"
 325
 326 test_13() {
 327     multiop $DIR/$tfile mo_c &
 328     MULTIPID=$!
 329     sleep 5
 330
 331     replay_barrier mds1
 332
 333     kill -USR1 $MULTIPID || return 3
 334     wait $MULTIPID || return 4
 335
 336     # drop close
 337     sysctl -w lustre.fail_loc=0x80000115
 338     facet_failover mds1
 339     df $MOUNT || return 1
 340     sysctl -w lustre.fail_loc=0
 341
 342     ls $DIR/$tfile
 343     $CHECKSTAT -t file $DIR/$tfile || return 2
 344     rm $DIR/$tfile
 345
 346     return 0
 347 }
 348 run_test 13 "close resend timeout"
 349
 350
 351 test_14() {
 352     replay_barrier mds1
 353     createmany -o $MOUNT1/$tfile- 25
 354     createmany -o $MOUNT2/$tfile-2- 1
 355     createmany -o $MOUNT1/$tfile-3- 25
 356     umount $MOUNT2
 357
 358     facet_failover mds1
 359     # expect failover to fail
 360     df $MOUNT && return 1
 361     sleep 1
 362
 363     # first 25 files shouuld have been
 364     # replayed
 365     sleep 2
 366     unlinkmany $MOUNT1/$tfile- 25 || return 2
 367
 368     zconf_mount `hostname` $MOUNT2
 369     return 0
 370 }
 371 run_test 14 "timeouts waiting for lost client during replay"
 372
 373 test_15() {
 374     replay_barrier mds1
 375     createmany -o $MOUNT1/$tfile- 25
 376     createmany -o $MOUNT2/$tfile-2- 1
 377     umount $MOUNT2
 378
 379     facet_failover mds1
 380     df $MOUNT || return 1
 381     sleep 1
 382
 383     unlinkmany $MOUNT1/$tfile- 25 || return 2
 384
 385     zconf_mount `hostname` $MOUNT2
 386     return 0
 387 }
 388 run_test 15 "timeout waiting for lost client during replay, 1 client completes"
 389 test_16() {
 390     replay_barrier mds1
 391     createmany -o $MOUNT1/$tfile- 25
 392     createmany -o $MOUNT2/$tfile-2- 1
 393     umount $MOUNT2
 394
 395     facet_failover mds1
 396     sleep $TIMEOUT
 397     facet_failover mds1
 398     df $MOUNT || return 1
 399     sleep 1
 400
 401     unlinkmany $MOUNT1/$tfile- 25 || return 2
 402
 403     zconf_mount `hostname` $MOUNT2
 404     return 0
 405
 406 }
 407 #run_test 16 "fail MDS during recovery (3571)"
 408
 409 test_17() {
 410     createmany -o $MOUNT1/$tfile- 25
 411     createmany -o $MOUNT2/$tfile-2- 1
 412
 413     # Make sure the disconnect is lost
 414     replay_barrier ost
 415     umount $MOUNT2
 416
 417     echo -1 > /proc/sys/portals/debug
 418     facet_failover ost
 419     sleep $TIMEOUT
 420     facet_failover ost
 421     df $MOUNT || return 1
 422     sleep 1
 423
 424     unlinkmany $MOUNT1/$tfile- 25 || return 2
 425
 426     zconf_mount `hostname` $MOUNT2
 427     return 0
 428
 429 }
 430 #Still not support ost fail over
 431 #run_test 17 "fail OST during recovery (3571)"
 432
 433 test_18 () {
 434     replay_barrier mds1
 435     multiop $MOUNT2/$tfile O_c &
 436     pid2=$!
 437     multiop $MOUNT1/$tfile O_c &
 438     pid1=$!
 439     # give multiop a chance to open
 440     sleep 1
 441     kill -USR1 $pid2
 442     kill -USR1 $pid1
 443     sleep 1
 444     umount $MOUNT2
 445     facet_failover mds1
 446     df || df ||  return 1
 447     zconf_mount `hostname` $MOUNT2
 448 }
 449 run_test 18 "replay open, Abort recovery, don't assert (3892)"
 450
 451 # cleanup with blocked enqueue fails until timer elapses (MDS busy), wait for
 452 # itexport NOW=0
 453
 454 test_20() {     # bug 3822 - evicting client with enqueued lock
 455        mkdir -p $MOUNT1/$tdir
 456        touch $MOUNT1/$tdir/f0
 457 #define OBD_FAIL_LDLM_ENQUEUE_BLOCKED    0x30b
 458        statmany -s $MOUNT1/$tdir/f 500 &
 459        OPENPID=$!
 460        NOW=`date +%s`
 461        do_facet mds1 sysctl -w lustre.fail_loc=0x8000030b  # hold enqueue
 462        sleep 1
 463 #define OBD_FAIL_LDLM_BL_CALLBACK        0x305
 464        do_facet client sysctl -w lustre.fail_loc=0x80000305  # drop cb, evict
 465        cancel_lru_locks MDC
 466        usleep 500 # wait to ensure first client is one that will be evicted
 467        openfile -f O_RDONLY $MOUNT2/$tdir/f0
 468        wait $OPENPID
 469        dmesg | grep "entering recovery in server" && \
 470                error "client not evicted" || true
 471 }
 472 run_test 20 "ldlm_handle_enqueue succeeds on evicted export (3822)"
 473
 474 # $1 - number of mountpoint
 475 # $2 - mds
 476 function find_dev_for_fs_and_mds()
 477 {
 478         local fsuuid=`cat /proc/fs/lustre/llite/fs$1/uuid`
 479         $LCTL device_list | awk "/mdc.*$2.*$fsuuid/ {print \$4}"
 480 }
 481
 482 test_21() {
 483         mdc1dev=`find_dev_for_fs_and_mds 0 mds1`
 484         mdc2dev=`find_dev_for_fs_and_mds 1 mds1`
 485         multiop $MOUNT1/f21 O
 486         cancel_lru_locks MDC
 487         # generate IT_OPEN to be replayed against existing file
 488         multiop $MOUNT1/f21 o_Sc &
 489         pid=$!
 490
 491         # IT_OPEN will be committed by the failover time
 492         replay_barrier mds1
 493
 494         # generate MDS_REINT_UNLINK to be replayed
 495         rm -f $MOUNT2/f21 || return 1
 496
 497         # disable recovery on the both clients
 498         $LCTL --device %$mdc1dev disable_recovery
 499         $LCTL --device %$mdc2dev disable_recovery
 500         facet_failover mds1
 501
 502         # let unlink to be replayed first
 503         $LCTL --device %$mdc2dev enable_recovery
 504         sleep $((TIMEOUT/2))
 505
 506         # now let open to be replaye
 507         $LCTL --device %$mdc1dev enable_recovery
 508         kill -USR1 $pid
 509         wait $pid || return 2
 510 }
 511 run_test 21 "open vs. unlink out of order replay"
 512
 513 if [ "$ONLY" != "setup" ]; then
 514         equals_msg test complete, cleaning up
 515         if [ $NOW ]; then
 516             SLEEP=$((`date +%s` - $NOW))
 517             [ $SLEEP -lt $TIMEOUT ] && sleep $SLEEP
 518         fi
 519         $CLEANUP
 520 fi