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